path: root/src/board/move_generation.rs

use smallvec::SmallVec;
use crate::{moves::{Move, MoveKind}, board::{color::Color, piece::Piece, CastlingSide}, bitboard::BitboardFns, square::Square};

use super::Board;

pub type MoveList = SmallVec<[Move; 128]>;

impl Board {
    pub fn generate_pseudolegal_moves(&self) -> MoveList {
        let mut result = MoveList::new();
        result.append(&mut self.generate_moves_core(true));
        result.append(&mut self.generate_moves_core(false));
        result
    }

    pub fn generate_moves_core(&self, tactical_only: bool) -> MoveList {
        let color = self.color();
        let player_pieces = self.pieces_by_color(color);
        let mut moves = MoveList::new();
        let empty = self.empty();

        let targets = if tactical_only {
            self.color_occupancy(color.flip()) ^ match color {
                // Exclude opponent king because we can't capture it
                Color::White => self.piece_sets[Piece::KingBlack as usize],
                Color::Black => self.piece_sets[Piece::King as usize],
            }
        } else {
            empty
        };

        let kind = if tactical_only {
            MoveKind::Capture
        } else {
            MoveKind::Quiet
        };

        for (piece_id, piece) in player_pieces.iter().enumerate() {
            for source in piece.serialize() {
                let piece_type = Piece::from(piece_id);
                let move_targets = match piece_type {
                    Piece::Bishop => self.attacks.bishop(self.occupancy, source),
                    Piece::Rook => self.attacks.rook(self.occupancy, source),
                    Piece::Queen => self.attacks.queen(self.occupancy, source),
                    Piece::Knight => self.attacks.knight[source as usize],
                    Piece::King => self.attacks.king[source as usize],
                    Piece::Pawn => if tactical_only {
                        self.attacks.pawn[color as usize][source as usize]
                    } else {
                        self.attacks.pawn_pushes[color as usize][source as usize]
                    },
                    _ => panic!("Incorrect piece type"),
                };

                // Generalized attack/move pattern for all pieces
                for target in (move_targets & targets).serialize() {
                    moves.push(Move { source, target, kind });
                }

                // Promotions
                if piece_type == Piece::Pawn && tactical_only {
                    // All promotions are tactical, but target square can be empty
                    let iter_captures = (move_targets & targets).serialize();
                    let iter_pushes = (self.attacks.pawn_pushes[color as usize][source as usize] & empty).serialize();

                    for target in iter_pushes.chain(iter_captures) {
                        if target.rank() == 7 {
                            for promo_type in [Piece::Bishop, Piece::Knight, Piece::Rook, Piece::Queen] {
                                moves.push(Move { source, target, kind: MoveKind::Promotion(promo_type)})
                            }
                        } else if target.rank() == 0 {
                            for promo_type in [Piece::BishopBlack, Piece::KnightBlack, Piece::RookBlack, Piece::QueenBlack] {
                                moves.push(Move { source, target, kind: MoveKind::Promotion(promo_type)})
                            }
                        }
                    }
                }

                // En Passant
                if piece_type == Piece::Pawn && tactical_only {
                    for target in (move_targets & self.ep_bitboard()).serialize() {
                        moves.push(Move { source, target, kind: MoveKind::EnPassant });
                    }
                }
            }
        }

        if !tactical_only {
            // Double Pushes
            // Make sure no blocking piece is standing in front of the pawns
            // that are potential double-push sources
            let able_to_double_push_mask = match color {
                Color::White => empty >> 8,
                Color::Black => empty << 8,
            };
            for source in (player_pieces[Piece::Pawn as usize] & able_to_double_push_mask).serialize() {
                for target in (self.attacks.pawn_double_pushes[color as usize][source as usize] & empty).serialize() {
                    moves.push(Move { source, target, kind: MoveKind::DoublePush });
                };
            }

            // Castling
            let king_home_position = match color {
                Color::White => Square::E1,
                Color::Black => Square::E8,
            };
            if player_pieces[Piece::King as usize].bitscan() == king_home_position {
                for rook_square in player_pieces[Piece::Rook as usize]
                    .serialize()
                    .filter(|rook_square| rook_square.rank() == king_home_position.rank())
                {
                    match rook_square.file() {
                        0 => {
                            let all_empty = [
                                king_home_position.west_one(),
                                king_home_position.west_one().west_one(),
                                king_home_position.west_one().west_one().west_one(),

                            ].iter().all(|square| empty & square.to_bitboard() > 0);

                            let any_checks = [
                                king_home_position,
                                king_home_position.west_one(),
                                king_home_position.west_one().west_one(),
                            ].iter().any(|square| self.is_square_attacked(*square, color.flip()));

                            if all_empty && !any_checks && self.castling_rights[color as usize][CastlingSide::Queen as usize] {
                                moves.push(Move {
                                    source: king_home_position,
                                    target: king_home_position.west_one().west_one(),
                                    kind: MoveKind::Castle,
                                })
                            }
                        },
                        7 => {
                            let all_empty = [
                                king_home_position.east_one(),
                                king_home_position.east_one().east_one(),

                            ].iter().all(|square| empty & square.to_bitboard() > 0);

                            let any_checks = [
                                king_home_position,
                                king_home_position.east_one(),
                                king_home_position.east_one().east_one(),
                            ].iter().any(|square| self.is_square_attacked(*square, color.flip()));

                            if all_empty && !any_checks && self.castling_rights[color as usize][CastlingSide::King as usize] {
                                moves.push(Move {
                                    source: king_home_position,
                                    target: king_home_position.east_one().east_one(),
                                    kind: MoveKind::Castle,
                                })
                            }
                        },
                        _ => {},
                    }
                }
            }
        }

        moves
    }
}

