Change protocol and server to allow multiple players per connection (untested)

1 files changed, 61 insertions, 68 deletions

diff --git a/server/src/entity/customers/mod.rs b/server/src/entity/customers/mod.rs
index b5b9fa42..e6067110 100644
--- a/server/src/entity/customers/mod.rs
+++ b/server/src/entity/customers/mod.rs
@@ -31,7 +31,7 @@ use std::collections::{HashMap, VecDeque};
 #[derive(Debug, Clone)]
 pub struct Customers {
     demands: Vec<Demand>,
-    cpackets: VecDeque<(PlayerID, PacketS)>,
+    cpackets: VecDeque<PacketS>,
     chairs: HashMap<IVec2, bool>,
     customer_id_counter: PlayerID,
     customers: HashMap<PlayerID, CustomerState>,
@@ -84,13 +84,10 @@ impl EntityT for Customers {
             self.spawn_cooldown = 10. + random::<f32>() * 10.;
             self.customer_id_counter.0 -= 1;
             let id = self.customer_id_counter;
-            self.cpackets.push_back((
-                id,
-                PacketS::Join {
-                    name: faker::name::fr_fr::Name().fake(),
-                    character: -1 - (random::<u16>() as i32),
-                },
-            ));
+            self.cpackets.push_back(PacketS::Join {
+                name: faker::name::fr_fr::Name().fake(),
+                character: -1 - (random::<u16>() as i32),
+            });
             let chair = self.select_chair().ok_or(anyhow!("no free chair found"))?;
             let from = game.data.customer_spawn.as_ivec2();
             let path = find_path(&game.walkable, from, chair)
@@ -100,24 +97,22 @@ impl EntityT for Customers {
                 .insert(id, CustomerState::Entering { path, chair });
         }
         let mut customers_to_remove = Vec::new();
-        for (&id, state) in &mut self.customers {
-            let Some(player) = game.players.get_mut(&id) else {
+        for (&player, state) in &mut self.customers {
+            let Some(playerdata) = game.players.get_mut(&player) else {
                 continue;
             };
 
             match state {
                 CustomerState::Entering { path, chair } => {
-                    player.direction = path.next_direction(player.position());
+                    playerdata.direction = path.next_direction(playerdata.position());
                     if path.is_done() {
                         let demand = DemandIndex(random::<usize>() % self.demands.len());
-                        self.cpackets.push_back((
-                            id,
-                            PacketS::Communicate {
-                                message: Some(Message::Item(self.demands[demand.0].from)),
-                                persist: true,
-                            },
-                        ));
-                        info!("{id:?} -> waiting");
+                        self.cpackets.push_back(PacketS::Communicate {
+                            message: Some(Message::Item(self.demands[demand.0].from)),
+                            persist: true,
+                            player,
+                        });
+                        info!("{player:?} -> waiting");
                         *state = CustomerState::Waiting {
                             chair: *chair,
                             timeout: 90. + random::<f32>() * 60.,
@@ -130,26 +125,22 @@ impl EntityT for Customers {
                     demand,
                     timeout,
                 } => {
-                    player.direction = (chair.as_vec2() + 0.5) - player.position();
+                    playerdata.direction = (chair.as_vec2() + 0.5) - playerdata.position();
                     *timeout -= dt;
                     if *timeout <= 0. {
-                        self.cpackets.push_back((
-                            id,
-                            PacketS::Communicate {
-                                message: None,
-                                persist: true,
-                            },
-                        ));
-                        self.cpackets.push_back((
-                            id,
-                            PacketS::Communicate {
-                                message: Some(Message::Effect("angry".to_string())),
-                                persist: false,
-                            },
-                        ));
+                        self.cpackets.push_back(PacketS::Communicate {
+                            message: None,
+                            persist: true,
+                            player,
+                        });
+                        self.cpackets.push_back(PacketS::Communicate {
+                            message: Some(Message::Effect("angry".to_string())),
+                            persist: false,
+                            player,
+                        });
                         let path = find_path(
                             &game.walkable,
-                            player.position().as_ivec2(),
+                            playerdata.position().as_ivec2(),
                             game.data.customer_spawn.as_ivec2(),
                         )
                         .expect("no path to exit");
@@ -157,7 +148,7 @@ impl EntityT for Customers {
                         game.score.demands_failed += 1;
                         game.score.points -= 1;
                         game.score_changed = true;
-                        info!("{id:?} -> exiting");
+                        info!("{player:?} -> exiting");
                         *state = CustomerState::Exiting { path }
                     } else {
                         let demand_data = &self.demands[demand.0];
@@ -182,25 +173,23 @@ impl EntityT for Customers {
                                 }
                             });
                         if let Some(pos) = demand_pos {
-                            self.cpackets.push_back((
-                                id,
-                                PacketS::Communicate {
-                                    persist: true,
-                                    message: None,
-                                },
-                            ));
-                            self.cpackets.push_back((
-                                id,
-                                PacketS::Communicate {
-                                    message: Some(Message::Effect("satisfied".to_string())),
-                                    persist: false,
-                                },
-                            ));
-                            self.cpackets
-                                .push_back((id, PacketS::Interact { pos: Some(pos) }));
+                            self.cpackets.push_back(PacketS::Communicate {
+                                persist: true,
+                                message: None,
+                                player,
+                            });
+                            self.cpackets.push_back(PacketS::Communicate {
+                                message: Some(Message::Effect("satisfied".to_string())),
+                                persist: false,
+                                player,
+                            });
+                            self.cpackets.push_back(PacketS::Interact {
+                                pos: Some(pos),
+                                player,
+                            });
                             self.cpackets
-                                .push_back((id, PacketS::Interact { pos: None }));
-                            info!("{id:?} -> eating");
+                                .push_back(PacketS::Interact { pos: None, player });
+                            info!("{player:?} -> eating");
                             *state = CustomerState::Eating {
                                 demand: *demand,
                                 target: pos,
@@ -216,21 +205,25 @@ impl EntityT for Customers {
                     progress,
                     chair,
                 } => {
-                    player.direction = (chair.as_vec2() + 0.5) - player.position();
+                    playerdata.direction = (chair.as_vec2() + 0.5) - playerdata.position();
                     let demand = &self.demands[demand.0];
                     *progress += dt / demand.duration;
                     if *progress >= 1. {
-                        self.cpackets
-                            .push_back((id, PacketS::ReplaceHand { item: demand.to }));
+                        self.cpackets.push_back(PacketS::ReplaceHand {
+                            player,
+                            item: demand.to,
+                        });
                         if demand.to.is_some() {
+                            self.cpackets.push_back(PacketS::Interact {
+                                player,
+                                pos: Some(*target),
+                            });
                             self.cpackets
-                                .push_back((id, PacketS::Interact { pos: Some(*target) }));
-                            self.cpackets
-                                .push_back((id, PacketS::Interact { pos: None }));
+                                .push_back(PacketS::Interact { player, pos: None });
                         }
                         let path = find_path(
                             &game.walkable,
-                            player.position().as_ivec2(),
+                            playerdata.position().as_ivec2(),
                             game.data.customer_spawn.as_ivec2(),
                         )
                         .ok_or(anyhow!("no path to exit"))?;
@@ -238,16 +231,16 @@ impl EntityT for Customers {
                         game.score.demands_completed += 1;
                         game.score.points += demand.points;
                         game.score_changed = true;
-                        info!("{id:?} -> exiting");
+                        info!("{player:?} -> exiting");
                         *state = CustomerState::Exiting { path }
                     }
                 }
                 CustomerState::Exiting { path } => {
-                    player.direction = path.next_direction(player.position());
+                    playerdata.direction = path.next_direction(playerdata.position());
                     if path.is_done() {
-                        info!("{id:?} -> leave");
-                        self.cpackets.push_back((id, PacketS::Leave));
-                        customers_to_remove.push(id);
+                        info!("{player:?} -> leave");
+                        self.cpackets.push_back(PacketS::Leave { player });
+                        customers_to_remove.push(player);
                     }
                 }
             }
@@ -255,8 +248,8 @@ impl EntityT for Customers {
         for c in customers_to_remove {
             self.customers.remove(&c).unwrap();
         }
-        for (player, packet) in self.cpackets.drain(..) {
-            if let Err(err) = game.packet_in(player, packet, &mut vec![], packet_out) {
+        for packet in self.cpackets.drain(..) {
+            if let Err(err) = game.packet_in(packet, &mut vec![], packet_out) {
                 warn!("demand packet {err}");
             }
         }