clean up server code, move some code to game behaviour crate

1 files changed, 134 insertions, 0 deletions

diff --git a/server/game-core/src/lib.rs b/server/game-core/src/lib.rs
index faecb9d1..21315a07 100644
--- a/server/game-core/src/lib.rs
+++ b/server/game-core/src/lib.rs
@@ -316,4 +316,138 @@ impl Game {
         self.player_id_counter += 1;
         PlayerID(self.player_id_counter)
     }
+
+    pub fn prime_client(&self) -> Vec<PacketC> {
+        let mut out = Vec::new();
+        out.push(PacketC::GameData({
+            let mut k = self.data.as_ref().to_owned();
+            k.recipes.clear();
+            k.demands.clear();
+            k
+        }));
+        out.push(PacketC::Environment {
+            effects: self.environment_effects.clone(),
+        });
+        for (&id, player) in &self.players {
+            out.push(PacketC::AddPlayer {
+                id,
+                class: player.class,
+                position: player.movement.position,
+                character: player.character,
+                name: player.name.clone(),
+            });
+            for (i, item) in player.items.iter().enumerate() {
+                if let Some(item) = &item {
+                    out.push(PacketC::SetItem {
+                        location: ItemLocation::Player(id, Hand(i)),
+                        item: Some(item.kind),
+                    });
+                    if let Some(Involvement {
+                        players: player,
+                        position,
+                        speed,
+                        warn,
+                        ..
+                    }) = item.active.clone()
+                    {
+                        out.push(PacketC::SetProgress {
+                            players: player,
+                            item: ItemLocation::Player(id, Hand(i)),
+                            position,
+                            speed,
+                            warn,
+                        });
+                    }
+                }
+            }
+            if let Some((message, timeout)) = &player.communicate_persist {
+                out.push(PacketC::Communicate {
+                    player: id,
+                    message: Some(message.to_owned()),
+                    timeout: Some(*timeout),
+                })
+            }
+        }
+        out.push(PacketC::UpdateMap {
+            changes: self
+                .tiles
+                .iter()
+                .map(|(pos, tile)| (*pos, tile.parts.clone()))
+                .collect(),
+        });
+        for (&tile, tdata) in &self.tiles {
+            if let Some(item) = &tdata.item {
+                out.push(PacketC::SetItem {
+                    location: ItemLocation::Tile(tile),
+                    item: Some(item.kind),
+                });
+                if let Some(Involvement {
+                    players,
+                    position,
+                    speed,
+                    warn,
+                    ..
+                }) = item.active.clone()
+                {
+                    out.push(PacketC::SetProgress {
+                        players: players.to_owned(),
+                        item: ItemLocation::Tile(tile),
+                        position,
+                        speed,
+                        warn,
+                    });
+                }
+            }
+        }
+        out.push(PacketC::Score(self.score.clone()));
+        out.push(PacketC::SetIngame {
+            state: true,
+            lobby: self.lobby,
+        });
+        out
+    }
+
+    pub fn unload(&mut self, packet_out: &mut VecDeque<PacketC>) {
+        packet_out.push_back(PacketC::SetIngame {
+            state: false,
+            lobby: false,
+        });
+        for (id, _) in self.players.drain() {
+            self.players_spatial_index.remove_entry(id);
+            packet_out.push_back(PacketC::RemovePlayer { id })
+        }
+        packet_out.push_back(PacketC::UpdateMap {
+            changes: self.tiles.keys().map(|&p| (p, Vec::new())).collect(),
+        });
+        self.tiles.clear();
+        self.score = Score::default();
+        self.environment_effects.clear();
+        self.walkable.clear();
+        self.tile_index.clear();
+        self.item_locations_index.clear();
+    }
+
+    pub fn remove_player(&mut self, id: PlayerID) -> bool {
+        let Some(p) = self.players.remove(&id) else {
+            return false;
+        };
+        for (hand, item) in p.items.into_iter().enumerate() {
+            if let Some(item) = item {
+                self.item_locations_index
+                    .remove(&ItemLocation::Player(id, Hand(hand)));
+                let pos = p.movement.position.floor().as_ivec2();
+                if let Some(tile) = self.tiles.get_mut(&pos)
+                    && tile.item.is_none()
+                {
+                    self.events.push_back(PacketC::SetItem {
+                        location: ItemLocation::Tile(pos),
+                        item: Some(item.kind),
+                    });
+                    tile.item = Some(item);
+                }
+            }
+        }
+        self.events.push_back(PacketC::RemovePlayer { id });
+        true
+    }
 }