refactor interact function and new progress proto

1 files changed, 36 insertions, 103 deletions

diff --git a/server/src/server.rs b/server/src/server.rs
index 63664354..109d5561 100644
--- a/server/src/server.rs
+++ b/server/src/server.rs
@@ -18,7 +18,7 @@
 use crate::{
     data::{DataIndex, Serverdata},
     entity::{Entities, EntityContext},
-    interaction::{interact, tick_slot, InteractEffect, TickEffect},
+    interaction::{interact, tick_slot, TickEffect},
     scoreboard::ScoreboardStore,
     ConnectionID,
 };
@@ -444,18 +444,18 @@ impl Server {
                         bail!("You shall not interact with customers.")
                     }
 
-                    interact_effect(
+                    interact(
                         &self.game.data,
                         edge,
+                        None,
                         &mut this.item,
                         ItemLocation::Player(base_pid),
                         &mut other.item,
                         ItemLocation::Player(pid),
-                        None,
-                        &mut self.packet_out,
                         &mut self.game.score,
                         &mut self.score_changed,
                         false,
+                        &mut self.packet_out,
                     )
                 } else {
                     let player = self
@@ -464,18 +464,18 @@ impl Server {
                         .get_mut(&pid)
                         .ok_or(anyhow!("The player does not exist"))?;
 
-                    interact_effect(
+                    interact(
                         &self.game.data,
                         edge,
+                        Some(tile.kind),
                         &mut tile.item,
                         ItemLocation::Tile(pos),
                         &mut player.item,
                         ItemLocation::Player(pid),
-                        Some(tile.kind),
-                        &mut self.packet_out,
                         &mut self.game.score,
                         &mut self.score_changed,
                         false,
+                        &mut self.packet_out,
                     )
                 }
             }
@@ -550,22 +550,27 @@ impl Server {
                 &mut self.game.score,
             ) {
                 match effect {
-                    TickEffect::Progress(warn) => self.packet_out.push_back(PacketC::SetProgress {
+                    TickEffect::Progress {
+                        speed,
+                        position,
+                        warn,
+                    } => self.packet_out.push_back(PacketC::SetProgress {
+                        position,
+                        speed,
                         warn,
                         item: ItemLocation::Tile(pos),
-                        progress: tile
-                            .item
-                            .as_ref()
-                            .unwrap()
-                            .active
-                            .as_ref()
-                            .map(|i| i.progress),
                     }),
+                    TickEffect::ClearProgress => {
+                        self.packet_out.push_back(PacketC::ClearProgress {
+                            item: ItemLocation::Tile(pos),
+                        })
+                    }
                     TickEffect::Produce => {
                         self.packet_out.push_back(PacketC::SetProgress {
                             warn: false,
                             item: ItemLocation::Tile(pos),
-                            progress: None,
+                            position: 1.,
+                            speed: 0.,
                         });
                         self.packet_out.push_back(PacketC::SetItem {
                             location: ItemLocation::Tile(pos),
@@ -611,22 +616,27 @@ impl Server {
                 &mut self.game.score,
             ) {
                 match effect {
-                    TickEffect::Progress(warn) => self.packet_out.push_back(PacketC::SetProgress {
+                    TickEffect::Progress {
+                        position,
+                        speed,
                         warn,
+                    } => self.packet_out.push_back(PacketC::SetProgress {
+                        warn,
+                        position,
+                        speed,
                         item: ItemLocation::Player(pid),
-                        progress: player
-                            .item
-                            .as_ref()
-                            .unwrap()
-                            .active
-                            .as_ref()
-                            .map(|i| i.progress),
                     }),
+                    TickEffect::ClearProgress => {
+                        self.packet_out.push_back(PacketC::ClearProgress {
+                            item: ItemLocation::Player(pid),
+                        })
+                    }
                     TickEffect::Produce => {
                         self.packet_out.push_back(PacketC::SetProgress {
                             warn: false,
                             item: ItemLocation::Player(pid),
-                            progress: None,
+                            position: 1.,
+                            speed: 0.,
                         });
                         self.packet_out.push_back(PacketC::SetItem {
                             location: ItemLocation::Player(pid),
@@ -649,7 +659,7 @@ impl Server {
                 if let Some(tile) = self.game.tiles.get(&pos) {
                     if let Some(item) = &tile.item {
                         if let Some(involvement) = &item.active {
-                            if involvement.progress >= 1. {
+                            if involvement.position >= 1. {
                                 players_auto_release.push(*pid);
                             }
                         }
@@ -727,80 +737,3 @@ impl Server {
             .sum()
     }
 }
-
-pub fn interact_effect(
-    data: &Gamedata,
-    edge: bool,
-    this: &mut Option<Item>,
-    this_loc: ItemLocation,
-    other: &mut Option<Item>,
-    other_loc: ItemLocation,
-    this_tile_kind: Option<TileIndex>,
-    packet_out: &mut VecDeque<PacketC>,
-    score: &mut Score,
-    score_changed: &mut bool,
-    automated: bool,
-) {
-    let this_had_item = this.is_some();
-    let other_had_item = other.is_some();
-
-    if let Some(effect) = interact(data, edge, this_tile_kind, this, other, score, automated) {
-        match effect {
-            InteractEffect::Put => {
-                info!("put {this_loc} <- {other_loc}");
-                packet_out.push_back(PacketC::MoveItem {
-                    from: other_loc,
-                    to: this_loc,
-                })
-            }
-            InteractEffect::Take => {
-                info!("take {this_loc} -> {other_loc}");
-                packet_out.push_back(PacketC::MoveItem {
-                    from: this_loc,
-                    to: other_loc,
-                })
-            }
-            InteractEffect::Produce => {
-                info!("produce {this_loc} <~ {other_loc}");
-                *score_changed = true;
-                if this_had_item {
-                    packet_out.push_back(PacketC::SetProgress {
-                        item: this_loc,
-                        progress: None,
-                        warn: false,
-                    });
-                    packet_out.push_back(PacketC::SetItem {
-                        location: this_loc,
-                        item: None,
-                    });
-                }
-                if other_had_item {
-                    packet_out.push_back(PacketC::MoveItem {
-                        from: other_loc,
-                        to: this_loc,
-                    });
-                    packet_out.push_back(PacketC::SetItem {
-                        location: this_loc,
-                        item: None,
-                    });
-                }
-                if let Some(i) = &other {
-                    packet_out.push_back(PacketC::SetItem {
-                        location: this_loc,
-                        item: Some(i.kind),
-                    });
-                    packet_out.push_back(PacketC::MoveItem {
-                        from: this_loc,
-                        to: other_loc,
-                    })
-                }
-                if let Some(i) = &this {
-                    packet_out.push_back(PacketC::SetItem {
-                        location: this_loc,
-                        item: Some(i.kind),
-                    });
-                }
-            }
-        }
-    }
-}