chessfriend/board/src/move_generator/knight.rs

// Eryn Wells <eryn@erynwells.me>

use super::{move_generator_declaration, MoveGeneratorInternal, MoveSet};
use crate::{
    piece::{Color, Piece, PlacedPiece},
    BitBoard, Move, Position,
};

move_generator_declaration!(KnightMoveGenerator);

impl<'pos> MoveGeneratorInternal for KnightMoveGenerator<'pos> {
    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| Move::new(placed_piece.piece(), placed_piece.square(), to_sq));
        let capture_moves = capture_moves_bb.occupied_squares().map(|to_sq| {
            let captured_piece = position.piece_on_square(to_sq).unwrap();
            Move::new(placed_piece.piece(), placed_piece.square(), to_sq).capturing(captured_piece)
        });

        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::Square;
    use std::collections::HashSet;

    #[test]
    fn one_knight() {
        let mut pos = Position::empty();
        pos.place_piece(Piece::knight(Color::White), Square::E4)
            .expect("Failed to place 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 = [
            Move::new(Piece::knight(Color::White), Square::E4, Square::C3),
            Move::new(Piece::knight(Color::White), Square::E4, Square::D2),
            Move::new(Piece::knight(Color::White), Square::E4, Square::F2),
            Move::new(Piece::knight(Color::White), Square::E4, Square::G3),
            Move::new(Piece::knight(Color::White), Square::E4, Square::C5),
            Move::new(Piece::knight(Color::White), Square::E4, Square::D6),
            Move::new(Piece::knight(Color::White), Square::E4, Square::G5),
            Move::new(Piece::knight(Color::White), Square::E4, Square::F6),
        ];

        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
        );
    }
}