Placable walls in tag

2 files changed, 74 insertions, 4 deletions

diff --git a/server/src/entity/mod.rs b/server/src/entity/mod.rs
index 01cb9462..7c38e532 100644
--- a/server/src/entity/mod.rs
+++ b/server/src/entity/mod.rs
@@ -86,7 +86,10 @@ pub trait Entity: Any {
 
 pub fn construct_entity(decl: &EntityDecl) -> DynEntity {
     match decl.to_owned() {
-        EntityDecl::TagMinigame { tag_item } => Box::new(TagMinigame::new(tag_item)),
+        EntityDecl::TagMinigame {
+            tag_item,
+            blocker_tile,
+        } => Box::new(TagMinigame::new(tag_item, blocker_tile)),
         EntityDecl::Book { pos } => Box::new(Book(pos)),
         EntityDecl::ItemPortal { from, to } => Box::new(ItemPortal { from, to }),
         EntityDecl::PlayerPortal { from, to } => Box::new(PlayerPortal { from, to }),
diff --git a/server/src/entity/tag_minigame.rs b/server/src/entity/tag_minigame.rs
index ff4faccd..7c6c721f 100644
--- a/server/src/entity/tag_minigame.rs
+++ b/server/src/entity/tag_minigame.rs
@@ -17,24 +17,34 @@
 */
 use super::{Entity, EntityContext};
 use anyhow::Result;
-use hurrycurry_client_lib::Item;
-use hurrycurry_protocol::{Hand, ItemIndex, ItemLocation, Message, PacketC, PlayerID};
+use hurrycurry_client_lib::{Item, Tile};
+use hurrycurry_protocol::{
+    Hand, ItemIndex, ItemLocation, Message, PacketC, PlayerID, TileIndex, glam::IVec2,
+};
 use std::{collections::HashMap, fmt::Write, random::random};
 
 #[derive(Debug, Clone)]
 pub struct TagMinigame {
     scores: HashMap<PlayerID, f32>,
+    player_place_timeouts: HashMap<PlayerID, f32>,
+    wall_place_delays: HashMap<IVec2, f32>,
+    wall_remove_timeouts: HashMap<IVec2, f32>,
     report_cooldown: f32,
     init_done: bool,
     tag_item: ItemIndex,
+    blocker_tile: TileIndex,
 }
 impl TagMinigame {
-    pub fn new(tag_item: ItemIndex) -> Self {
+    pub fn new(tag_item: ItemIndex, blocker_tile: TileIndex) -> Self {
         Self {
             init_done: false,
             report_cooldown: 0.,
             scores: HashMap::new(),
+            player_place_timeouts: HashMap::new(),
+            wall_remove_timeouts: HashMap::new(),
+            wall_place_delays: HashMap::new(),
             tag_item,
+            blocker_tile,
         }
     }
 }
@@ -71,8 +81,65 @@ impl Entity for TagMinigame {
             {
                 *self.scores.entry(id).or_default() += c.dt
             }
+            if player.movement.boosting && !self.player_place_timeouts.contains_key(&id) {
+                let pos = player.movement.position.floor().as_ivec2();
+                self.player_place_timeouts.insert(id, 3.);
+                self.wall_place_delays.insert(pos, 0.5);
+            }
         }
 
+        self.player_place_timeouts
+            .values_mut()
+            .for_each(|v| *v -= c.dt);
+        self.player_place_timeouts.retain(|_, v| *v > 0.);
+
+        self.wall_place_delays.values_mut().for_each(|v| *v -= c.dt);
+        self.wall_place_delays
+            .iter()
+            .filter(|(_, v)| **v <= 0.)
+            .for_each(|(&pos, _)| {
+                self.wall_remove_timeouts.insert(pos, 3.);
+                c.game.walkable.remove(&pos);
+                c.game.tiles.insert(
+                    pos,
+                    Tile {
+                        kind: self.blocker_tile,
+                        item: None,
+                    },
+                );
+                c.packet_out.push_back(PacketC::UpdateMap {
+                    tile: pos,
+                    kind: Some(self.blocker_tile),
+                    neighbors: [None; 4],
+                });
+            });
+        self.wall_place_delays.retain(|_, v| *v > 0.);
+
+        self.wall_remove_timeouts
+            .values_mut()
+            .for_each(|v| *v -= c.dt);
+        self.wall_remove_timeouts
+            .iter()
+            .filter(|(_, v)| **v <= 0.)
+            .for_each(|(&pos, _)| {
+                if let Some(&(tile, _)) = c.serverdata.initial_map.get(&pos) {
+                    c.game.walkable.insert(pos);
+                    c.game.tiles.insert(
+                        pos,
+                        Tile {
+                            kind: tile,
+                            item: None,
+                        },
+                    );
+                    c.packet_out.push_back(PacketC::UpdateMap {
+                        tile: pos,
+                        kind: Some(tile),
+                        neighbors: [None; 4],
+                    });
+                }
+            });
+        self.wall_remove_timeouts.retain(|_, v| *v > 0.);
+
         // Send out a scoreboard message every 0.1s
         self.report_cooldown -= c.dt;
         if self.report_cooldown < 0. {