Strategy to focus mcts

1 files changed, 29 insertions, 18 deletions

diff --git a/src/game.rs b/src/game.rs
index 9903250..1ac627d 100644
--- a/src/game.rs
+++ b/src/game.rs
@@ -31,8 +31,9 @@ pub struct Worm {
 }
 
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
-pub enum Powerup {
-    Health(Point2d<i8>, i32)
+pub struct Powerup {
+    pub position: Point2d<i8>,
+    pub value: i32
 }
 
 #[derive(Debug, PartialEq, Eq, Clone)]
@@ -88,7 +89,10 @@ impl GameBoard {
             max_rounds: json.max_rounds,
             players: [player, opponent],
             powerups: json.map.iter().flatten().filter_map(|c| {
-                c.powerup.clone().map(|p| Powerup::Health(Point2d::new(c.x, c.y), p.value))
+                c.powerup.clone().map(|p| Powerup {
+                    position: Point2d::new(c.x, c.y),
+                    value: p.value
+                })
             }).collect(),
             map,
             outcome: SimulationOutcome::Continue
@@ -110,7 +114,10 @@ impl GameBoard {
         }
 
         self.powerups = json.map.iter().flatten().filter_map(|c| {
-            c.powerup.clone().map(|p| Powerup::Health(Point2d::new(c.x, c.y), p.value))
+            c.powerup.clone().map(|p| Powerup {
+                position: Point2d::new(c.x, c.y),
+                value: p.value
+            })
         }).collect();
 
         for cell in json.map.iter().flatten() {
@@ -174,12 +181,13 @@ impl GameBoard {
                         worm.position.x = x;
                         worm.position.y = y;
 
-                        self.powerups.retain(|p| match p {
-                            Powerup::Health(point, size) if *point == worm.position => {
-                                worm.health += *size;
+                        self.powerups.retain(|p| {
+                            if p.position == worm.position {
+                                worm.health += p.value;
                                 false
-                            },
-                            _ => true
+                            } else {
+                                true
+                            }
                         });
                     }
                 }
@@ -241,11 +249,13 @@ impl GameBoard {
                 if player.worms[worm_index].health <= 0 {
                     player.worms.remove(worm_index);
                     if player.active_worm >= worm_index {
-                        if player.active_worm > 0 {
-                            player.active_worm -= 1;
+                        player.active_worm = if player.active_worm > 0 {
+                            player.active_worm - 1
+                        } else if player.worms.len() > 0 {
+                             player.worms.len() - 1 
                         } else {
-                            player.active_worm = player.worms.len()-1;
-                        }
+                            0
+                        };
                     }
                 }
             }
@@ -268,13 +278,12 @@ impl GameBoard {
         self.outcome
     }
 
-    pub fn find_targets(&self, center: Point2d<i8>, weapon_range: u8) -> Vec<Direction> {
+    pub fn find_targets(&self, player_index: usize, center: Point2d<i8>, weapon_range: u8) -> Vec<Direction> {
         let range = weapon_range as i8;
         let dir_range = ((weapon_range as f32 + 1.) / 2f32.sqrt()).floor() as i8;
 
-        let mut directions: Vec<Direction> = self.players.iter()
-            .flat_map(|p| p.worms.iter())
-            .filter(|w| w.position != center)
+        let mut directions: Vec<Direction> = self.players[(player_index + 1)%2].worms
+            .iter()
             .filter_map(|w| {
                 let diff = w.position - center;
                 if diff.x == 0 && diff.y.abs() <= range {
@@ -302,7 +311,9 @@ impl GameBoard {
             })
             .filter(|(dir, range)| {
                 let diff = dir.as_vec();
-                (1..*range).any(|distance| self.map.at(center + diff * distance) != Some(false))
+                !(1..*range).any(|distance|
+                                 self.map.at(center + diff * distance) != Some(false) &&
+                                 !self.players[player_index].worms.iter().any(|w| w.position == center + diff * distance))
             })
             .map(|(dir, _range)| dir)
             .collect();