[position] Lazily build move lists in MoveGenerator structs

Merge branch 'lazily-build-move-lists'

core/src/colors.rs

@@ -10,8 +10,10 @@ pub enum Color {
 }
 
 impl Color {
-    pub fn iter() -> impl Iterator<Item = Color> {
+    pub const ALL: [Color; 2] = [Color::White, Color::Black];
-        [Color::White, Color::Black].into_iter()
+
+    pub fn iter() -> impl Iterator<Item = &'static Color> {
+        Color::ALL.iter()
     }
 
     pub fn other(&self) -> Color {

position/src/lib.rs

@@ -11,5 +11,9 @@ mod sight;
 #[macro_use]
 mod macros;
 
+#[cfg(test)]
+#[macro_use]
+mod tests;
+
 pub use position::{MoveBuilder as MakeMoveBuilder, Position, PositionBuilder};
 pub use r#move::{Castle, MakeMoveError, Move, MoveBuilder};

position/src/move.rs

@@ -16,6 +16,7 @@ pub enum MakeMoveError {
 }
 
 mod castle {
+    use chessfriend_bitboard::BitBoard;
     use chessfriend_core::{Color, Square};
 
     #[repr(u16)]
@@ -25,12 +26,19 @@ mod castle {
         QueenSide = 0b11,
     }
 
+    pub(crate) struct CastlingParameters {
+        clear_squares: BitBoard,
+        check_squares: BitBoard,
+    }
+
     pub(crate) struct Squares {
         pub king: Square,
         pub rook: Square,
     }
 
     impl Castle {
+        pub const ALL: [Castle; 2] = [Castle::KingSide, Castle::QueenSide];
+
         const STARTING_SQUARES: [[Squares; 2]; 2] = [
             [
                 Squares {
@@ -91,6 +99,29 @@ mod castle {
                 Castle::QueenSide => 1,
             }
         }
+
+        pub(crate) fn parameters(&self) -> CastlingParameters {
+            match self {
+                Castle::KingSide => CastlingParameters {
+                    clear_squares: BitBoard::new(0b01100000),
+                    check_squares: BitBoard::new(0b01110000),
+                },
+                Castle::QueenSide => CastlingParameters {
+                    clear_squares: BitBoard::new(0b00001110),
+                    check_squares: BitBoard::new(0b00011100),
+                },
+            }
+        }
+    }
+
+    impl CastlingParameters {
+        pub fn clear_squares(&self) -> &BitBoard {
+            &self.clear_squares
+        }
+
+        pub fn check_squares(&self) -> &BitBoard {
+            &self.check_squares
+        }
     }
 }
 

position/src/move_generator.rs

@@ -57,7 +57,7 @@ macro_rules! move_generator_declaration {
     };
     ($name:ident, getters) => {
         impl $name {
-            pub(super) fn iter(&self) -> impl Iterator<Item = &$crate::Move> + '_ {
+            pub(super) fn iter(&self) -> impl Iterator<Item = $crate::Move> + '_ {
                 self.move_sets.values().map(|set| set.moves()).flatten()
             }
 
@@ -141,7 +141,6 @@ impl Moves {
             .chain(self.rook_moves.iter())
             .chain(self.queen_moves.iter())
             .chain(self.king_moves.iter())
-            .cloned()
     }
 }
 

position/src/move_generator/bishop.rs

@@ -42,16 +42,12 @@ impl MoveGeneratorInternal for ClassicalMoveGenerator {
         update_moves_with_ray!(SouthEast, occupied_squares);
         update_moves_with_ray!(SouthWest, occupied_squares);
 
-        let quiet_moves_bb = all_moves & (empty_squares | !friendly_pieces);
+        let quiet_moves = all_moves & (empty_squares | !friendly_pieces);
-        let capture_moves_bb = all_moves & opposing_pieces;
+        let capture_moves = all_moves & opposing_pieces;
-
-        let map_to_move = |sq| MoveBuilder::new(*piece, square, sq).build();
-        let quiet_moves = quiet_moves_bb.occupied_squares().map(map_to_move);
-        let capture_moves = capture_moves_bb.occupied_squares().map(map_to_move);
 
         MoveSet::new(placed_piece)
-            .quiet_moves(quiet_moves_bb, quiet_moves)
+            .quiet_moves(quiet_moves)
-            .capture_moves(capture_moves_bb, capture_moves)
+            .capture_moves(capture_moves)
     }
 }
 

position/src/move_generator/king.rs

@@ -12,28 +12,6 @@ move_generator_declaration!(KingMoveGenerator, struct);
 move_generator_declaration!(KingMoveGenerator, new);
 move_generator_declaration!(KingMoveGenerator, getters);
 
-impl KingMoveGenerator {
-    #[allow(unused_variables)]
-    fn king_side_castle(position: &Position, color: Color) -> Option<Move> {
-        if !position.player_has_right_to_castle(color, Castle::KingSide) {
-            return None;
-        }
-
-        // TODO: Implement king side castle.
-        None
-    }
-
-    #[allow(unused_variables)]
-    fn queen_side_castle(position: &Position, color: Color) -> Option<Move> {
-        if !position.player_has_right_to_castle(color, Castle::QueenSide) {
-            return None;
-        }
-
-        // TODO: Implement queen side castle.
-        None
-    }
-}
-
 impl MoveGeneratorInternal for KingMoveGenerator {
     fn piece(color: Color) -> Piece {
         Piece::king(color)
@@ -44,37 +22,37 @@ impl MoveGeneratorInternal for KingMoveGenerator {
         let color = piece.color();
         let square = placed_piece.square();
 
+        let safe_squares = !position.king_danger(color);
+        let all_king_moves = BitBoard::king_moves(square);
+
         let empty_squares = position.empty_squares();
+        let safe_empty_squares = empty_squares & safe_squares;
+
         let opposing_pieces = position.bitboard_for_color(color.other());
+        let opposing_pieces_on_safe_squares = opposing_pieces & safe_squares;
 
-        let all_moves = BitBoard::king_moves(square);
+        let quiet_moves = all_king_moves & safe_empty_squares;
-        let quiet_moves_bb = all_moves & empty_squares;
+        let capture_moves = all_king_moves & opposing_pieces_on_safe_squares;
-        let capture_moves_bb = all_moves & opposing_pieces;
 
-        // TODO: Handle checks. Prevent moving a king to a square attacked by a
+        let mut move_set = MoveSet::new(placed_piece)
-        // piece of the opposite color.
+            .quiet_moves(quiet_moves)
+            .capture_moves(capture_moves);
 
-        let map_to_move = |sq| MoveBuilder::new(*piece, square, sq).build();
+        if position.player_can_castle(color, Castle::KingSide) {
+            move_set.kingside_castle();
+        }
+        if position.player_can_castle(color, Castle::QueenSide) {
+            move_set.queenside_castle();
+        }
 
-        let king_side_castle = Self::king_side_castle(position, color);
+        move_set
-        let queen_side_castle = Self::queen_side_castle(position, color);
-        let quiet_moves = quiet_moves_bb
-            .occupied_squares()
-            .map(map_to_move)
-            .chain(king_side_castle.iter().cloned())
-            .chain(queen_side_castle.iter().cloned());
-        let capture_moves = capture_moves_bb.occupied_squares().map(map_to_move);
-
-        MoveSet::new(placed_piece)
-            .quiet_moves(quiet_moves_bb, quiet_moves)
-            .capture_moves(capture_moves_bb, capture_moves)
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{position, r#move::AlgebraicMoveFormatter, PositionBuilder};
+    use crate::{assert_move_list, position, test_position, PositionBuilder};
     use chessfriend_bitboard::bitboard;
     use chessfriend_core::{piece, Square};
     use std::collections::HashSet;
@@ -90,7 +68,7 @@ mod tests {
             bitboard![E5, F5, F4, F3, E3, D3, D4, D5]
         );
 
-        let expected_moves = [
+        let expected_moves: HashSet<Move> = HashSet::from_iter([
             MoveBuilder::new(piece!(White King), Square::E4, Square::D5).build(),
             MoveBuilder::new(piece!(White King), Square::E4, Square::E5).build(),
             MoveBuilder::new(piece!(White King), Square::E4, Square::F5).build(),
@@ -99,23 +77,11 @@ mod tests {
             MoveBuilder::new(piece!(White King), Square::E4, Square::E3).build(),
             MoveBuilder::new(piece!(White King), Square::E4, Square::D3).build(),
             MoveBuilder::new(piece!(White King), Square::E4, Square::D4).build(),
-        ];
+        ]);
 
-        let mut generated_moves: HashSet<Move> = generator.iter().cloned().collect();
+        let generated_moves: HashSet<Move> = generator.iter().collect();
 
-        for ex_move in expected_moves {
+        assert_move_list!(generated_moves, expected_moves, pos);
-            assert!(
-                generated_moves.remove(&ex_move),
-                "{:#?} was not generated",
-                &ex_move
-            );
-        }
-
-        assert!(
-            generated_moves.is_empty(),
-            "Moves unexpectedly present: {:#?}",
-            generated_moves
-        );
     }
 
     #[test]
@@ -138,7 +104,7 @@ mod tests {
             MoveBuilder::new(piece!(White King), Square::A1, Square::B2).build(),
         ];
 
-        let mut generated_moves: HashSet<Move> = generator.iter().cloned().collect();
+        let mut generated_moves: HashSet<Move> = generator.iter().collect();
 
         for ex_move in expected_moves {
             assert!(
@@ -167,27 +133,93 @@ mod tests {
         assert!(pos.is_king_in_check());
 
         let generator = KingMoveGenerator::new(&pos, Color::Black);
-        let generated_moves: HashSet<Move> = generator.iter().cloned().collect();
+        let generated_moves = generator.bitboard();
 
-        let king = piece!(Black King);
+        let expected_moves = bitboard![F8, F7, F6, D6, D7, D8];
-        let from_square = Square::E7;
-        let expected_moves = HashSet::from_iter([
-            MoveBuilder::new(king, from_square, Square::D6).build(),
-            MoveBuilder::new(king, from_square, Square::D7).build(),
-            MoveBuilder::new(king, from_square, Square::D8).build(),
-            MoveBuilder::new(king, from_square, Square::F6).build(),
-            MoveBuilder::new(king, from_square, Square::F7).build(),
-            MoveBuilder::new(king, from_square, Square::F8).build(),
-        ]);
 
-        assert_eq!(
+        assert_eq!(generated_moves, expected_moves);
-            generated_moves,
+    }
-            expected_moves,
+
-            "Difference: {:?}",
+    #[test]
-            generated_moves
+    fn white_king_unobstructed_castles() {
-                .symmetric_difference(&expected_moves)
+        let pos = test_position!(
-                .map(|mv| format!("{}", AlgebraicMoveFormatter::new(mv, &pos)))
+            White King on E1,
-                .collect::<Vec<_>>()
+            White Rook on A1,
+            White Rook on H1,
         );
+
+        assert!(pos.player_can_castle(Color::White, Castle::KingSide));
+        assert!(pos.player_can_castle(Color::White, Castle::QueenSide));
+
+        let generator = KingMoveGenerator::new(&pos, Color::White);
+        let generated_moves: HashSet<Move> = generator.iter().collect();
+
+        let king = piece!(White King);
+        assert!(generated_moves.contains(
+            &MoveBuilder::new(king, Square::E1, Square::G1)
+                .castle(Castle::KingSide)
+                .build()
+        ));
+        assert!(generated_moves.contains(
+            &MoveBuilder::new(king, Square::E1, Square::C1)
+                .castle(Castle::QueenSide)
+                .build()
+        ));
+    }
+
+    #[test]
+    fn white_king_obstructed_queenside_castle() {
+        let pos = test_position!(
+            White King on E1,
+            White Knight on B1,
+            White Rook on A1,
+            White Rook on H1,
+        );
+
+        assert!(pos.player_can_castle(Color::White, Castle::KingSide));
+        assert!(!pos.player_can_castle(Color::White, Castle::QueenSide));
+
+        let generator = KingMoveGenerator::new(&pos, Color::White);
+        let generated_moves: HashSet<Move> = generator.iter().collect();
+
+        let king = piece!(White King);
+        assert!(generated_moves.contains(
+            &MoveBuilder::new(king, Square::E1, Square::G1)
+                .castle(Castle::KingSide)
+                .build()
+        ));
+        assert!(!generated_moves.contains(
+            &MoveBuilder::new(king, Square::E1, Square::C1)
+                .castle(Castle::QueenSide)
+                .build()
+        ));
+    }
+
+    #[test]
+    fn white_king_obstructed_kingside_castle() {
+        let pos = test_position!(
+            White King on E1,
+            White Rook on A1,
+            White Knight on G1,
+            White Rook on H1,
+        );
+
+        assert!(!pos.player_can_castle(Color::White, Castle::KingSide));
+        assert!(pos.player_can_castle(Color::White, Castle::QueenSide));
+
+        let generator = KingMoveGenerator::new(&pos, Color::White);
+        let generated_moves: HashSet<Move> = generator.iter().collect();
+
+        let king = piece!(White King);
+        assert!(!generated_moves.contains(
+            &MoveBuilder::new(king, Square::E1, Square::G1)
+                .castle(Castle::KingSide)
+                .build()
+        ));
+        assert!(generated_moves.contains(
+            &MoveBuilder::new(king, Square::E1, Square::C1)
+                .castle(Castle::QueenSide)
+                .build()
+        ));
     }
 }

position/src/move_generator/knight.rs

@@ -17,22 +17,12 @@ impl MoveGeneratorInternal for KnightMoveGenerator {
         let empty_squares = position.empty_squares();
         let knight_moves = BitBoard::knight_moves(placed_piece.square());
 
-        let quiet_moves_bb = knight_moves & empty_squares;
+        let quiet_moves = knight_moves & empty_squares;
-        let capture_moves_bb = knight_moves & opposing_pieces;
+        let capture_moves = knight_moves & opposing_pieces;
-
-        let quiet_moves = quiet_moves_bb.occupied_squares().map(|to_sq| {
-            MoveBuilder::new(*placed_piece.piece(), placed_piece.square(), to_sq).build()
-        });
-        let capture_moves = capture_moves_bb.occupied_squares().map(|to_sq| {
-            let captured_piece = position.piece_on_square(to_sq).unwrap();
-            MoveBuilder::new(*placed_piece.piece(), placed_piece.square(), to_sq)
-                .capturing(captured_piece)
-                .build()
-        });
 
         MoveSet::new(placed_piece)
-            .quiet_moves(quiet_moves_bb, quiet_moves)
+            .quiet_moves(quiet_moves)
-            .capture_moves(capture_moves_bb, capture_moves)
+            .capture_moves(capture_moves)
     }
 }
 
@@ -72,7 +62,7 @@ mod tests {
             MoveBuilder::new(piece!(White Knight), Square::E4, Square::F6).build(),
         ];
 
-        let mut generated_moves: HashSet<Move> = generator.iter().cloned().collect();
+        let mut generated_moves: HashSet<Move> = generator.iter().collect();
 
         for ex_move in expected_moves {
             assert!(

position/src/move_generator/move_set.rs

@@ -1,10 +1,10 @@
 // Eryn Wells <eryn@erynwells.me>
 
-use crate::Move;
+use crate::{r#move::Castle, Move, MoveBuilder};
 use chessfriend_bitboard::BitBoard;
-use chessfriend_core::PlacedPiece;
+use chessfriend_core::{Color, Piece, PlacedPiece, Shape};
 
-#[derive(Clone, Debug, Eq, PartialEq)]
+#[derive(Clone, Debug, Default, Eq, PartialEq)]
 struct BitBoardSet {
     quiet: BitBoard,
     captures: BitBoard,
@@ -27,43 +27,35 @@ impl MoveListSet {
 pub(crate) struct MoveSet {
     piece: PlacedPiece,
     bitboards: BitBoardSet,
-    move_lists: MoveListSet,
+    special: u8,
 }
 
 impl MoveSet {
     pub(super) fn new(piece: PlacedPiece) -> MoveSet {
         MoveSet {
             piece,
-            bitboards: BitBoardSet {
+            bitboards: BitBoardSet::default(),
-                quiet: BitBoard::empty(),
+            special: 0,
-                captures: BitBoard::empty(),
-            },
-            move_lists: MoveListSet {
-                quiet: Vec::new(),
-                captures: Vec::new(),
-            },
         }
     }
 
-    pub(super) fn quiet_moves(
+    pub(super) fn quiet_moves(mut self, bitboard: BitBoard) -> MoveSet {
-        mut self,
-        bitboard: BitBoard,
-        move_list: impl Iterator<Item = Move>,
-    ) -> MoveSet {
         self.bitboards.quiet = bitboard;
-        self.move_lists.quiet = move_list.collect();
-
         self
     }
 
-    pub(super) fn capture_moves(
+    pub(super) fn capture_moves(mut self, bitboard: BitBoard) -> MoveSet {
-        mut self,
-        bitboard: BitBoard,
-        move_list: impl Iterator<Item = Move>,
-    ) -> MoveSet {
         self.bitboards.captures = bitboard;
-        self.move_lists.captures = move_list.collect();
+        self
+    }
 
+    pub(super) fn kingside_castle(&mut self) -> &mut MoveSet {
+        self.special |= 0b1;
+        self
+    }
+
+    pub(super) fn queenside_castle(&mut self) -> &mut MoveSet {
+        self.special |= 0b10;
         self
     }
 
@@ -72,10 +64,58 @@ impl MoveSet {
         self.bitboards.captures | self.bitboards.quiet
     }
 
-    pub(super) fn moves(&self) -> impl Iterator<Item = &Move> {
+    pub(super) fn moves(&self) -> impl Iterator<Item = Move> + '_ {
-        self.move_lists
+        let piece = self.piece.piece();
-            .captures
+        let from_square = self.piece.square();
-            .iter()
+
-            .chain(self.move_lists.quiet.iter())
+        self.bitboards
+            .quiet
+            .occupied_squares()
+            .map(move |to_square| MoveBuilder::new(*piece, from_square, to_square).build())
+            .chain(
+                self.bitboards
+                    .captures
+                    .occupied_squares()
+                    .map(move |to_square| {
+                        MoveBuilder::new(*piece, from_square, to_square)
+                            .capturing(PlacedPiece::new(
+                                Piece::new(Color::White, Shape::Pawn),
+                                to_square,
+                            ))
+                            .build()
+                    }),
+            )
+            .chain(
+                if (self.special & 0b1) != 0 {
+                    Some(())
+                } else {
+                    None
+                }
+                .map(|()| {
+                    MoveBuilder::new(
+                        *piece,
+                        from_square,
+                        Castle::KingSide.target_squares(piece.color()).king,
+                    )
+                    .castle(Castle::KingSide)
+                    .build()
+                }),
+            )
+            .chain(
+                if (self.special & 0b10) != 0 {
+                    Some(())
+                } else {
+                    None
+                }
+                .map(|()| {
+                    MoveBuilder::new(
+                        *piece,
+                        from_square,
+                        Castle::QueenSide.target_squares(piece.color()).king,
+                    )
+                    .castle(Castle::QueenSide)
+                    .build()
+                }),
+            )
     }
 }

position/src/move_generator/pawn.rs

@@ -1,7 +1,7 @@
 // Eryn Wells <eryn@erynwells.me>
 
 use super::{move_generator_declaration, MoveGeneratorInternal, MoveSet};
-use crate::{MoveBuilder, Position};
+use crate::Position;
 use chessfriend_bitboard::BitBoard;
 use chessfriend_core::{Color, Piece, PlacedPiece, Rank, Square};
 
@@ -16,24 +16,12 @@ impl MoveGeneratorInternal for PawnMoveGenerator {
     }
 
     fn move_set_for_piece(position: &Position, placed_piece: PlacedPiece) -> MoveSet {
-        let from_square = placed_piece.square();
+        let capture_moves = Self::attacks(position, placed_piece);
-
+        let quiet_moves = Self::pushes(position, placed_piece);
-        let captures_bitboard = Self::attacks(position, placed_piece);
-        let quiet_moves_bitboard = Self::pushes(position, placed_piece);
-
-        let quiet_moves = quiet_moves_bitboard.occupied_squares().map(|to_square| {
-            MoveBuilder::new(*placed_piece.piece(), from_square, to_square).build()
-        });
-        let capture_moves = captures_bitboard.occupied_squares().map(|to_square| {
-            let captured_piece = position.piece_on_square(to_square).unwrap();
-            MoveBuilder::new(*placed_piece.piece(), from_square, to_square)
-                .capturing(captured_piece)
-                .build()
-        });
 
         MoveSet::new(placed_piece)
-            .quiet_moves(quiet_moves_bitboard, quiet_moves)
+            .quiet_moves(quiet_moves)
-            .capture_moves(captures_bitboard, capture_moves)
+            .capture_moves(capture_moves)
     }
 }
 
@@ -42,13 +30,11 @@ impl PawnMoveGenerator {
         let square = piece.square();
         let bitboard: BitBoard = square.into();
 
-        let empty_squares = position.empty_squares();
+        let starting_rank = Rank::PAWN_STARTING_RANKS[piece.color() as usize];
 
+        let empty_squares = position.empty_squares();
         let mut moves = bitboard.shift_north_one() & empty_squares;
-        if !(bitboard
+        if !(bitboard & BitBoard::rank(starting_rank.as_index())).is_empty() {
-            & BitBoard::rank(Rank::PAWN_STARTING_RANKS[piece.color() as usize].as_index()))
-        .is_empty()
-        {
             moves |= moves.shift_north_one() & empty_squares;
         }
 
@@ -71,7 +57,7 @@ impl PawnMoveGenerator {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{position::DiagramFormatter, test_position, Move};
+    use crate::{assert_move_list, position::DiagramFormatter, test_position, Move, MoveBuilder};
     use chessfriend_core::{piece, Square};
     use std::collections::HashSet;
 
@@ -86,7 +72,7 @@ mod tests {
             MoveBuilder::new(piece!(White Pawn), Square::E2, Square::E4).build(),
         ]);
 
-        let generated_moves: HashSet<Move> = generator.iter().cloned().collect();
+        let generated_moves: HashSet<Move> = generator.iter().collect();
 
         assert_eq!(generated_moves, expected_moves);
     }
@@ -104,9 +90,9 @@ mod tests {
         )
         .build()]);
 
-        let generated_moves: HashSet<Move> = generator.iter().cloned().collect();
+        let generated_moves: HashSet<Move> = generator.iter().collect();
 
-        assert_eq!(generated_moves, expected_moves);
+        assert_move_list!(generated_moves, expected_moves, pos);
     }
 
     #[test]
@@ -127,9 +113,9 @@ mod tests {
         )
         .build()]);
 
-        let generated_moves: HashSet<Move> = generator.iter().cloned().collect();
+        let generated_moves: HashSet<Move> = generator.iter().collect();
 
-        assert_eq!(generated_moves, expected_moves);
+        assert_move_list!(generated_moves, expected_moves, pos);
     }
 
     #[test]
@@ -141,9 +127,10 @@ mod tests {
 
         let generator = PawnMoveGenerator::new(&pos, Color::White);
 
-        let generated_moves: HashSet<Move> = generator.iter().cloned().collect();
+        let generated_moves: HashSet<Move> = generator.iter().collect();
+        let expected_moves: HashSet<Move> = HashSet::new();
 
-        assert_eq!(generated_moves, HashSet::new());
+        assert_move_list!(generated_moves, expected_moves, pos);
     }
 
     #[test]
@@ -163,7 +150,7 @@ mod tests {
                     .build()],
             );
 
-        let generated_moves: HashSet<Move> = generator.iter().cloned().collect();
+        let generated_moves: HashSet<Move> = generator.iter().collect();
 
         assert_eq!(generated_moves, expected_moves);
     }
@@ -188,7 +175,7 @@ mod tests {
                 .build(),
         ]);
 
-        let generated_moves: HashSet<Move> = generator.iter().cloned().collect();
+        let generated_moves: HashSet<Move> = generator.iter().collect();
 
         assert_eq!(
             generated_moves, expected_moves,

position/src/move_generator/queen.rs

@@ -1,7 +1,7 @@
 // Eryn Wells <eryn@erynwells.me>
 
 use super::{move_generator_declaration, MoveGeneratorInternal, MoveSet};
-use crate::{MoveBuilder, Position};
+use crate::Position;
 use chessfriend_bitboard::BitBoard;
 use chessfriend_core::{Color, Direction, Piece, PlacedPiece};
 
@@ -48,16 +48,12 @@ impl MoveGeneratorInternal for ClassicalMoveGenerator {
         update_moves_with_ray!(SouthWest, occupied_squares);
         update_moves_with_ray!(West, occupied_squares);
 
-        let quiet_moves_bb = all_moves & (empty_squares | !friendly_pieces);
+        let quiet_moves = all_moves & (empty_squares | !friendly_pieces);
-        let capture_moves_bb = all_moves & opposing_pieces;
+        let capture_moves = all_moves & opposing_pieces;
-
-        let map_to_move = |sq| MoveBuilder::new(*piece, square, sq).build();
-        let quiet_moves = quiet_moves_bb.occupied_squares().map(map_to_move);
-        let capture_moves = capture_moves_bb.occupied_squares().map(map_to_move);
 
         MoveSet::new(placed_piece)
-            .quiet_moves(quiet_moves_bb, quiet_moves)
+            .quiet_moves(quiet_moves)
-            .capture_moves(capture_moves_bb, capture_moves)
+            .capture_moves(capture_moves)
     }
 }
 

position/src/move_generator/rook.rs

@@ -1,7 +1,7 @@
 // Eryn Wells <eryn@erynwells.me>
 
 use super::{move_generator_declaration, MoveGeneratorInternal, MoveSet};
-use crate::{MoveBuilder, Position};
+use crate::Position;
 use chessfriend_bitboard::BitBoard;
 use chessfriend_core::{Color, Direction, Piece, PlacedPiece};
 
@@ -44,16 +44,12 @@ impl MoveGeneratorInternal for ClassicalMoveGenerator {
         update_moves_with_ray!(South, occupied_squares);
         update_moves_with_ray!(West, occupied_squares);
 
-        let quiet_moves_bb = all_moves & (empty_squares | !friendly_pieces);
+        let quiet_moves = all_moves & (empty_squares | !friendly_pieces);
-        let capture_moves_bb = all_moves & opposing_pieces;
+        let capture_moves = all_moves & opposing_pieces;
-
-        let map_to_move = |sq| MoveBuilder::new(*piece, square, sq).build();
-        let quiet_moves = quiet_moves_bb.occupied_squares().map(map_to_move);
-        let capture_moves = capture_moves_bb.occupied_squares().map(map_to_move);
 
         MoveSet::new(placed_piece)
-            .quiet_moves(quiet_moves_bb, quiet_moves)
+            .quiet_moves(quiet_moves)
-            .capture_moves(capture_moves_bb, capture_moves)
+            .capture_moves(capture_moves)
     }
 }
 

position/src/position/builders/position_builder.rs

@@ -61,9 +61,11 @@ impl Builder {
 
     pub fn place_piece(&mut self, piece: PlacedPiece) -> &mut Self {
         let square = piece.square();
+        let shape = piece.shape();
 
-        if piece.shape() == Shape::King {
+        if shape == Shape::King {
-            let color_index: usize = piece.color() as usize;
+            let color = piece.color();
+            let color_index: usize = color as usize;
             self.pieces.remove(&self.kings[color_index]);
             self.kings[color_index] = square;
         }
@@ -81,9 +83,27 @@ impl Builder {
                 .filter(Self::is_piece_placement_valid),
         );
 
+        let mut flags = self.flags;
+
+        for color in Color::ALL {
+            for castle in Castle::ALL {
+                let starting_squares = castle.starting_squares(color);
+                let has_rook_on_starting_square = self
+                    .pieces
+                    .get(&starting_squares.rook)
+                    .is_some_and(|piece| piece.shape() == Shape::Rook);
+                let king_is_on_starting_square =
+                    self.kings[color as usize] == starting_squares.king;
+
+                if !king_is_on_starting_square || !has_rook_on_starting_square {
+                    flags.clear_player_has_right_to_castle_flag(color, castle);
+                }
+            }
+        }
+
         Position::new(
             self.player_to_move,
-            self.flags,
+            flags,
             pieces,
             None,
             self.ply_counter,

position/src/position/position.rs

@@ -107,7 +107,17 @@ impl Position {
             return false;
         }
 
-        // TODO: Perform a real check that the player can castle.
+        let castling_parameters = castle.parameters();
+
+        let all_pieces = self.occupied_squares();
+        if !(all_pieces & castling_parameters.clear_squares()).is_empty() {
+            return false;
+        }
+
+        let danger_squares = self.king_danger(player);
+        if !(danger_squares & castling_parameters.check_squares()).is_empty() {
+            return false;
+        }
 
         true
     }
@@ -159,7 +169,7 @@ impl Position {
     pub fn piece_on_square(&self, sq: Square) -> Option<PlacedPiece> {
         for color in Color::iter() {
             for shape in Shape::iter() {
-                let piece = Piece::new(color, *shape);
+                let piece = Piece::new(*color, *shape);
                 if self.pieces.bitboard_for_piece(&piece).is_set(sq) {
                     return Some(PlacedPiece::new(piece, sq));
                 }
@@ -212,19 +222,16 @@ impl Position {
 
     /// A bitboard representing the squares where a king of the given color will
     /// be in danger. The king cannot move to these squares.
-    pub(crate) fn king_danger(&self) -> BitBoard {
+    pub(crate) fn king_danger(&self, color: Color) -> BitBoard {
         let pieces_without_king = {
             let mut cloned_pieces = self.pieces.clone();
-            let placed_king = PlacedPiece::new(
+            let placed_king = PlacedPiece::new(Piece::king(color), self.king_square(color));
-                Piece::king(self.color_to_move),
-                self.king_square(self.color_to_move),
-            );
             cloned_pieces.remove_piece(&placed_king);
 
             cloned_pieces
         };
 
-        self._sight_of_player(self.color_to_move.other(), &pieces_without_king)
+        self._sight_of_player(color.other(), &pieces_without_king)
     }
 
     pub(crate) fn is_king_in_check(&self) -> bool {
@@ -363,6 +370,25 @@ mod tests {
         assert!(!pos.is_king_in_check());
     }
 
+    #[test]
+    fn king_not_on_starting_square_cannot_castle() {
+        let pos = test_position!(White King on E4);
+        assert!(!pos.player_can_castle(Color::White, Castle::KingSide));
+        assert!(!pos.player_can_castle(Color::White, Castle::QueenSide));
+    }
+
+    #[test]
+    fn king_on_starting_square_can_castle() {
+        let pos = test_position!(
+            White King on E1,
+            White Rook on A1,
+            White Rook on H1
+        );
+
+        assert!(pos.player_can_castle(Color::White, Castle::KingSide));
+        assert!(pos.player_can_castle(Color::White, Castle::QueenSide));
+    }
+
     #[test]
     fn rook_for_castle() {
         let pos = position![
@@ -390,7 +416,7 @@ mod tests {
             .to_move(Color::Black)
             .build();
 
-        let danger_squares = pos.king_danger();
+        let danger_squares = pos.king_danger(Color::Black);
         let expected =
             bitboard![D1, F1, D2, E2, F2, E3, A4, B4, C4, D4, F4, G4, H4, E5, E6, E7, E8];
         assert_eq!(

position/src/tests.rs

@@ -0,0 +1,19 @@
+// Eryn Wells <eryn@erynwells.me>
+
+#[macro_export]
+macro_rules! assert_move_list {
+    ($generated:expr, $expected:expr, $position:expr) => {
+        assert_eq!(
+            $generated,
+            $expected,
+            "Difference: {:?}",
+            $generated
+                .symmetric_difference(&$expected)
+                .map(|mv| format!(
+                    "{}",
+                    $crate::r#move::AlgebraicMoveFormatter::new(mv, &$position)
+                ))
+                .collect::<Vec<String>>()
+        )
+    };
+}