Directly rename board -> position

position/src/move_generator/bishop.rs

@@ -0,0 +1,139 @@
+// Eryn Wells <eryn@erynwells.me>
+
+use super::{move_generator_declaration, MoveGeneratorInternal, MoveSet};
+use crate::{MoveBuilder, Position};
+use chessfriend_bitboard::BitBoard;
+use chessfriend_core::{Color, Direction, Piece, PlacedPiece};
+
+move_generator_declaration!(ClassicalMoveGenerator);
+
+impl MoveGeneratorInternal for ClassicalMoveGenerator {
+    fn piece(color: Color) -> Piece {
+        Piece::bishop(color)
+    }
+
+    fn move_set_for_piece(position: &Position, placed_piece: PlacedPiece) -> MoveSet {
+        let piece = placed_piece.piece();
+        let square = placed_piece.square();
+
+        let blockers = position.occupied_squares();
+        let empty_squares = !blockers;
+        let (friendly_pieces, opposing_pieces) = position.all_pieces();
+
+        let mut all_moves = BitBoard::empty();
+
+        macro_rules! update_moves_with_ray {
+            ($direction:ident, $occupied_squares:tt) => {
+                let ray = BitBoard::ray(square, Direction::$direction);
+                if let Some(first_occupied_square) =
+                    BitBoard::$occupied_squares(&(ray & blockers)).next()
+                {
+                    let remainder = BitBoard::ray(first_occupied_square, Direction::$direction);
+                    let attack_ray = ray & !remainder;
+                    all_moves |= attack_ray;
+                } else {
+                    all_moves |= ray;
+                }
+            };
+        }
+
+        update_moves_with_ray!(NorthEast, occupied_squares_trailing);
+        update_moves_with_ray!(NorthWest, occupied_squares_trailing);
+        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 capture_moves_bb = 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)
+            .capture_moves(capture_moves_bb, capture_moves)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{position, position::DiagramFormatter};
+    use chessfriend_bitboard::BitBoard;
+    use chessfriend_core::Color;
+
+    #[test]
+    fn classical_single_bishop_bitboard() {
+        let pos = position![
+            White Bishop on A1,
+        ];
+
+        let generator = ClassicalMoveGenerator::new(&pos, Color::White);
+
+        assert_eq!(
+            generator.bitboard(),
+            BitBoard::new(
+                0b10000000_01000000_00100000_00010000_00001000_00000100_00000010_00000000
+            )
+        );
+    }
+
+    /// Test that a bishop can move up to, but not onto, a friendly piece.
+    #[test]
+    fn classical_single_bishop_with_same_color_blocker_bitboard() {
+        let pos = position![
+            White Bishop on A1,
+            White Knight on E5,
+        ];
+
+        println!("{}", DiagramFormatter::new(&pos));
+
+        let generator = ClassicalMoveGenerator::new(&pos, Color::White);
+
+        assert_eq!(
+            generator.bitboard(),
+            BitBoard::new(
+                0b00000000_00000000_00000000_00000000_00001000_00000100_00000010_00000000
+            )
+        );
+    }
+
+    /// Test that a rook can move up to, and then capture, an enemy piece.
+    #[test]
+    fn classical_single_bishop_with_opposing_color_blocker_bitboard() {
+        let pos = position![
+            White Bishop on A1,
+            Black Knight on C3,
+        ];
+
+        let generator = ClassicalMoveGenerator::new(&pos, Color::White);
+
+        assert_eq!(
+            generator.bitboard(),
+            BitBoard::new(
+                0b00000000_00000000_00000000_00000000_00000000_00000100_00000010_00000000
+            )
+        );
+    }
+
+    #[test]
+    fn classical_single_bishop_in_center() {
+        let pos = position![
+            White Bishop on E4,
+        ];
+
+        println!("{}", DiagramFormatter::new(&pos));
+
+        let generator = ClassicalMoveGenerator::new(&pos, Color::White);
+        let bitboard = generator.bitboard();
+        let expected = BitBoard::new(
+            0b00000001_10000010_01000100_00101000_00000000_00101000_01000100_10000010,
+        );
+
+        assert_eq!(
+            bitboard, expected,
+            "actual:\n{}\nexpected:\n{}",
+            bitboard, expected
+        );
+    }
+}

position/src/move_generator/king.rs

