Send _list of_ players in progress reports

5 files changed, 35 insertions, 32 deletions

diff --git a/server/bot/src/pathfinding.rs b/server/bot/src/pathfinding.rs
index 41bc79c7..f4cf36d4 100644
--- a/server/bot/src/pathfinding.rs
+++ b/server/bot/src/pathfinding.rs
@@ -46,7 +46,7 @@ impl Path {
         self.segments.is_empty()
     }
     pub fn is_stuck(&self) -> bool {
-        self.seg_time > 5.
+        self.seg_time > 3.
     }
     pub fn remaining_segments(&self) -> usize {
         self.segments.len()
diff --git a/server/client-lib/src/lib.rs b/server/client-lib/src/lib.rs
index 4639d2ea..515b2e38 100644
--- a/server/client-lib/src/lib.rs
+++ b/server/client-lib/src/lib.rs
@@ -25,19 +25,19 @@ use hurrycurry_protocol::{
 };
 use spatial_index::SpatialIndex;
 use std::{
-    collections::{HashMap, HashSet},
+    collections::{BTreeSet, HashMap, HashSet},
     sync::Arc,
     time::Instant,
 };
 
 use crate::gamedata_index::GamedataIndex;
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct Involvement {
     pub position: f32,
     pub speed: f32,
     pub recipe: RecipeIndex,
-    pub player: Option<PlayerID>,
+    pub players: BTreeSet<PlayerID>,
     pub warn: bool,
 }
 
@@ -145,13 +145,13 @@ impl Game {
             PacketC::SetProgress {
                 item,
                 position,
-                player,
+                players,
                 speed,
                 warn,
             } => {
                 if let Some(Some(item)) = self.get_item(item) {
                     item.active = Some(Involvement {
-                        player,
+                        players,
                         speed,
                         warn,
                         position,
diff --git a/server/protocol/src/lib.rs b/server/protocol/src/lib.rs
index ee5651ce..82476eab 100644
--- a/server/protocol/src/lib.rs
+++ b/server/protocol/src/lib.rs
@@ -18,7 +18,7 @@
 use glam::{IVec2, Vec2};
 use serde::{Deserialize, Deserializer, Serialize};
 use std::{
-    collections::{BTreeMap, HashSet},
+    collections::{BTreeMap, BTreeSet, HashSet},
     sync::LazyLock,
 };
 
@@ -241,7 +241,7 @@ pub enum PacketC {
         item: ItemLocation,
     },
     SetProgress {
-        player: Option<PlayerID>,
+        players: BTreeSet<PlayerID>,
         item: ItemLocation,
         position: f32,
         speed: f32,
diff --git a/server/src/interaction.rs b/server/src/interaction.rs
index 7d7376cb..dfe62121 100644
--- a/server/src/interaction.rs
+++ b/server/src/interaction.rs
@@ -18,7 +18,7 @@
 use hurrycurry_client_lib::{Involvement, Item, gamedata_index::GamedataIndex};
 use hurrycurry_protocol::{Gamedata, ItemLocation, PacketC, PlayerID, Recipe, Score, TileIndex};
 use log::info;
-use std::collections::VecDeque;
+use std::collections::{BTreeSet, VecDeque};
 
 #[allow(clippy::too_many_arguments)]
 pub fn interact(
@@ -37,19 +37,22 @@ pub fn interact(
 ) {
     if other.is_none()
         && let Some(item) = this
-        && let Some(active) = &mut item.active
+        && let Some(inv) = &mut item.active
     {
-        let recipe = &data.recipe(active.recipe);
+        let recipe = &data.recipe(inv.recipe);
         if recipe.supports_tile(tile)
             && let Recipe::Active { outputs, speed, .. } = recipe
         {
             if edge {
-                active.speed += speed;
+                inv.players.extend(player);
             } else {
-                active.speed -= speed;
-                active.speed = active.speed.max(0.); // in case of "release without press" when items cool on active tile
+                if let Some(player) = player {
+                    inv.players.remove(&player);
+                }
             }
-            if active.position >= 1. {
+            inv.speed = speed * inv.players.len() as f32;
+
+            if inv.position >= 1. {
                 let this_had_item = this.is_some();
                 let other_had_item = other.is_some();
                 *other = outputs[0].map(|kind| Item { kind, active: None });
@@ -66,11 +69,11 @@ pub fn interact(
                 );
             } else {
                 packet_out.push_back(PacketC::SetProgress {
-                    player,
+                    players: inv.players.clone(),
                     item: this_loc,
-                    position: active.position,
-                    speed: active.speed,
-                    warn: active.warn,
+                    position: inv.position,
+                    speed: inv.speed,
+                    warn: inv.warn,
                 });
             }
             return;
@@ -92,7 +95,7 @@ pub fn interact(
                 {
                     info!("start active {ri}");
                     item.active = Some(Involvement {
-                        player,
+                        players: player.into_iter().collect(),
                         recipe: ri,
                         speed: *speed,
                         position: 0.,
@@ -107,7 +110,7 @@ pub fn interact(
                     let mut item = other.take().unwrap();
                     info!("start active {ri}");
                     item.active = Some(Involvement {
-                        player,
+                        players: player.into_iter().collect(),
                         recipe: ri,
                         speed: *speed,
                         position: 0.,
@@ -120,7 +123,7 @@ pub fn interact(
                         to: this_loc,
                     });
                     packet_out.push_back(PacketC::SetProgress {
-                        player,
+                        players: player.into_iter().collect(),
                         item: this_loc,
                         position: 0.,
                         speed: *speed,
@@ -248,7 +251,7 @@ pub fn tick_slot(
                 score.passive_recipes += 1;
                 *score_changed = true;
                 packet_out.push_back(PacketC::SetProgress {
-                    player: None,
+                    players: BTreeSet::new(),
                     warn: *warn,
                     item: slot_loc,
                     position: 1.,
@@ -266,7 +269,7 @@ pub fn tick_slot(
 
             if a.speed != prev_speed {
                 packet_out.push_back(PacketC::SetProgress {
-                    player: None,
+                    players: a.players.clone(),
                     position: a.position,
                     speed: a.speed,
                     warn: a.warn,
@@ -283,14 +286,14 @@ pub fn tick_slot(
                     && *input == item.kind
                 {
                     item.active = Some(Involvement {
-                        player: None,
+                        players: BTreeSet::new(),
                         recipe: ri,
                         position: 0.,
                         warn: *warn,
                         speed: *speed,
                     });
                     packet_out.push_back(PacketC::SetProgress {
-                        player: None,
+                        players: BTreeSet::new(),
                         position: 0.,
                         speed: *speed,
                         warn: *warn,
diff --git a/server/src/server.rs b/server/src/server.rs
index c0b32a1c..73035463 100644
--- a/server/src/server.rs
+++ b/server/src/server.rs
@@ -198,15 +198,15 @@ impl GameServerExt for Game {
                         item: Some(item.kind),
                     });
                     if let Some(Involvement {
-                        player,
+                        players: player,
                         position,
                         speed,
                         warn,
                         ..
-                    }) = item.active
+                    }) = item.active.clone()
                     {
                         out.push(PacketC::SetProgress {
-                            player,
+                            players: player,
                             item: ItemLocation::Player(id, Hand(i)),
                             position,
                             speed,
@@ -240,15 +240,15 @@ impl GameServerExt for Game {
                     item: Some(item.kind),
                 });
                 if let Some(Involvement {
-                    player,
+                    players,
                     position,
                     speed,
                     warn,
                     ..
-                }) = item.active
+                }) = item.active.clone()
                 {
                     out.push(PacketC::SetProgress {
-                        player,
+                        players: players.to_owned(),
                         item: ItemLocation::Tile(tile),
                         position,
                         speed,