chessfriend/board/src/castle.rs

// Eryn Wells <eryn@erynwells.me>

mod parameters;
mod rights;

pub use parameters::Parameters;
pub use rights::Rights;

use crate::Board;
use chessfriend_core::{Color, Piece, Square, Wing};
use thiserror::Error;

#[derive(Clone, Copy, Debug, Error, Eq, PartialEq)]
pub enum CastleEvaluationError {
    #[error("{color} does not have the right to castle {wing}")]
    NoRights { color: Color, wing: Wing },
    #[error("no king")]
    NoKing,
    #[error("no rook")]
    NoRook,
    #[error("castling path is not clear")]
    ObstructingPieces,
    #[error("opposing pieces check castling path")]
    CheckingPieces,
}

impl Board {
    /// Evaluates whether the active color can castle toward the given wing of the board in the
    /// current position.
    ///
    /// ## Errors
    ///
    /// Returns an error indicating why the active color cannot castle.
    pub fn active_color_can_castle(&self, wing: Wing) -> Result<(), CastleEvaluationError> {
        // TODO: Cache this result. It's expensive!
        // TODO: Does this actually need to rely on internal state, i.e. active_color?

        let active_color = self.active_color;

        if !self.castling_rights.color_has_right(active_color, wing) {
            return Err(CastleEvaluationError::NoRights {
                color: active_color,
                wing,
            });
        }

        let parameters = self.castling_parameters(wing);

        if self.castling_king(parameters.origin.king).is_none() {
            return Err(CastleEvaluationError::NoKing);
        }

        if self.castling_rook(parameters.origin.rook).is_none() {
            return Err(CastleEvaluationError::NoRook);
        }

        // All squares must be clear.
        let has_obstructing_pieces = (self.occupancy() & parameters.clear).is_populated();
        if has_obstructing_pieces {
            return Err(CastleEvaluationError::ObstructingPieces);
        }

        // King cannot pass through check.
        let opposing_sight = self.opposing_sight(active_color);
        let opposing_pieces_can_see_castling_path =
            (parameters.check & opposing_sight).is_populated();
        if opposing_pieces_can_see_castling_path {
            return Err(CastleEvaluationError::CheckingPieces);
        }

        Ok(())
    }

    pub(crate) fn castling_king(&self, square: Square) -> Option<Piece> {
        let active_color = self.active_color;
        self.get_piece(square)
            .filter(|piece| piece.color == active_color && piece.is_king())
    }

    pub(crate) fn castling_rook(&self, square: Square) -> Option<Piece> {
        let active_color = self.active_color;
        self.get_piece(square)
            .filter(|piece| piece.color == active_color && piece.is_rook())
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::test_board;
    use chessfriend_core::{piece, Color, Wing};

    #[test]
    fn king_on_starting_square_can_castle() {
        let pos = test_board!(
            White King on E1,
            White Rook on A1,
            White Rook on H1
        );

        let rights = pos.castling_rights;
        assert!(rights.color_has_right(Color::White, Wing::KingSide));
        assert!(rights.color_has_right(Color::White, Wing::QueenSide));
    }

    #[test]
    fn king_for_castle() {
        let pos = test_board![
            White King on E1,
            White Rook on H1,
            White Rook on A1,
        ];

        let kingside_parameters = pos.castling_parameters(Wing::KingSide);
        assert_eq!(
            pos.castling_king(kingside_parameters.origin.king),
            Some(piece!(White King))
        );

        let queenside_parameters = pos.castling_parameters(Wing::QueenSide);
        assert_eq!(
            pos.castling_king(queenside_parameters.origin.king),
            Some(piece!(White King))
        );
    }

    #[test]
    fn rook_for_castle() {
        let pos = test_board![
            White King on E1,
            White Rook on H1,
        ];

        let kingside_parameters = pos.castling_parameters(Wing::KingSide);
        assert_eq!(
            pos.castling_rook(kingside_parameters.origin.rook),
            Some(piece!(White Rook))
        );

        let pos = test_board![
            White King on E1,
            White Rook on A1,
        ];

        let queenside_parameters = pos.castling_parameters(Wing::QueenSide);
        assert_eq!(
            pos.castling_rook(queenside_parameters.origin.rook),
            Some(piece!(White Rook))
        );
    }

    #[test]
    fn white_can_castle() {
        let pos = test_board![
            White King on E1,
            White Rook on H1,
            White Rook on A1,
        ];

        assert_eq!(pos.active_color_can_castle(Wing::KingSide), Ok(()));
        assert_eq!(pos.active_color_can_castle(Wing::QueenSide), Ok(()));
    }

    #[test]
    fn white_cannot_castle_missing_king() {
        let pos = test_board![
            White King on E2,
            White Rook on H1,
            White Rook on A1,
        ];

        assert_eq!(
            pos.active_color_can_castle(Wing::KingSide),
            Err(CastleEvaluationError::NoKing)
        );
        assert_eq!(
            pos.active_color_can_castle(Wing::QueenSide),
            Err(CastleEvaluationError::NoKing)
        );
    }

    #[test]
    fn white_cannot_castle_missing_rook() {
        let pos = test_board![
            White King on E1,
            White Rook on A1,
        ];

        assert_eq!(
            pos.active_color_can_castle(Wing::KingSide),
            Err(CastleEvaluationError::NoRook)
        );

        let pos = test_board![
            White King on E1,
            White Rook on H1,
        ];

        assert_eq!(
            pos.active_color_can_castle(Wing::QueenSide),
            Err(CastleEvaluationError::NoRook)
        );
    }

    #[test]
    fn white_cannot_castle_obstructing_piece() {
        let pos = test_board![
            White King on E1,
            White Bishop on F1,
            White Rook on H1,
            White Rook on A1,
        ];

        assert_eq!(
            pos.active_color_can_castle(Wing::KingSide),
            Err(CastleEvaluationError::ObstructingPieces)
        );
        assert_eq!(pos.active_color_can_castle(Wing::QueenSide), Ok(()));
    }

    #[test]
    fn white_cannot_castle_checking_pieces() {
        let pos = test_board![
            White King on E1,
            White Rook on H1,
            White Rook on A1,
            Black Queen on C6,
        ];

        assert_eq!(pos.active_color_can_castle(Wing::KingSide), Ok(()));
        assert_eq!(
            pos.active_color_can_castle(Wing::QueenSide),
            Err(CastleEvaluationError::CheckingPieces)
        );
    }
}