@@ -0,0 +1,193 @@
+// Eryn Wells <eryn@erynwells.me>
+
+//! Declares the KingMoveGenerator type. This struct is responsible for
+//! generating the possible moves for the king in the given position.
+
+use super::{move_generator_declaration, MoveGeneratorInternal, MoveSet};
+use crate::{r#move::Castle, Move, MoveBuilder, Position};
+use chessfriend_bitboard::BitBoard;
+use chessfriend_core::{Color, Piece, PlacedPiece};
+
+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)
+    }
+
+    fn move_set_for_piece(position: &Position, placed_piece: PlacedPiece) -> MoveSet {
+        let piece = placed_piece.piece();
+        let color = piece.color();
+        let square = placed_piece.square();
+
+        let empty_squares = position.empty_squares();
+        let opposing_pieces = position.bitboard_for_color(color.other());
+
+        let all_moves = BitBoard::king_moves(square);
+        let quiet_moves_bb = all_moves & empty_squares;
+        let capture_moves_bb = all_moves & opposing_pieces;
+
+        // TODO: Handle checks. Prevent moving a king to a square attacked by a
+        // piece of the opposite color.
+
+        let map_to_move = |sq| MoveBuilder::new(*piece, square, sq).build();
+
+        let king_side_castle = Self::king_side_castle(position, color);
+        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 chessfriend_bitboard::bitboard;
+    use chessfriend_core::{piece, Square};
+    use std::collections::HashSet;
+
+    #[test]
+    fn one_king() {
+        let pos = position![White King on E4];
+
+        let generator = KingMoveGenerator::new(&pos, Color::White);
+
+        assert_eq!(
+            generator.bitboard(),
+            bitboard![E5, F5, F4, F3, E3, D3, D4, D5]
+        );
+
+        let expected_moves = [
+            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(),
+            MoveBuilder::new(piece!(White King), Square::E4, Square::F4).build(),
+            MoveBuilder::new(piece!(White King), Square::E4, Square::F3).build(),
+            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();
+
+        for ex_move in expected_moves {
+            assert!(
+                generated_moves.remove(&ex_move),
+                "{:#?} was not generated",
+                &ex_move
+            );
+        }
+
+        assert!(
+            generated_moves.is_empty(),
+            "Moves unexpectedly present: {:#?}",
+            generated_moves
+        );
+    }
+
+    #[test]
+    fn one_king_corner() {
+        let pos = position![White King on A1];
+
+        let generator = KingMoveGenerator::new(&pos, Color::White);
+
+        let generated_bitboard = generator.bitboard();
+        let expected_bitboard = bitboard![A2, B2, B1];
+        assert_eq!(
+            generator.bitboard(),
+            bitboard![A2, B2, B1],
+            "Generated:\n{generated_bitboard}\nExpected:\n{expected_bitboard}"
+        );
+
+        let expected_moves = [
+            MoveBuilder::new(piece!(White King), Square::A1, Square::A2).build(),
+            MoveBuilder::new(piece!(White King), Square::A1, Square::B1).build(),
+            MoveBuilder::new(piece!(White King), Square::A1, Square::B2).build(),
+        ];
+
+        let mut generated_moves: HashSet<Move> = generator.iter().cloned().collect();
+
+        for ex_move in expected_moves {
+            assert!(
+                generated_moves.remove(&ex_move),
+                "{:#?} was not generated",
+                &ex_move
+            );
+        }
+
+        assert!(
+            generated_moves.is_empty(),
+            "Moves unexpectedly present: {:#?}",
+            generated_moves
+        );
+    }
+
+    #[test]
+    fn black_king_in_check_by_rook() {
+        let pos = PositionBuilder::new()
+            .place_piece(piece!(White King on E1))
+            .place_piece(piece!(White Rook on E4))
+            .place_piece(piece!(Black King on E7))
+            .to_move(Color::Black)
+            .build();
+
+        assert!(pos.is_king_in_check());
+
+        let generator = KingMoveGenerator::new(&pos, Color::Black);
+        let generated_moves: HashSet<Move> = generator.iter().cloned().collect();
+
+        let king = piece!(Black King);
+        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!(
+            generated_moves,
+            expected_moves,
+            "Difference: {:?}",
+            generated_moves
+                .symmetric_difference(&expected_moves)
+                .map(|mv| format!("{}", AlgebraicMoveFormatter::new(mv, &pos)))
+                .collect::<Vec<_>>()
+        );
+    }
+}

position/src/move_generator/knight.rs

@@ -0,0 +1,91 @@
+// Eryn Wells <eryn@erynwells.me>
+
+use super::{move_generator_declaration, MoveGeneratorInternal, MoveSet};
+use crate::{MoveBuilder, Position};
+use chessfriend_bitboard::BitBoard;
+use chessfriend_core::{Color, Piece, PlacedPiece};
+
+move_generator_declaration!(KnightMoveGenerator);
+
+impl MoveGeneratorInternal for KnightMoveGenerator {
+    fn piece(color: Color) -> Piece {
+        Piece::knight(color)
+    }
+
+    fn move_set_for_piece(position: &Position, placed_piece: PlacedPiece) -> MoveSet {
+        let opposing_pieces = position.bitboard_for_color(placed_piece.piece().color().other());
+        let empty_squares = position.empty_squares();
+        let knight_moves = BitBoard::knight_moves(placed_piece.square());
+
+        let quiet_moves_bb = knight_moves & empty_squares;
+        let capture_moves_bb = 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)
+            .capture_moves(capture_moves_bb, capture_moves)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{position, Move};
+    use chessfriend_core::{piece, Square};
+    use std::collections::HashSet;
+
+    #[test]
+    fn one_knight() {
+        let pos = position![
+            White Knight on E4,
+        ];
+
+        let generator = KnightMoveGenerator::new(&pos, Color::White);
+
+        /*
+        let bb = generator.bitboard();
+        assert_eq!(
+            bb,
+            BitBoard::new(
+                0b00000000_00000000_00000000_00111000_00101000_00111000_00000000_00000000
+            )
+        );
+        */
+
+        let expected_moves = [
+            MoveBuilder::new(piece!(White Knight), Square::E4, Square::C3).build(),
+            MoveBuilder::new(piece!(White Knight), Square::E4, Square::D2).build(),
+            MoveBuilder::new(piece!(White Knight), Square::E4, Square::F2).build(),
+            MoveBuilder::new(piece!(White Knight), Square::E4, Square::G3).build(),
+            MoveBuilder::new(piece!(White Knight), Square::E4, Square::C5).build(),
+            MoveBuilder::new(piece!(White Knight), Square::E4, Square::D6).build(),
+            MoveBuilder::new(piece!(White Knight), Square::E4, Square::G5).build(),
+            MoveBuilder::new(piece!(White Knight), Square::E4, Square::F6).build(),
+        ];
+
+        let mut generated_moves: HashSet<Move> = generator.iter().cloned().collect();
+
+        for ex_move in expected_moves {
+            assert!(
+                generated_moves.remove(&ex_move),
+                "{:#?} was not generated",
+                &ex_move
+            );
+        }
+
+        assert!(
+            generated_moves.is_empty(),
+            "Moves unexpectedly present: {:#?}",
+            generated_moves
+        );
+    }
+}

position/src/move_generator/move_set.rs

@@ -0,0 +1,81 @@
+// Eryn Wells <eryn@erynwells.me>
+
+use crate::Move;
+use chessfriend_bitboard::BitBoard;
+use chessfriend_core::PlacedPiece;
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+struct BitBoardSet {
+    quiet: BitBoard,
+    captures: BitBoard,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+struct MoveListSet {
+    quiet: Vec<Move>,
+    captures: Vec<Move>,
+}
+
+impl MoveListSet {
+    pub fn contains(&self, mv: &Move) -> bool {
+        self.quiet.contains(mv) || self.captures.contains(mv)
+    }
+}
+
+/// A set of moves for a piece on the board.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) struct MoveSet {
+    piece: PlacedPiece,
+    bitboards: BitBoardSet,
+    move_lists: MoveListSet,
+}
+
+impl MoveSet {
+    pub(super) fn new(piece: PlacedPiece) -> MoveSet {
+        MoveSet {
+            piece,
+            bitboards: BitBoardSet {
+                quiet: BitBoard::empty(),
+                captures: BitBoard::empty(),
+            },
+            move_lists: MoveListSet {
+                quiet: Vec::new(),
+                captures: Vec::new(),
+            },
+        }
+    }
+
+    pub(super) fn quiet_moves(
+        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(
+        mut self,
+        bitboard: BitBoard,
+        move_list: impl Iterator<Item = Move>,
+    ) -> MoveSet {
+        self.bitboards.captures = bitboard;
+        self.move_lists.captures = move_list.collect();
+
+        self
+    }
+
+    /// Return a BitBoard representing all possible moves.
+    pub(super) fn bitboard(&self) -> BitBoard {
+        self.bitboards.captures | self.bitboards.quiet
+    }
+
+    pub(super) fn moves(&self) -> impl Iterator<Item = &Move> {
+        self.move_lists
+            .captures
+            .iter()
+            .chain(self.move_lists.quiet.iter())
+    }
+}

position/src/move_generator/pawn.rs

@@ -0,0 +1,240 @@
+// Eryn Wells <eryn@erynwells.me>
+
+use super::{move_generator_declaration, MoveGeneratorInternal, MoveSet};
+use crate::{Move, MoveBuilder, Position};
+use chessfriend_bitboard::BitBoard;
+use chessfriend_core::{Color, Piece, PlacedPiece, Shape, Square};
+
+enum MoveList {
+    Quiet = 0,
+    Promotions = 1,
+    Captures = 2,
+}
+
+#[derive(Debug)]
+struct MoveIterator(usize, usize);
+
+struct MoveGenerationParameters {
+    starting_rank: BitBoard,
+    promotion_rank: BitBoard,
+    push_shift: fn(&BitBoard) -> BitBoard,
+    left_capture_shift: fn(&BitBoard) -> BitBoard,
+    right_capture_shift: fn(&BitBoard) -> BitBoard,
+}
+
+move_generator_declaration!(PawnMoveGenerator);
+
+impl MoveGeneratorInternal for PawnMoveGenerator {
+    fn piece(color: Color) -> Piece {
+        Piece::pawn(color)
+    }
+
+    fn move_set_for_piece(position: &Position, placed_piece: PlacedPiece) -> MoveSet {
+        let from_square = placed_piece.square();
+        let parameters = Self::move_generation_parameters(placed_piece.color());
+
+        let opposing_pieces = position.opposing_pieces();
+
+        let captures_bitboard = Self::attacks(position, placed_piece, &parameters);
+        let quiet_moves_bitboard = Self::pushes(position, placed_piece, &parameters);
+
+        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)
+            .capture_moves(captures_bitboard, capture_moves)
+    }
+}
+
+impl PawnMoveGenerator {
+    fn move_generation_parameters(color: Color) -> MoveGenerationParameters {
+        match color {
+            Color::White => MoveGenerationParameters {
+                starting_rank: BitBoard::rank(1),
+                promotion_rank: BitBoard::rank(7),
+                push_shift: BitBoard::shift_north_one,
+                left_capture_shift: BitBoard::shift_north_west_one,
+                right_capture_shift: BitBoard::shift_north_east_one,
+            },
+            Color::Black => MoveGenerationParameters {
+                starting_rank: BitBoard::rank(6),
+                promotion_rank: BitBoard::rank(0),
+                push_shift: BitBoard::shift_south_one,
+                left_capture_shift: BitBoard::shift_south_east_one,
+                right_capture_shift: BitBoard::shift_south_west_one,
+            },
+        }
+    }
+
+    fn pushes(
+        position: &Position,
+        piece: PlacedPiece,
+        parameters: &MoveGenerationParameters,
+    ) -> BitBoard {
+        let empty_squares = position.empty_squares();
+        let from_square: BitBoard = piece.square().into();
+
+        (parameters.push_shift)(&from_square) & empty_squares
+    }
+
+    fn attacks(
+        position: &Position,
+        piece: PlacedPiece,
+        parameters: &MoveGenerationParameters,
+    ) -> BitBoard {
+        let color = piece.color();
+
+        let opponent_pieces = position.bitboard_for_color(color.other());
+        let en_passant_square = position
+            .en_passant_square()
+            .map(|square| <Square as Into<BitBoard>>::into(square))
+            .unwrap_or(BitBoard::empty());
+
+        let from_square: BitBoard = piece.square().into();
+
+        ((parameters.left_capture_shift)(&from_square)
+            | (parameters.right_capture_shift)(&from_square))
+            & (opponent_pieces | en_passant_square)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{position, position::DiagramFormatter};
+    use chessfriend_core::{piece, Square};
+    use std::collections::HashSet;
+
+    #[test]
+    fn one_2square_push() {
+        let pos = position![White Pawn on E2];
+
+        let generator = PawnMoveGenerator::new(&pos, Color::White);
+
+        let expected_moves = HashSet::from_iter([
+            MoveBuilder::new(piece!(White Pawn), Square::E2, Square::E3).build(),
+            MoveBuilder::new(piece!(White Pawn), Square::E2, Square::E4).build(),
+        ]);
+
+        let generated_moves: HashSet<Move> = generator.iter().cloned().collect();
+
+        assert_eq!(generated_moves, expected_moves);
+    }
+
+    #[test]
+    fn one_1square_push() {
+        let mut pos = position![White Pawn on E3];
+
+        let generator = PawnMoveGenerator::new(&pos, Color::White);
+
+        let expected_moves = HashSet::from_iter([MoveBuilder::new(
+            Piece::pawn(Color::White),
+            Square::E3,
+            Square::E4,
+        )
+        .build()]);
+
+        let generated_moves: HashSet<Move> = generator.iter().cloned().collect();
+
+        assert_eq!(generated_moves, expected_moves);
+    }
+
+    #[test]
+    fn one_obstructed_2square_push() {
+        let pos = position![
+            White Pawn on E2,
+            White Knight on E4,
+        ];
+
+        println!("{}", DiagramFormatter::new(&pos));
+
+        let generator = PawnMoveGenerator::new(&pos, Color::White);
+
+        let expected_moves = HashSet::from_iter([MoveBuilder::new(
+            Piece::pawn(Color::White),
+            Square::E2,
+            Square::E3,
+        )
+        .build()]);
+
+        let generated_moves: HashSet<Move> = generator.iter().cloned().collect();
+
+        assert_eq!(generated_moves, expected_moves);
+    }
+
+    #[test]
+    fn one_obstructed_1square_push() {
+        let mut pos = position![
+            White Pawn on E2,
+            White Knight on E3,
+        ];
+        println!("{}", DiagramFormatter::new(&pos));
+
+        let generator = PawnMoveGenerator::new(&pos, Color::White);
+
+        let generated_moves: HashSet<Move> = generator.iter().cloned().collect();
+
+        assert_eq!(generated_moves, HashSet::new());
+    }
+
+    #[test]
+    fn one_attack() {
+        let pos = position![
+            White Pawn on E4,
+            White Bishop on E5,
+            Black Knight on D5,
+        ];
+        println!("{}", DiagramFormatter::new(&pos));
+
+        let generator = PawnMoveGenerator::new(&pos, Color::White);
+
+        let expected_moves =
+            HashSet::from_iter(
+                [MoveBuilder::new(piece!(White Pawn), Square::E4, Square::D5)
+                    .capturing(piece!(Black Knight on D5))
+                    .build()],
+            );
+
+        let generated_moves: HashSet<Move> = generator.iter().cloned().collect();
+
+        assert_eq!(generated_moves, expected_moves);
+    }
+
+    #[test]
+    fn one_double_attack() {
+        let pos = position![
+            White Pawn on E4,
+            White Bishop on E5,
+            Black Knight on D5,
+            Black Queen on F5,
+        ];
+        println!("{}", DiagramFormatter::new(&pos));
+
+        let generator = PawnMoveGenerator::new(&pos, Color::White);
+
+        let expected_moves = HashSet::from_iter([
+            MoveBuilder::new(piece!(White Pawn), Square::E4, Square::D5)
+                .capturing(piece!(Black Knight on D5))
+                .build(),
+            MoveBuilder::new(piece!(White Pawn), Square::E4, Square::F5)
+                .capturing(piece!(Black Queen on F5))
+                .build(),
+        ]);
+
+        let generated_moves: HashSet<Move> = generator.iter().cloned().collect();
+
+        assert_eq!(
+            generated_moves, expected_moves,
+            "generated: {:#?}\nexpected: {:#?}",
+            generated_moves, expected_moves
+        );
+    }
+}

position/src/move_generator/queen.rs

@@ -0,0 +1,153 @@
+// Eryn Wells <eryn@erynwells.me>
+
+use super::{move_generator_declaration, MoveGeneratorInternal, MoveSet};
+use crate::{MoveBuilder, Position};
+use chessfriend_bitboard::BitBoard;
+use chessfriend_core::{Color, Direction, Piece, PlacedPiece};
+
+move_generator_declaration!(ClassicalMoveGenerator);
+
+impl MoveGeneratorInternal for ClassicalMoveGenerator {
+    fn piece(color: Color) -> Piece {
+        Piece::queen(color)
+    }
+
+    fn move_set_for_piece(position: &Position, placed_piece: PlacedPiece) -> MoveSet {
+        let piece = placed_piece.piece();
+        let color = piece.color();
+        let square = placed_piece.square();
+
+        let blockers = position.occupied_squares();
+        let empty_squares = !blockers;
+        let friendly_pieces = position.bitboard_for_color(color);
+        let opposing_pieces = position.bitboard_for_color(color.other());
+
+        let mut all_moves = BitBoard::empty();
+
+        macro_rules! update_moves_with_ray {
+            ($direction:ident, $occupied_squares:tt) => {
+                let ray = BitBoard::ray(square, Direction::$direction);
+                if let Some(first_occupied_square) =
+                    BitBoard::$occupied_squares(&(ray & blockers)).next()
+                {
+                    let remainder = BitBoard::ray(first_occupied_square, Direction::$direction);
+                    let attack_ray = ray & !remainder;
+                    all_moves |= attack_ray;
+                } else {
+                    all_moves |= ray;
+                }
+            };
+        }
+
+        update_moves_with_ray!(NorthWest, occupied_squares_trailing);
+        update_moves_with_ray!(North, occupied_squares_trailing);
+        update_moves_with_ray!(NorthEast, occupied_squares_trailing);
+        update_moves_with_ray!(East, occupied_squares_trailing);
+        update_moves_with_ray!(SouthEast, occupied_squares);
+        update_moves_with_ray!(South, occupied_squares);
+        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 capture_moves_bb = 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)
+            .capture_moves(capture_moves_bb, capture_moves)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{position, position::DiagramFormatter};
+    use chessfriend_bitboard::{bitboard, BitBoard};
+    use chessfriend_core::Color;
+
+    #[test]
+    fn classical_single_queen_bitboard() {
+        let pos = position![White Queen on B2];
+
+        let generator = ClassicalMoveGenerator::new(&pos, Color::White);
+        let bitboard = generator.bitboard();
+        let expected = bitboard![
+            A2, C2, D2, E2, F2, G2, H2, // Rank
+            B1, B3, B4, B5, B6, B7, B8, // File
+            A1, C3, D4, E5, F6, G7, H8, // Diagonal
+            C1, A3 // Anti-diagonal
+        ];
+
+        assert_eq!(
+            bitboard, expected,
+            "actual:\n{}\nexpected:\n{}",
+            bitboard, expected
+        );
+    }
+
+    /// Test that a rook can move up to, but not onto, a friendly piece.
+    #[test]
+    fn classical_single_queen_with_same_color_blocker_bitboard() {
+        let pos = position![
+            White Queen on A1,
+            White Knight on E1,
+        ];
+
+        println!("{}", DiagramFormatter::new(&pos));
+
+        let generator = ClassicalMoveGenerator::new(&pos, Color::White);
+        let bitboard = generator.bitboard();
+        let expected = BitBoard::new(
+            0b10000001_01000001_00100001_00010001_00001001_00000101_00000011_00001110,
+        );
+
+        assert_eq!(
+            bitboard, expected,
+            "actual:\n{}\nexpected:\n{}",
+            bitboard, expected
+        );
+    }
+
+    /// Test that a rook can move up to, and then capture, an enemy piece.
+    #[test]
+    fn classical_single_queen_with_opposing_color_blocker_bitboard() {
+        let pos = position![
+            White Queen on B2,
+            Black Knight on E5,
+        ];
+        println!("{}", DiagramFormatter::new(&pos));
+
+        let generator = ClassicalMoveGenerator::new(&pos, Color::White);
+
+        assert_eq!(
+            generator.bitboard(),
+            bitboard![
+                A2, C2, D2, E2, F2, G2, H2, // Rank
+                B1, B3, B4, B5, B6, B7, B8, // File
+                A1, C3, D4, E5, // Diagonal
+                C1, A3 // Anti-diagonal
+            ]
+        );
+    }
+
+    #[test]
+    fn classical_single_queen_in_center() {
+        let pos = position![White Queen on D3];
+        println!("{}", DiagramFormatter::new(&pos));
+
+        let generator = ClassicalMoveGenerator::new(&pos, Color::White);
+
+        assert_eq!(
+            generator.bitboard(),
+            bitboard![
+                A3, B3, C3, E3, F3, G3, H3, // Rank
+                D1, D2, D4, D5, D6, D7, D8, // File
+                B1, C2, E4, F5, G6, H7, // Diagonal
+                F1, E2, C4, B5, A6, // Anti-diagonal
+            ]
+        );
+    }
+}

position/src/move_generator/rook.rs

@@ -0,0 +1,127 @@
+// Eryn Wells <eryn@erynwells.me>
+
+use super::{move_generator_declaration, MoveGeneratorInternal, MoveSet};
+use crate::{MoveBuilder, Position};
+use chessfriend_bitboard::BitBoard;
+use chessfriend_core::{Color, Direction, Piece, PlacedPiece};
+
+move_generator_declaration!(ClassicalMoveGenerator);
+
+impl MoveGeneratorInternal for ClassicalMoveGenerator {
+    fn piece(color: Color) -> Piece {
+        Piece::rook(color)
+    }
+
+    fn move_set_for_piece(position: &Position, placed_piece: PlacedPiece) -> MoveSet {
+        let piece = placed_piece.piece();
+        let color = piece.color();
+        let square = placed_piece.square();
+
+        let blockers = position.occupied_squares();
+        let empty_squares = !blockers;
+        let friendly_pieces = position.bitboard_for_color(color);
+        let opposing_pieces = position.bitboard_for_color(color.other());
+
+        let mut all_moves = BitBoard::empty();
+
+        macro_rules! update_moves_with_ray {
+            ($direction:ident, $occupied_squares:tt) => {
+                let ray = BitBoard::ray(square, Direction::$direction);
+                if let Some(first_occupied_square) =
+                    BitBoard::$occupied_squares(&(ray & blockers)).next()
+                {
+                    let remainder = BitBoard::ray(first_occupied_square, Direction::$direction);
+                    let attack_ray = ray & !remainder;
+                    all_moves |= attack_ray;
+                } else {
+                    all_moves |= ray;
+                }
+            };
+        }
+
+        update_moves_with_ray!(North, occupied_squares_trailing);
+        update_moves_with_ray!(East, occupied_squares_trailing);
+        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 capture_moves_bb = 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)
+            .capture_moves(capture_moves_bb, capture_moves)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{position, position::DiagramFormatter};
+    use chessfriend_bitboard::{bitboard, BitBoard};
+    use chessfriend_core::Color;
+
+    #[test]
+    fn classical_single_rook_bitboard() {
+        let pos = position![White Rook on A2];
+        println!("{}", DiagramFormatter::new(&pos));
+
+        let generator = ClassicalMoveGenerator::new(&pos, Color::White);
+
+        assert_eq!(
+            generator.bitboard(),
+            bitboard![A1, A3, A4, A5, A6, A7, A8, B2, C2, D2, E2, F2, G2, H2]
+        );
+    }
+
+    /// Test that a rook can move up to, but not onto, a friendly piece.
+    #[test]
+    fn classical_single_rook_with_same_color_blocker_bitboard() {
+        let mut pos = position![
+            White Rook on A1,
+            White Knight on E1,
+        ];
+
+        println!("{}", DiagramFormatter::new(&pos));
+
+        let generator = ClassicalMoveGenerator::new(&pos, Color::White);
+
+        assert_eq!(
+            generator.bitboard(),
+            BitBoard::new(
+                0b00000001_00000001_00000001_00000001_00000001_00000001_00000001_00001110
+            )
+        );
+    }
+
+    /// Test that a rook can move up to, and then capture, an enemy piece.
+    #[test]
+    fn classical_single_rook_with_opposing_color_blocker_bitboard() {
+        let pos = position![
+            White Rook on A1,
+            Black Knight on E1,
+        ];
+
+        let generator = ClassicalMoveGenerator::new(&pos, Color::White);
+
+        assert_eq!(
+            generator.bitboard(),
+            bitboard![A2, A3, A4, A5, A6, A7, A8, B1, C1, D1, E1]
+        );
+    }
+
+    #[test]
+    fn classical_single_rook_in_center() {
+        let pos = position![White Rook on D4];
+
+        let generator = ClassicalMoveGenerator::new(&pos, Color::White);
+
+        assert_eq!(
+            generator.bitboard(),
+            bitboard![A4, B4, C4, E4, F4, G4, H4, D1, D2, D3, D5, D6, D7, D8]
+        );
+    }
+}