#[cfg(test)]
mod tests {
    use crate::board::{Board, io::IO};

    use super::*;

    #[test]
    fn generate_pseudolegal_moves_starting_position() {
        let board = Board::new();
        let moves = board.generate_pseudolegal_moves();
        let black_moves = board.generate_pseudolegal_moves();

        assert_eq!(moves.len(), 20);
        assert_eq!(black_moves.len(), 20);

        for mov in moves {
            mov.print();
        }
    }


    #[test]
    fn moved_king_castle() {
        let fen = String::from("4k2r/ppp1n3/8/4R1Pp/5P2/q1P5/P1P1BP2/1K1R4 b - - 2 22");
        let mut board = Board::from_FEN(fen);

        // Shuffle kings around, returning to the same position
        board.make_move(Move { source: Square::E8, target: Square::F8, kind: MoveKind::Quiet });
        board.make_move(Move { source: Square::B1, target: Square::A1, kind: MoveKind::Quiet });
        board.make_move(Move { source: Square::F8, target: Square::E8, kind: MoveKind::Quiet });
        board.make_move(Move { source: Square::A1, target: Square::B1, kind: MoveKind::Quiet });
        board.print();

        let moves = board.generate_pseudolegal_moves();

        let castle = moves.iter().find(|m| **m == Move { source: Square::E8, target: Square::G8, kind: MoveKind::Castle });
        println!("{:?}", board.castling_rights);
        assert!(castle.is_none(), "Castle should not be allowed after king has moved");
    }

    #[test]
    fn tactical_move_generation() {
        let fen = String::from("4k2r/ppp1n3/8/4R1Pp/5P2/q1P5/P1P1BP2/1K1R4 b - - 2 22");
        let board = Board::from_FEN(fen);

        let all_moves = board.generate_pseudolegal_moves();

        let tactical_only = board.generate_moves_core(true);
        let quiet_only = board.generate_moves_core(false);

        let true_tactical = all_moves.iter().filter(|m| m.is_tactical()).copied().collect::<MoveList>();
        let true_quiet = all_moves.iter().filter(|m| !m.is_tactical()).copied().collect::<MoveList>();

        // Make sure tactical_only and true_tactical are identical sets
        for mov in tactical_only.iter() {
            assert!(true_tactical.iter().any(|m| *m == *mov));
            assert!(mov.is_tactical());
        }
        for mov in true_tactical {
            assert!(tactical_only.iter().any(|m| *m == mov));
        }

        // Make sure quiet_only and true_quiet are identical sets
        for mov in quiet_only.iter() {
            assert!(!mov.is_tactical());
            assert!(true_quiet.iter().any(|m| *m == *mov));
        }
        for mov in true_quiet {
            assert!(quiet_only.iter().any(|m| *m == mov));
        }
    }
}