chessfriend/moves/src/castle.rs

// Eryn Wells <eryn@erynwells.me>

use chessfriend_bitboard::BitBoard;
use chessfriend_core::{Color, Square};

#[repr(u8)]
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
pub enum Castle {
    KingSide = 0,
    QueenSide = 1,
}

pub struct Parameters {
    /// Origin squares of the king and rook.
    origin_squares: Squares,

    /// Target or destination squares for the king and rook.
    target_squares: Squares,

    /// The set of squares that must be clear of any pieces in order to perform this castle.
    clear_squares: BitBoard,

    /// The set of squares that must not be attacked in order to perform this castle.
    check_squares: BitBoard,
}

impl Parameters {
    pub fn king_origin_square(&self) -> Square {
        self.origin_squares.king
    }

    pub fn rook_origin_square(&self) -> Square {
        self.origin_squares.rook
    }

    pub fn king_target_square(&self) -> Square {
        self.target_squares.king
    }

    pub fn rook_target_square(&self) -> Square {
        self.target_squares.rook
    }

    pub fn clear_squares(&self) -> &BitBoard {
        &self.clear_squares
    }

    pub fn check_squares(&self) -> &BitBoard {
        &self.check_squares
    }
}

#[derive(Debug)]
struct Squares {
    king: Square,
    rook: Square,
}

impl Castle {
    pub const ALL: [Castle; 2] = [Castle::KingSide, Castle::QueenSide];

    /// Parameters for each castling move, organized by color and board-side.
    const PARAMETERS: [[Parameters; 2]; 2] = [
        [
            Parameters {
                origin_squares: Squares {
                    king: Square::E1,
                    rook: Square::H1,
                },
                target_squares: Squares {
                    king: Square::G1,
                    rook: Square::F1,
                },
                clear_squares: BitBoard::new(0b01100000),
                check_squares: BitBoard::new(0b01110000),
            },
            Parameters {
                origin_squares: Squares {
                    king: Square::E1,
                    rook: Square::A1,
                },
                target_squares: Squares {
                    king: Square::C1,
                    rook: Square::D1,
                },
                clear_squares: BitBoard::new(0b00001110),
                check_squares: BitBoard::new(0b00011100),
            },
        ],
        [
            Parameters {
                origin_squares: Squares {
                    king: Square::E8,
                    rook: Square::H8,
                },
                target_squares: Squares {
                    king: Square::G8,
                    rook: Square::F8,
                },
                clear_squares: BitBoard::new(0b01100000 << 8 * 7),
                check_squares: BitBoard::new(0b01110000 << 8 * 7),
            },
            Parameters {
                origin_squares: Squares {
                    king: Square::E8,
                    rook: Square::A8,
                },
                target_squares: Squares {
                    king: Square::C8,
                    rook: Square::D8,
                },
                clear_squares: BitBoard::new(0b00001110 << 8 * 7),
                check_squares: BitBoard::new(0b00011100 << 8 * 7),
            },
        ],
    ];

    pub fn parameters(&self, color: Color) -> &'static Parameters {
        &Castle::PARAMETERS[color as usize][*self as usize]
    }
}