prime clients and tile rendering

1 files changed, 81 insertions, 8 deletions

diff --git a/server/src/game.rs b/server/src/game.rs
index 458a796b..fbbab0a4 100644
--- a/server/src/game.rs
+++ b/server/src/game.rs
@@ -1,9 +1,10 @@
-use crate::protocol::{Item, PacketC, PacketS, ID};
+use crate::protocol::{Item, PacketC, PacketS, Tile, ID};
 use anyhow::{anyhow, Result};
-use glam::UVec2;
+use glam::IVec2;
 use std::collections::{HashMap, VecDeque};
 
 struct TileData {
+    kind: Tile,
     items: Vec<ID>,
     active: bool,
 }
@@ -16,7 +17,7 @@ struct Player {
 #[derive(Default)]
 pub struct Game {
     item_id_counter: ID,
-    tiles: HashMap<UVec2, TileData>,
+    tiles: HashMap<IVec2, TileData>,
     items: HashMap<ID, Item>,
     players: HashMap<ID, Player>,
     packet_out: VecDeque<PacketC>,
@@ -24,13 +25,72 @@ pub struct Game {
 
 impl Game {
     pub fn new() -> Self {
-        Self::default()
+        let mut g = Self::default();
+        for x in -5..5 {
+            for y in -5..5 {
+                g.tiles.insert(IVec2 { x, y }, Tile::Floor.into());
+            }
+        }
+        for x in -5..5 {
+            g.tiles.insert(IVec2 { x, y: -5 }, Tile::Table.into());
+            g.tiles.insert(IVec2 { x, y: 4 }, Tile::Table.into());
+        }
+        for y in -5..5 {
+            g.tiles.insert(IVec2 { x: -5, y }, Tile::Table.into());
+            g.tiles.insert(IVec2 { x: 4, y }, Tile::Table.into());
+        }
+
+        g.tiles.extend(
+            [
+                ([-5, 1], Tile::Pan),
+                ([-5, 2], Tile::Pan),
+                ([4, 3], Tile::Pan),
+            ]
+            .map(|(k, v)| {
+                (
+                    IVec2::from_array(k),
+                    TileData {
+                        active: false,
+                        items: vec![],
+                        kind: v,
+                    },
+                )
+            }),
+        );
+
+        g
     }
 
     pub fn packet_out(&mut self) -> Option<PacketC> {
         self.packet_out.pop_front()
     }
 
+    pub fn prime_client(&self, id: ID) -> Vec<PacketC> {
+        let mut out = Vec::new();
+        for (&id, player) in &self.players {
+            out.push(PacketC::AddPlayer {
+                id,
+                name: player.name.clone(),
+                hand: player.hand.map(|i| (i, self.items[&i])),
+            })
+        }
+        for (&pos, tdata) in &self.tiles {
+            out.push(PacketC::UpdateMap {
+                pos,
+                tile: tdata.kind,
+            });
+            for &id in &tdata.items {
+                out.push(PacketC::ProduceItem {
+                    id,
+                    pos,
+                    kind: self.items[&id],
+                })
+            }
+        }
+        out.push(PacketC::Joined { id });
+        out
+    }
+
     pub fn packet_in(&mut self, player: ID, packet: PacketS) -> Result<()> {
         match packet {
             PacketS::Join { name } => {
@@ -41,16 +101,19 @@ impl Game {
                         name: name.clone(),
                     },
                 );
-                self.packet_out
-                    .push_back(PacketC::AddPlayer { id: player, name });
+                self.packet_out.push_back(PacketC::AddPlayer {
+                    id: player,
+                    name,
+                    hand: None,
+                });
             }
             PacketS::Leave => {
                 let p = self
                     .players
                     .remove(&player)
                     .ok_or(anyhow!("player does not exist"))?;
-                if let Some(_i) = p.hand {
-                    // TODO what now?
+                if let Some(id) = p.hand {
+                    self.items.remove(&id).expect("hand item lost");
                 }
                 self.packet_out
                     .push_back(PacketC::RemovePlayer { id: player })
@@ -84,3 +147,13 @@ impl Game {
         Ok(())
     }
 }
+
+impl From<Tile> for TileData {
+    fn from(kind: Tile) -> Self {
+        Self {
+            kind,
+            active: false,
+            items: vec![],
+        }
+    }
+}