Add combat

src/game_state.rs

@@ -106,11 +106,32 @@ impl GameState {
                 self.current_run.combat_log.player_action = Option::from(Move);
             },
             Tile::Wall => return false,
+            Tile::Enemy(id) => self.attack_enemy(id, target_position),
             _ => ()
         }
         true
     }
 
+    fn attack_enemy(&mut self, enemy_id: usize, enemy_position: Point) {
+        let damage = self.current_run.player.attack_power + GameState::roll_dice(6);
+        match self.current_run.level.enemies.get_mut(enemy_id) {
+            Some(enemy) => {
+                if enemy.hp <= damage {
+                    self.current_run.level.move_player_to(enemy_position);
+                    self.current_run.combat_log.player_action = Option::from(PlayerAction::Attack(damage, 0));
+                } else {
+                    enemy.hp -= damage;
+                    self.current_run.combat_log.player_action = Option::from(PlayerAction::Attack(damage, enemy.hp));
+                }
+            }
+            None => ()
+        }
+    }
+
+    fn roll_dice(sides: usize) -> usize {
+        thread_rng().gen_range(1, sides)
+    }
+
     fn calculate_target_position(current_position: Point, key: Key) -> Point {
         match key {
             Key::W | Key::Up => {
@@ -147,10 +168,51 @@ impl GameState {
 
 impl GameState {
     fn run_enemy_turn(&mut self) {
-        println!("turn count: {}", self.current_run.level.turn_count);
-        for enemy in self.current_run.level.get_current_enemies() {
-            self.move_enemy(enemy.0, enemy.1);
+        let player_position = self.current_run.level.get_player_position();
+
+        let mut total_damage = 0;
+
+        for (id, position) in self.current_run.level.get_current_enemies() {
+            if GameState::check_is_neighbor(player_position, position) {
+                total_damage += self.attack_player();
+            } else {
+                self.move_enemy(id, position);
+            }
         }
+
+        if total_damage > 0 {
+            self.current_run.combat_log.damage_taken = Option::from(total_damage)
+        } else {
+            self.current_run.combat_log.damage_taken = None
+        }
+    }
+
+    fn check_is_neighbor(a: Point, b: Point) -> bool {
+        return GameState::check_neighbor_uint(a.0, b.0) || GameState::check_neighbor_uint(a.1, b.1);
+    }
+
+    fn check_neighbor_uint(a: usize, b: usize) -> bool {
+        if a > b {
+            if a - b == 1 {
+                return true
+            }
+        } else if b > a {
+            if b - a == 1 {
+                return true
+            }
+        }
+        false
+    }
+
+    fn attack_player(&mut self) -> usize {
+        let damage = 1 + GameState::roll_dice(4);
+        if self.current_run.player.current_hp <= damage {
+            self.current_run.player.current_hp = 0
+        } else {
+            self.current_run.player.current_hp -= damage
+        }
+
+        damage
     }
 
     fn move_enemy(&mut self, id: usize, position: Point) {

src/game_state/enemy.rs

-pub struct Enemy {}
+pub struct Enemy {
+    pub hp: usize
+}
 
 impl Enemy {
     pub fn new() -> Enemy {
-        Enemy {}
+        Enemy {
+            hp: 6
+        }
     }
 }
\ No newline at end of file