passive works

1 files changed, 76 insertions, 51 deletions

diff --git a/server/src/game.rs b/server/src/game.rs
index d481dc4f..46bc0569 100644
--- a/server/src/game.rs
+++ b/server/src/game.rs
@@ -1,6 +1,6 @@
 use crate::{
     data::Gamedata,
-    interaction::interact,
+    interaction::{interact, tick_tile, InteractEffect, TickEffect},
     protocol::{ItemIndex, PacketC, PacketS, PlayerID, RecipeIndex, TileIndex},
 };
 use anyhow::{anyhow, bail, Result};
@@ -12,12 +12,14 @@ use std::{
     sync::Arc,
 };
 
+#[derive(Debug, PartialEq)]
 pub struct Involvement {
     pub recipe: RecipeIndex,
     pub progress: f32,
     pub working: usize,
 }
 
+#[derive(Debug, PartialEq)]
 pub struct Item {
     pub kind: ItemIndex,
     pub active: Option<Involvement>,
@@ -80,8 +82,8 @@ impl Game {
             });
             if let Some(item) = &tdata.item {
                 out.push(PacketC::ProduceItem {
-                    item: item.kind,
                     tile,
+                    item: item.kind,
                 })
             }
         }
@@ -111,7 +113,7 @@ impl Game {
                     .players
                     .remove(&player)
                     .ok_or(anyhow!("player does not exist"))?;
-                if let Some(id) = p.item {
+                if let Some(_id) = p.item {
                     // TODO place on ground
                 }
                 self.packet_out
@@ -121,6 +123,10 @@ impl Game {
                 self.packet_out
                     .push_back(PacketC::Position { player, pos, rot });
             }
+            PacketS::Collide { player, force } => {
+                self.packet_out
+                    .push_back(PacketC::Collide { player, force });
+            }
             PacketS::Interact { pos, edge } => {
                 info!("interact {pos:?} edge={edge}");
 
@@ -139,64 +145,83 @@ impl Game {
                 }
 
                 let tile_had_item = tile.item.is_some();
+                let player_had_item = tile.item.is_some();
 
-                interact(&self.data, edge, tile, player);
-
-                // interact(
-                //     &self.data,
-                //     edge,
-                //     tilekind,
-                //     &mut tile.active,
-                //     item,
-                //     hand,
-                //     |out| match out {
-                //         Out::Take(index) => {
-                //             info!("take");
-                //             let item = tile.items.remove(index);
-                //             player.hand = Some(item);
-                //             self.packet_out
-                //                 .push_back(PacketC::TakeItem { item, player: pid })
-                //         }
-                //         Out::Put => {
-                //             info!("put");
-                //             let hand = player.hand.take().unwrap();
-                //             tile.items.push(hand);
-                //             self.packet_out
-                //                 .push_back(PacketC::PutItem { item: hand, pos })
-                //         }
-                //         Out::Produce(kind) => {
-                //             info!("produce");
-                //             let id = self.item_id_counter;
-                //             self.item_id_counter += 1;
-                //             self.items.insert(id, kind);
-                //             tile.items.push(id);
-                //             self.packet_out
-                //                 .push_back(PacketC::ProduceItem { id, pos, kind });
-                //         }
-                //         Out::Consume(index) => {
-                //             info!("consume");
-                //             let id = tile.items.remove(index);
-                //             info!("left {:?}", tile.items);
-                //             self.packet_out.push_back(PacketC::ConsumeItem { id, pos });
-                //         }
-                //         Out::SetActive(progress) => {
-                //             self.packet_out.push_back(PacketC::SetActive {
-                //                 tile: pos,
-                //                 progress,
-                //             });
-                //         }
-                //     },
-                // );
+                if let Some(effect) = interact(&self.data, edge, tile, player) {
+                    match effect {
+                        InteractEffect::Put => self.packet_out.push_back(PacketC::PutItem {
+                            player: pid,
+                            tile: pos,
+                        }),
+                        InteractEffect::Take => self.packet_out.push_back(PacketC::TakeItem {
+                            player: pid,
+                            tile: pos,
+                        }),
+                        InteractEffect::Produce => {
+                            if tile_had_item {
+                                self.packet_out
+                                    .push_back(PacketC::ConsumeItem { tile: pos });
+                            }
+                            if player_had_item {
+                                self.packet_out.push_back(PacketC::PutItem {
+                                    player: pid,
+                                    tile: pos,
+                                });
+                                self.packet_out
+                                    .push_back(PacketC::ConsumeItem { tile: pos });
+                            }
+                            if let Some(i) = &player.item {
+                                self.packet_out.push_back(PacketC::ProduceItem {
+                                    tile: pos,
+                                    item: i.kind,
+                                });
+                                self.packet_out.push_back(PacketC::TakeItem {
+                                    player: pid,
+                                    tile: pos,
+                                })
+                            }
+                            if let Some(i) = &tile.item {
+                                self.packet_out.push_back(PacketC::ProduceItem {
+                                    tile: pos,
+                                    item: i.kind,
+                                });
+                            }
+                        }
+                    }
+                }
 
                 player.interacting = edge;
             }
-            PacketS::Collide { player, force } => {}
         }
         Ok(())
     }
 
     pub fn tick(&mut self, dt: f32) {
         for (&pos, tile) in &mut self.tiles {
+            if let Some(effect) = tick_tile(dt, &self.data, tile) {
+                match effect {
+                    TickEffect::Progress => self.packet_out.push_back(PacketC::SetActive {
+                        tile: pos,
+                        progress: tile
+                            .item
+                            .as_ref()
+                            .unwrap()
+                            .active
+                            .as_ref()
+                            .map(|i| i.progress),
+                    }),
+                    TickEffect::Produce => {
+                        self.packet_out
+                            .push_back(PacketC::ConsumeItem { tile: pos });
+                        if let Some(item) = &tile.item {
+                            self.packet_out.push_back(PacketC::ProduceItem {
+                                tile: pos,
+                                item: item.kind,
+                            });
+                        }
+                    }
+                }
+            }
             // let items = tile.items.iter().map(|e| self.items[e]).collect::<Vec<_>>();
             // tick_tile(
             //     dt,