Implemented tracking of the tiebreaking score

1 files changed, 39 insertions, 6 deletions

diff --git a/src/game.rs b/src/game.rs
index fe54f40..2112076 100644
--- a/src/game.rs
+++ b/src/game.rs
@@ -37,6 +37,7 @@ impl GameBoard {
 
         let player = Player {
             active_worm: json.active_worm_index().unwrap(),
+            moves_score: json.my_player.score - json.my_player.health_score(),
             worms: json.my_player.worms.iter().map(|w| Worm {
                 id: w.id,
                 health: w.health,
@@ -48,6 +49,7 @@ impl GameBoard {
 
         let opponent = Player {
             active_worm: 0,
+            moves_score: json.opponents[0].score - json.opponents[0].health_score(),
             worms: json.opponents.iter().flat_map(|o| &o.worms).map(|w| Worm {
                 id: w.id,
                 health: w.health,
@@ -93,6 +95,9 @@ impl GameBoard {
             }
         }
 
+        self.players[0].moves_score = json.my_player.score - json.my_player.health_score();
+        self.players[1].moves_score = json.opponents[0].score - json.opponents[0].health_score();
+
         self.powerups = json.map.iter().flatten().filter_map(|c| {
             c.powerup.as_ref().map(|p| Powerup {
                 position: Point2d::new(c.x, c.y),
@@ -143,7 +148,6 @@ impl GameBoard {
                 // TODO: Get this from some sort of config rather
                 let damage = 20;
 
-
                 debug_assert_eq!(Some(false), self.map.at(Point2d::new(p1.x, p1.y)), "Movement target wasn't empty, ({}, {})", p1.x, p1.y);
                 // Worms have a 50% chance of swapping places
                 // here. I'm treating that as an edge case that I
@@ -151,6 +155,7 @@ impl GameBoard {
                 for player in &mut self.players {
                     let worm = player.active_worm_mut();
                     worm.health = worm.health.saturating_sub(damage);
+                    player.moves_score += 5;
                 }
             },
             _ => {
@@ -158,6 +163,8 @@ impl GameBoard {
                     if let Command::Move(p) = moves[player_index] {
                         debug_assert_eq!(Some(false), self.map.at(p), "Movement target wasn't empty, ({}, {})", p.x, p.y);
 
+                        self.players[player_index].moves_score += 5;
+
                         let worm = self.players[player_index].active_worm_mut();
 
                         debug_assert!(
@@ -196,13 +203,15 @@ impl GameBoard {
                     "Tried to dig too far away, ({}, {})", p.x, p.y
                 };
 
+                self.players[player_index].moves_score += 7;
+
                 self.map.clear(p);
             }
         }
     }
     
     fn simulate_shoots(&mut self, moves: [Command; 2]) {
-        for player_index in 0..moves.len() {
+        'players_loop: for player_index in 0..moves.len() {
             if let Command::Shoot(dir) = moves[player_index] {
                 let (center, weapon_range, weapon_damage) = {
                     let worm = self.players[player_index].active_worm();
@@ -220,17 +229,41 @@ impl GameBoard {
                     let target = center + diff * distance;
                     match self.map.at(target) {
                         Some(false) => {
-                            let target_worm: Option<&mut Worm> = self.players.iter_mut()
-                                .flat_map(|p| p.worms.iter_mut())
+                            let target_own_worm: Option<&mut Worm> = self.players[player_index]
+                                .worms.iter_mut()
                                 .find(|w| w.position == target);
-                            if let Some(target_worm) = target_worm {
+                            
+                            if let Some(target_worm) = target_own_worm {
                                 target_worm.health -= weapon_damage;
-                                break;
+                                if target_worm.health <= 0 {
+                                    // TODO: This will probably be changed soon https://github.com/EntelectChallenge/2019-Worms/issues/42
+                                    self.players[player_index].moves_score += 40;
+                                } else {
+                                    self.players[player_index].moves_score -= 20;
+                                }
+                                continue 'players_loop;
+                            }
+
+                            let target_opponent_worm: Option<&mut Worm> = self.players[GameBoard::opponent(player_index)]
+                                .worms.iter_mut()
+                                .find(|w| w.position == target);
+                            if let Some(target_worm) = target_opponent_worm {
+                                target_worm.health -= weapon_damage;
+                                if target_worm.health <= 0 {
+                                    self.players[player_index].moves_score += 40;
+                                } else {
+                                    self.players[player_index].moves_score += 20;
+                                }
+                                
+                                continue 'players_loop;
                             }
                         },
                         _ => break
                     }
                 }
+
+                // You get here if the shot missed. Hits are an early return.
+                self.players[player_index].moves_score += 2;
             }
         }
     }