Finding valid move positions

Author: sunjay

examples/reversi/board.rs

@@ -1,4 +1,5 @@
 use std::ops::Deref;
+use std::collections::HashSet;
 
 use turtle::Color;
 
@@ -36,10 +37,6 @@ impl Piece {
     }
 }
 
-fn valid_moves_for(tiles: Tiles, piece: Piece) -> Vec<Position> {
-    Default::default() //TODO
-}
-
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Board {
     current: Piece,
@@ -49,7 +46,7 @@ pub struct Board {
     ///
     /// Each array in Board is a row of the board
     tiles: Tiles,
-    valid_moves: Vec<Position>
+    valid_moves: HashSet<Position>
 }
 
 impl Deref for Board {
@@ -68,23 +65,20 @@ impl Board {
         tiles[4][3] = Some(Piece::B);
         tiles[4][4] = Some(Piece::A);
         let current = Piece::A;
-        let valid_moves = valid_moves_for(tiles, current);
 
-        Self {
+        let mut board = Self {
             current,
             tiles,
-            valid_moves,
-        }
+            valid_moves: HashSet::new(),
+        };
+        board.update_valid_moves(current);
+        board
     }
 
     pub fn current(&self) -> Piece {
         self.current
     }
 
-    pub fn valid_moves(&self) -> &[Position] {
-        &self.valid_moves
-    }
-
     pub fn is_valid_move(&self, position: &Position) -> bool {
         self.valid_moves.contains(position)
     }
@@ -95,8 +89,12 @@ impl Board {
             self.tiles[pos.0][pos.1] = Some(self.current);
             self.flip_tiles(pos);
 
-            self.valid_moves = vec![]; //TODO
             self.current = self.current.other();
+
+            //TODO: When nested method calls are enabled, this can be done in one line
+            // Link: https://github.com/rust-lang/rust/issues/44100
+            let current = self.current;
+            self.update_valid_moves(current);
         }
         else {
             unreachable!("Game should check for whether a valid move was used before playing it");
@@ -106,4 +104,82 @@ impl Board {
     fn flip_tiles(&mut self, start: Position) {
         unimplemented!()
     }
+
+    fn update_valid_moves(&mut self, piece: Piece) {
+        self.valid_moves.clear();
+
+        // Explanation: A valid move is an empty tile which has `piece` in a vertical, horizontal,
+        // or diagonal line from it with only `piece.other()` between the empty tile and piece.
+        // Example: E = empty, p = piece, o = other piece
+        //      A B C D E F G H I J K
+        //      E E o o o p o p p E o
+        //  Tile A is *not* a valid move. Tile B is a valid move for p. None of the other tiles are
+        //  valid moves for p.
+        // Algorithm: For each empty tile, look for at least one adjacent `other` piece. If one is
+        // found, look for another `piece` in that direction that isn't preceeded by an empty tile.
+
+        let other = piece.other();
+        for (i, row) in self.tiles.iter().enumerate() {
+            for (j, tile) in row.iter().enumerate() {
+                // Only empty tiles can be valid moves
+                if tile.is_some() {
+                    continue;
+                }
+
+                for (row, col) in self.adjacent_positions((i, j)) {
+                    // Look for at least one `other` tile before finding `piece`
+                    if self.tiles[row][col] == Some(other)
+                        && self.find_piece((i, j), (row, col), piece) {
+                        self.valid_moves.insert((i, j));
+                        // Don't want to keep searching this tile now that we've added it
+                        break;
+                    }
+                }
+            }
+        }
+
+        // We need to shrink to fit because clear does not reduce the capacity and we do not want
+        // to leak memory by allowing the valid_moves Vec to grow uncontrollably
+        self.valid_moves.shrink_to_fit();
+    }
+
+    /// Searches in the direction of the given target starting from the target. Returns true if it
+    /// finds piece AND only encounters piece.other() along the way.
+    fn find_piece(&self, pos: Position, (target_row, target_col): Position, piece: Piece) -> bool {
+        let other = piece.other();
+
+        let delta_row = target_row as isize - pos.0 as isize;
+        let delta_col = target_col as isize - pos.1 as isize;
+
+        let mut curr_row = target_row as isize + delta_row;
+        let mut curr_col = target_col as isize + delta_col;
+        while curr_row >= 0 && curr_row < self.tiles.len() as isize
+            && curr_col >= 0 && curr_col < self.tiles[0].len() as isize {
+            let current = self.tiles[curr_row as usize][curr_col as usize];
+            curr_row = curr_row + delta_row;
+            curr_col = curr_col + delta_col;
+            if current == Some(other) {
+                continue;
+            }
+            else if current == Some(piece) {
+                return true;
+            }
+            else {
+                return false;
+            }
+        }
+        return false;
+    }
+
+    //TODO: Replace return type with `impl Iterator<Item=(usize, usize)>` when the "impl Trait"
+    // feature is stable.
+    fn adjacent_positions(&self, (row, col): Position) -> Vec<Position> {
+        let rows = self.tiles.len();
+        let cols = self.tiles[0].len();
+        [(-1,-1),(-1,0),(-1,1),(0,-1),(0,1),(1,-1),(1,0),(1,1)].into_iter()
+            .map(|&(r, c)| (row as isize + r, col as isize + c))
+            .filter(|&(r, c)| r >= 0 && c >= 0 && r < rows as isize && c < cols as isize)
+            .map(|(r, c)| (r as usize, c as usize))
+            .collect()
+    }
 }