Initial drop in replacement implementation

It's faster than the other one! Doesn't tesla yet, but still! Yay!

3 files changed, 37 insertions, 8 deletions

diff --git a/src/engine/bitwise_engine.rs b/src/engine/bitwise_engine.rs
index e3ca4c6..31040bf 100644
--- a/src/engine/bitwise_engine.rs
+++ b/src/engine/bitwise_engine.rs
@@ -53,8 +53,6 @@ pub struct TeslaCooldown {
 }
 
 
-const EMPTY: [Point; 0] = [];
-
 impl GameState for BitwiseGameState {
     fn simulate(&mut self, settings: &GameSettings, player_command: Command, opponent_command: Command) -> GameStatus {
         BitwiseGameState::perform_command(settings, &mut self.player, &mut self.player_buildings, player_command);      BitwiseGameState::perform_command(settings, &mut self.opponent, &mut self.opponent_buildings, opponent_command);
@@ -82,8 +80,33 @@ impl GameState for BitwiseGameState {
     fn opponent(&self) -> &Player { &self.opponent }
     fn player_has_max_teslas(&self) -> bool { self.player_buildings.count_teslas() >= MAX_TESLAS }
     fn opponent_has_max_teslas(&self) -> bool { self.opponent_buildings.count_teslas() >= MAX_TESLAS }
-    fn unoccupied_player_cells(&self) -> &[Point] { &EMPTY } //TODO
-    fn unoccupied_opponent_cells(&self) -> &[Point] { &EMPTY } //TODO
+
+    fn unoccupied_player_cell_count(&self) -> usize { self.player_buildings.occupied.count_zeros() as usize }
+    fn unoccupied_opponent_cell_count(&self) -> usize { self.opponent_buildings.occupied.count_zeros() as usize }
+    fn location_of_unoccupied_player_cell(&self, i: usize) -> Point  {
+        let mut current = 0;
+        for bit in 0..64 {
+            let is_free = (1 << bit) & self.player_buildings.occupied == 0;
+            if is_free && current == i{
+                return Point::new(bit%SINGLE_MAP_WIDTH, bit/SINGLE_MAP_WIDTH);
+            } else if is_free {
+                current += 1;
+            }
+        }
+        panic!("Didn't find indicated free bit for player");
+    }
+    fn location_of_unoccupied_opponent_cell(&self, i: usize) -> Point {
+        let mut current = 0;
+        for bit in 0..64 {
+            let is_free = (1 << bit) & self.opponent_buildings.occupied == 0;
+            if is_free && current == i{
+                return Point::new((bit%SINGLE_MAP_WIDTH) + SINGLE_MAP_WIDTH, bit/SINGLE_MAP_WIDTH);
+            } else if is_free {
+                current += 1;
+            }
+        }
+        panic!("Didn't find indicated free bit for opponent");
+    }
 }
 
 impl BitwiseGameState {
diff --git a/src/engine/expressive_engine.rs b/src/engine/expressive_engine.rs
index 0640d58..b7d7bf2 100644
--- a/src/engine/expressive_engine.rs
+++ b/src/engine/expressive_engine.rs
@@ -89,8 +89,11 @@ impl GameState for ExpressiveGameState {
     fn opponent(&self) -> &Player { &self.opponent }
     fn player_has_max_teslas(&self) -> bool { self.count_player_teslas() >= 2 }
     fn opponent_has_max_teslas(&self) -> bool { self.count_opponent_teslas() >= 2 }
-    fn unoccupied_player_cells(&self) -> &[Point] { &self.unoccupied_player_cells }
-    fn unoccupied_opponent_cells(&self) -> &[Point] { &self.unoccupied_opponent_cells }
+
+    fn unoccupied_player_cell_count(&self) -> usize { self.unoccupied_player_cells.len() }
+    fn unoccupied_opponent_cell_count(&self) -> usize { self.unoccupied_opponent_cells.len() }
+    fn location_of_unoccupied_player_cell(&self, i: usize) -> Point  { self.unoccupied_player_cells[i] }
+    fn location_of_unoccupied_opponent_cell(&self, i: usize) -> Point { self.unoccupied_opponent_cells[i] }
 }
 
 impl ExpressiveGameState {
diff --git a/src/engine/mod.rs b/src/engine/mod.rs
index 39a5f26..d36d0e9 100644
--- a/src/engine/mod.rs
+++ b/src/engine/mod.rs
@@ -15,8 +15,11 @@ pub trait GameState: Clone + Sync {
     fn opponent(&self) -> &Player;
     fn player_has_max_teslas(&self) -> bool;
     fn opponent_has_max_teslas(&self) -> bool;
-    fn unoccupied_player_cells(&self) -> &[Point];
-    fn unoccupied_opponent_cells(&self) -> &[Point];
+
+    fn unoccupied_player_cell_count(&self) -> usize;
+    fn unoccupied_opponent_cell_count(&self) -> usize;
+    fn location_of_unoccupied_player_cell(&self, i: usize) -> Point;
+    fn location_of_unoccupied_opponent_cell(&self, i: usize) -> Point;
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]