Fix monster death logic

src/graphics/sidebar.rs

@@ -46,7 +46,7 @@ pub fn draw(resources: &Resources, bterm: &mut BTerm) {
     bterm.print(SIDEBAR_POS_X + 4, SIDEBAR_POS_Y + 15, "Keys");
 
     let stats = &resources.stats;
-    bterm.print_centered_at(SIDEBAR_POS_X + 6, SIDEBAR_POS_Y + 1, stats.score);
+    bterm.print_centered_at(SIDEBAR_POS_X + 6, SIDEBAR_POS_Y + 1, stats.score * 10);
     bterm.print_centered_at(SIDEBAR_POS_X + 6, SIDEBAR_POS_Y + 7, stats.gems);
     bterm.print_centered_at(SIDEBAR_POS_X + 6, SIDEBAR_POS_Y + 10, stats.whips);
     bterm.print_centered_at(SIDEBAR_POS_X + 6, SIDEBAR_POS_Y + 13, stats.teleports);

src/input/mod.rs

@@ -30,11 +30,6 @@ pub fn handle(world: &mut World, resources: &mut Resources, bterm: &mut BTerm) {
             VirtualKeyCode::W => {
                 player::whip(world, resources);
             }
-            VirtualKeyCode::S => {
-                resources
-                    .sound_output
-                    .play_sound(resources.sound_effects.pickup.clone());
-            }
             VirtualKeyCode::D => {
                 resources.show_debug_info = !resources.show_debug_info;
             }

src/input/player.rs

@@ -3,7 +3,9 @@ use std::time::{Duration, Instant};
 use bracket_lib::prelude::*;
 use hecs::{Entity, With, Without, World};
 
-use crate::{components::monster::*, components::*, constants::*, resources::*, systems};
+use crate::{
+    components::monster::*, components::*, constants::*, resources::*, systems, tile_data::TileType,
+};
 
 pub fn try_move(delta_x: i32, delta_y: i32, world: &mut World, resources: &mut Resources) {
     let mut to_kill: Vec<Entity> = Vec::new();
@@ -22,11 +24,7 @@ pub fn try_move(delta_x: i32, delta_y: i32, world: &mut World, resources: &mut R
             };
 
             if resources.map.in_bounds(destination) {
-                if resources.map.is_solid(destination) {
-                    resources
-                        .sound_output
-                        .play_sound(resources.sound_effects.blocked.clone());
-                } else {
+                if try_step(destination, world, resources) {
                     if let Some(monster_entity) = resources.map.get_tile_content_at(destination) {
                         if let Ok(monster) = world.get::<Monster>(monster_entity) {
                             resources.stats.add_score(damage_for_kind(monster.kind));
@@ -70,6 +68,96 @@ pub fn try_move(delta_x: i32, delta_y: i32, world: &mut World, resources: &mut R
     }
 }
 
+fn try_step(point: Point, _world: &World, resources: &mut Resources) -> bool {
+    match resources.map.get_tile_at(point) {
+        crate::tile_data::TileType::Floor
+        | crate::tile_data::TileType::Slow
+        | crate::tile_data::TileType::Medium
+        | crate::tile_data::TileType::Fast => true,
+        crate::tile_data::TileType::Block | crate::tile_data::TileType::Wall => {
+            resources
+                .sound_output
+                .play_sound(resources.sound_effects.blocked.clone());
+            if resources.stats.score > 2 {
+                resources.stats.take_score(2);
+            }
+            false
+        }
+        crate::tile_data::TileType::Whip => {
+            resources
+                .sound_output
+                .play_sound(resources.sound_effects.grab.clone());
+            resources.stats.give_whips(1);
+            resources.stats.add_score(1);
+            resources.map.set_tile_at(point, TileType::Floor);
+            true
+        }
+        crate::tile_data::TileType::Stairs => {
+            // TODO: Go to next level
+            true
+        }
+        crate::tile_data::TileType::Chest => todo!(),
+        crate::tile_data::TileType::SlowTime => todo!(),
+        crate::tile_data::TileType::Gem => {
+            resources
+                .sound_output
+                .play_sound(resources.sound_effects.grab.clone());
+            resources.stats.give_gems(1);
+            resources.stats.add_score(1);
+            resources.map.set_tile_at(point, TileType::Floor);
+            true
+        }
+        crate::tile_data::TileType::Invisible => todo!(),
+        crate::tile_data::TileType::Teleport => {
+            resources
+                .sound_output
+                .play_sound(resources.sound_effects.grab.clone());
+            resources.stats.give_teleports(1);
+            resources.stats.add_score(1);
+            resources.map.set_tile_at(point, TileType::Floor);
+            true
+        }
+        crate::tile_data::TileType::Key => todo!(),
+        crate::tile_data::TileType::Door => todo!(),
+        crate::tile_data::TileType::SpeedTime => todo!(),
+        crate::tile_data::TileType::Trap => todo!(),
+        crate::tile_data::TileType::River => todo!(),
+        crate::tile_data::TileType::Power => todo!(),
+        crate::tile_data::TileType::Forest => todo!(),
+        crate::tile_data::TileType::Tree => todo!(),
+        crate::tile_data::TileType::Bomb => todo!(),
+        crate::tile_data::TileType::Lava => todo!(),
+        crate::tile_data::TileType::Pit => todo!(),
+        crate::tile_data::TileType::Tome => todo!(),
+        crate::tile_data::TileType::Tunnel => todo!(),
+        crate::tile_data::TileType::Freeze => todo!(),
+        crate::tile_data::TileType::Nugget => todo!(),
+        crate::tile_data::TileType::Quake => todo!(),
+        crate::tile_data::TileType::InvisibleBlock => todo!(),
+        crate::tile_data::TileType::InvisibleWall => todo!(),
+        crate::tile_data::TileType::InvisibleDoor => todo!(),
+        crate::tile_data::TileType::Stop => todo!(),
+        crate::tile_data::TileType::Zap => todo!(),
+        crate::tile_data::TileType::Create => todo!(),
+        crate::tile_data::TileType::Generator => todo!(),
+        crate::tile_data::TileType::Trap2 => todo!(),
+        crate::tile_data::TileType::Trap3 => todo!(),
+        crate::tile_data::TileType::Trap4 => todo!(),
+        crate::tile_data::TileType::Trap5 => todo!(),
+        crate::tile_data::TileType::Trap6 => todo!(),
+        crate::tile_data::TileType::Trap7 => todo!(),
+        crate::tile_data::TileType::Trap8 => todo!(),
+        crate::tile_data::TileType::Trap9 => todo!(),
+        crate::tile_data::TileType::Trap10 => todo!(),
+        crate::tile_data::TileType::Trap11 => todo!(),
+        crate::tile_data::TileType::Trap12 => todo!(),
+        crate::tile_data::TileType::Trap13 => todo!(),
+        crate::tile_data::TileType::Player => true,
+        crate::tile_data::TileType::Punctuation => todo!(),
+        crate::tile_data::TileType::Letter(_) => todo!(),
+    }
+}
+
 pub fn whip(world: &mut World, resources: &mut Resources) {
     let mut to_add: Vec<Entity> = Vec::new();
 

src/resources/map.rs

@@ -245,8 +245,4 @@ impl Map {
         let index = self.point2d_to_index(point);
         self.tiles[index] = tile;
     }
-
-    pub fn is_solid(&self, point: Point) -> bool {
-        matches!(self.get_tile_at(point), TileType::Wall | TileType::Block)
-    }
 }

src/resources/sound_effects.rs

@@ -29,7 +29,7 @@ pub struct SoundEffect {
 pub struct SoundEffects {
     pub startup: SoundSamples,
     pub step: SoundSamples,
-    pub pickup: SoundSamples,
+    pub grab: SoundSamples,
     pub bad_key: SoundSamples,
     pub blocked: SoundSamples,
     pub whipping: SoundSamples,
@@ -66,7 +66,7 @@ impl SoundEffects {
                     },
                 ],
             }),
-            pickup: sound_output.render_sound_effect(&SoundEffect {
+            grab: sound_output.render_sound_effect(&SoundEffect {
                 sounds: vec![
                     Sound {
                         sound_type: SoundType::Noise(350, 900),

src/resources/stats.rs

@@ -10,18 +10,65 @@ pub struct Stats {
 type PlayerSurvived = bool;
 
 impl Stats {
-    pub fn take_gems(&mut self, num_gems: u32) -> PlayerSurvived {
-        let new_num_gems = self.gems as i64 - num_gems as i64;
-        if new_num_gems <= 0 {
-            self.gems = 0;
-            false
-        } else {
-            self.gems = new_num_gems as u32;
-            true
-        }
-    }
-
     pub fn add_score(&mut self, score: u32) {
         self.score += score;
     }
+
+    pub fn take_score(&mut self, score: u32) {
+        if let Some(result) = self.score.checked_sub(score) {
+            self.score = result;
+        } else {
+            self.score = 0;
+        }
+    }
+
+    pub fn give_gems(&mut self, num_gems: u32) {
+        self.gems += num_gems;
+    }
+
+    pub fn take_gems(&mut self, num_gems: u32) -> PlayerSurvived {
+        if let Some(result) = self.gems.checked_sub(num_gems) {
+            self.gems = result;
+            true
+        } else {
+            self.gems = 0;
+            false
+        }
+    }
+
+    pub fn give_whips(&mut self, num_whips: u32) {
+        self.whips += num_whips;
+    }
+
+    pub fn take_whips(&mut self, num_whips: u32) {
+        if let Some(result) = self.whips.checked_sub(num_whips) {
+            self.whips = result;
+        } else {
+            self.whips = 0;
+        }
+    }
+
+    pub fn give_teleports(&mut self, num_teleports: u32) {
+        self.teleports += num_teleports;
+    }
+
+    pub fn take_teleports(&mut self, num_teleports: u32) {
+        if let Some(result) = self.teleports.checked_sub(num_teleports) {
+            self.teleports = result;
+        } else {
+            self.teleports = 0;
+        }
+    }
+
+    pub fn give_keys(&mut self, num_keys: u32) {
+        self.keys += num_keys;
+    }
+
+    pub fn take_keys(&mut self, num_keys: u32) {
+        if let Some(result) = self.keys.checked_sub(num_keys) {
+            self.keys = result;
+        } else {
+            self.keys = 0;
+        }
+    }
 }

src/systems/monster_ai.rs

@@ -17,7 +17,7 @@ pub fn run(world: &mut World, resources: &mut Resources) {
         .cloned();
 
     if let Some(player_pos) = player_position {
-        let mut has_died = None;
+        let mut to_kill: Vec<Entity> = Vec::new();
         for (entity, (monster, position, renderable)) in
             &mut world.query::<(&mut Monster, &mut Position, &mut Renderable)>()
         {
@@ -60,16 +60,20 @@ pub fn run(world: &mut World, resources: &mut Resources) {
                                 monster.kind,
                                 &resources.sound_effects,
                             ));
-                            has_died = Some(entity);
+                            to_kill.push(entity);
                         }
                     } else {
                         let tile = resources.map.get_tile_at_mut(destination);
                         match tile {
                             TileType::Wall => {}
                             TileType::Block => {
-                                // TODO: Sound
+                                resources.sound_output.play_sound(sound_effect_for_kind(
+                                    monster.kind,
+                                    &resources.sound_effects,
+                                ));
+                                resources.stats.add_score(1);
                                 *tile = TileType::Floor;
-                                has_died = Some(entity);
+                                to_kill.push(entity);
                             }
                             _ => {
                                 resources.map.clear_tile_content_at(Point::from(*position));
@@ -85,7 +89,7 @@ pub fn run(world: &mut World, resources: &mut Resources) {
             }
         }
 
-        if let Some(e) = has_died {
+        for e in to_kill {
             let _ = world.despawn(e);
         }
     }