Merge pull request #18 from van-sprundel/quick-wins

Quick wins

Author: van-sprundel

check-buddy/src/board.rs

@@ -626,6 +626,7 @@ impl BoardMap {
     }
     pub fn gen_sliding(&self, from: Position, piece_type: PieceType) -> ArrayVec<Position, 32> {
         let piece_from = self.squares[from[0]][from[1]];
+        let piece_color = piece_from.get_color();
         let mut positions = ArrayVec::new();
         let start = if piece_type == PieceType::Bishop {
             4
@@ -640,14 +641,14 @@ impl BoardMap {
                 let target_position = [target_index / 8, target_index % 8];
                 let target_piece = self.squares[target_position[0]][target_position[1]];
 
-                if target_piece.is_piece() && target_piece.get_color() == piece_from.get_color() {
+                if target_piece.is_piece() && target_piece.get_color() == piece_color {
                     // your own color is in the way
                     break;
                 }
                 positions.push(target_position);
                 // self.squares[target_move[0]][target_move[1]] = Piece(100);
 
-                if target_piece.is_piece() && target_piece.get_color() != piece_from.get_color() {
+                if target_piece.is_piece() && target_piece.get_color() != piece_color {
                     // Enemy piece and capturable
                     break;
                 }
@@ -657,6 +658,7 @@ impl BoardMap {
     }
     pub fn gen_king(&self, from: Position) -> ArrayVec<Position, 32> {
         let piece_from = self.squares[from[0]][from[1]];
+        let piece_color = piece_from.get_color();
         let mut positions = ArrayVec::new();
         for (direction, offset) in DIRECTION_OFFSETS.iter().enumerate() {
             let index = from[0] * 8 + from[1];
@@ -669,27 +671,27 @@ impl BoardMap {
             let target_move = [target_index as usize / 8, target_index as usize % 8];
             let target_piece = self.squares[target_move[0]][target_move[1]];
 
-            if target_piece.is_piece() && target_piece.get_color() == piece_from.get_color() {
+            if target_piece.is_piece() && target_piece.get_color() == piece_color {
                 // your own color is in the way
                 continue;
             }
             positions.push(target_move);
 
-            if target_piece.is_piece() && target_piece.get_color() != piece_from.get_color() {
+            if target_piece.is_piece() && target_piece.get_color() != piece_color {
                 // Enemy piece and capturable
                 continue;
             }
         }
 
         // castling - use piece color, not active color
-        if piece_from.get_color() == PieceColor::Black {
+        if piece_color == PieceColor::Black {
             if self.black_can_short_castle() {
                 positions.push([0, 6]);
             }
             if self.black_can_long_castle() {
                 positions.push([0, 2]);
             }
-        } else if piece_from.get_color() == PieceColor::White {
+        } else {
             if self.white_can_short_castle() {
                 positions.push([7, 6]);
             }
@@ -703,10 +705,9 @@ impl BoardMap {
     pub fn gen_pawn(&self, from: Position) -> ArrayVec<Position, 32> {
         let piece_from = self.squares[from[0]][from[1]];
         let mut moves = ArrayVec::new();
-        let shift = match piece_from.get_color() {
-            PieceColor::Black => 1,
-            PieceColor::White => -1,
-        };
+        let piece_color = piece_from.get_color();
+        let is_black = piece_color == PieceColor::Black;
+        let shift = if is_black { 1 } else { -1 };
 
         // piece blocking
         let vertical = (from[0] as i32 + shift) as usize;
@@ -720,10 +721,7 @@ impl BoardMap {
             let vertical = (from[0] as i32 + shift * 2) as usize;
             if vertical < 8 {
                 let is_blocking = is_blocking || self.squares[vertical][from[1]].is_piece();
-                if ((piece_from.is_black() && from[0] == 1)
-                    || (piece_from.is_white() && from[0] == 6))
-                    && !is_blocking
-                {
+                if ((is_black && from[0] == 1) || (!is_black && from[0] == 6)) && !is_blocking {
                     moves.push([vertical, from[1]]);
                 }
             }
@@ -736,7 +734,7 @@ impl BoardMap {
             let to_top_left_pos = [(from[0] as i32 + shift) as usize, from[1] - 1];
             if to_top_left_pos[0] < 8 {
                 let to_top_left = self.get_piece(to_top_left_pos);
-                if to_top_left.is_piece() && to_top_left.get_color() != piece_from.get_color() {
+                if to_top_left.is_piece() && to_top_left.get_color() != piece_color {
                     moves.push(to_top_left_pos);
                 }
 
@@ -745,7 +743,7 @@ impl BoardMap {
                 // _  p  .
                 let to_left = self.squares[from[0]][from[1] - 1];
                 if let Some(PieceType::Pawn(en_passantable)) = to_left.get_type() {
-                    if en_passantable && to_left.get_color() != piece_from.get_color() {
+                    if en_passantable && to_left.get_color() != piece_color {
                         let to_en_passant = [(from[0] as i32 + shift) as usize, from[1] - 1];
                         moves.push(to_en_passant);
                     }
@@ -760,7 +758,7 @@ impl BoardMap {
             let to_top_right_pos = [(from[0] as i32 + shift) as usize, from[1] + 1];
             if to_top_right_pos[0] < 8 {
                 let to_top_right = self.squares[to_top_right_pos[0]][to_top_right_pos[1]];
-                if to_top_right.is_piece() && to_top_right.get_color() != piece_from.get_color() {
+                if to_top_right.is_piece() && to_top_right.get_color() != piece_color {
                     moves.push(to_top_right_pos);
                 }
 
@@ -769,7 +767,7 @@ impl BoardMap {
                 // .  p  _
                 let to_right = self.squares[from[0]][from[1] + 1];
                 if let Some(PieceType::Pawn(en_passantable)) = to_right.get_type() {
-                    if en_passantable && to_right.get_color() != piece_from.get_color() {
+                    if en_passantable && to_right.get_color() != piece_color {
                         let to_en_passant = [(from[0] as i32 + shift) as usize, from[1] + 1];
                         moves.push(to_en_passant);
                     }
@@ -780,6 +778,7 @@ impl BoardMap {
     }
     pub fn gen_knight(&self, from: Position) -> ArrayVec<Position, 32> {
         let piece_from = self.squares[from[0]][from[1]];
+        let piece_color = piece_from.get_color();
         KNIGHT_DIRECTION_OFFSETS
             .iter()
             .filter_map(|direction| {
@@ -789,9 +788,7 @@ impl BoardMap {
                 ];
                 if new_pos[0] < 8 && new_pos[1] < 8 {
                     let target_piece = self.squares[new_pos[0]][new_pos[1]];
-                    if !(target_piece.is_piece()
-                        && target_piece.get_color() == piece_from.get_color())
-                    {
+                    if !(target_piece.is_piece() && target_piece.get_color() == piece_color) {
                         return Some(new_pos);
                     }
                 }
@@ -826,23 +823,23 @@ impl BoardMap {
             promotion,
             ..
         } = position_move;
+
+        let piece = self.get_piece(from);
+        let is_white = piece.get_color() == PieceColor::White;
+        let target_piece = self.get_piece(to);
+
         if en_passant {
-            let shift = if self.get_piece(from).get_color() == PieceColor::Black {
-                1
-            } else {
-                -1
-            };
+            let shift = if is_white { -1 } else { 1 };
             let to_step = [(to[0] as isize - shift) as usize, to[1]];
             self.set_piece(to_step, 0);
         }
 
         // track castling rights
         // mark kings and rooks as moved
-        let piece = self.get_piece(from);
         if let Some(piece_type) = piece.get_type() {
             match piece_type {
                 PieceType::King => {
-                    if piece.get_color() == PieceColor::White {
+                    if is_white {
                         self.white_king_moved = true;
                         self.white_king_pos = to;
                     } else {
@@ -852,7 +849,7 @@ impl BoardMap {
                 }
                 PieceType::Rook => {
                     // check if rook move
-                    if piece.get_color() == PieceColor::White {
+                    if is_white {
                         if from == [7, 0] {
                             self.white_queenside_rook_moved = true;
                         } else if from == [7, 7] {
@@ -869,7 +866,6 @@ impl BoardMap {
         }
 
         // invalidate castling if a rook is captured on its starting square
-        let target_piece = self.get_piece(to);
         if target_piece.is_piece() {
             if let Some(PieceType::Rook) = target_piece.get_type() {
                 match to {
@@ -889,25 +885,24 @@ impl BoardMap {
                 // kingside castle - move rook from h-file to f-file
                 let rook_from = [from[0], 7];
                 let rook_to = [from[0], 5];
-                self.set_piece(rook_to, self.get_piece(rook_from).0);
+                let rook_piece = self.get_piece(rook_from).0;
+                self.set_piece(rook_to, rook_piece);
                 self.set_piece(rook_from, 0);
             } else if from[1] == 4 && to[1] == 2 {
                 // queenside castle - move rook from a-file to d-file
                 let rook_from = [from[0], 0];
                 let rook_to = [from[0], 3];
-                self.set_piece(rook_to, self.get_piece(rook_from).0);
+                let rook_piece = self.get_piece(rook_from).0;
+                self.set_piece(rook_to, rook_piece);
                 self.set_piece(rook_from, 0);
             }
         }
 
         if promotion {
-            let color = match self.get_piece(from).get_color() {
-                PieceColor::Black => BLACK,
-                PieceColor::White => WHITE,
-            };
+            let color = if is_white { WHITE } else { BLACK };
             self.set_piece(to, position_move.promotion_piece | color);
         } else {
-            self.set_piece(to, self.get_piece(from).0);
+            self.set_piece(to, piece.0);
         }
         self.set_piece(from, 0);
 
@@ -931,42 +926,37 @@ impl BoardMap {
             ..
         } = piece_move;
 
-        // undo castling rook movement if this was a castling move
         let piece = self.get_piece(to);
+        let is_white = piece.get_color() == PieceColor::White;
+
+        // undo castling rook movement if this was a castling move
         if let Some(PieceType::King) = piece.get_type() {
             if from[1] == 4 && to[1] == 6 {
                 // undo kingside castle - move rook back from f-file to h-file
                 let rook_from = [from[0], 5];
                 let rook_to = [from[0], 7];
-                self.set_piece(rook_to, self.get_piece(rook_from).0);
+                let rook_piece = self.get_piece(rook_from).0;
+                self.set_piece(rook_to, rook_piece);
                 self.set_piece(rook_from, 0);
             } else if from[1] == 4 && to[1] == 2 {
                 // undo queenside castle - move rook back from d-file to a-file
                 let rook_from = [from[0], 3];
                 let rook_to = [from[0], 0];
-                self.set_piece(rook_to, self.get_piece(rook_from).0);
+                let rook_piece = self.get_piece(rook_from).0;
+                self.set_piece(rook_to, rook_piece);
                 self.set_piece(rook_from, 0);
             }
         }
 
-        self.set_piece(from, self.get_piece(to).0);
+        self.set_piece(from, piece.0);
         self.set_piece(to, last_piece);
 
         // undo en passant - restore the captured pawn
         if en_passant {
-            let moving_piece = self.get_piece(from);
-            let shift = if moving_piece.get_color() == PieceColor::Black {
-                1
-            } else {
-                -1
-            };
+            let shift = if is_white { -1 } else { 1 };
             let captured_pawn_pos = [(to[0] as isize - shift) as usize, to[1]];
             // restore the captured pawn (it was the opponent's pawn with en-passant flag)
-            let opponent_color = if moving_piece.get_color() == PieceColor::Black {
-                WHITE
-            } else {
-                BLACK
-            };
+            let opponent_color = if is_white { BLACK } else { WHITE };
             self.set_piece(captured_pawn_pos, PAWN | opponent_color | 32);
         }
     }

check-buddy/tests/perft_castling_test.rs

@@ -54,5 +54,8 @@ fn test_perft_castling_position() {
     // But let's see what we actually get
 
     // The standard perft value for this position at depth 1 is 26
-    assert_eq!(depth1, 26, "Should have 26 moves at depth 1 with castling available");
+    assert_eq!(
+        depth1, 26,
+        "Should have 26 moves at depth 1 with castling available"
+    );
 }