587 lines
19 KiB
Rust
587 lines
19 KiB
Rust
use crate::board::bitboard::{
|
|
have_common_bit, lsb, square_to_bitboard, NOT_FILE_A, NOT_FILE_H, RANK_1, RANK_2, RANK_4,
|
|
RANK_5, RANK_7, RANK_8,
|
|
};
|
|
use crate::board::board::{Board, Color};
|
|
use crate::board::state::Castle;
|
|
use crate::movegen::attack::{
|
|
fetch_bishop_attacks, fetch_king_attacks, fetch_knight_attacks, fetch_pawn_attacks,
|
|
fetch_queen_attacks, fetch_rook_attacks,
|
|
};
|
|
use crate::movegen::r#move::{Move, MoveType, Promote};
|
|
use u64 as Bitboard;
|
|
|
|
pub fn pawn_pseudo_moves(
|
|
pawns: Bitboard,
|
|
all_occupancies: Bitboard,
|
|
opponent_occupancies: Bitboard,
|
|
en_passant_square: Option<usize>,
|
|
color: Color,
|
|
) -> Vec<Move> {
|
|
let mut moves = vec![];
|
|
match color {
|
|
Color::White => {
|
|
moves.extend(white_pawn_quiet_moves(pawns, all_occupancies));
|
|
moves.extend(white_pawn_capture_moves(
|
|
pawns,
|
|
opponent_occupancies,
|
|
en_passant_square,
|
|
));
|
|
}
|
|
Color::Black => {
|
|
moves.extend(black_pawn_quiet_moves(pawns, all_occupancies));
|
|
moves.extend(black_pawn_capture_moves(
|
|
pawns,
|
|
opponent_occupancies,
|
|
en_passant_square,
|
|
));
|
|
}
|
|
}
|
|
moves
|
|
}
|
|
|
|
fn add_promotion_moves(moves: &mut Vec<Move>, src: usize, dst: usize, capture: bool) {
|
|
let promotion_type = if capture {
|
|
MoveType::PromotionCapture
|
|
} else {
|
|
MoveType::Promotion
|
|
};
|
|
|
|
moves.extend([
|
|
Move::new_with_type(src, dst, promotion_type(Promote::Knight)),
|
|
Move::new_with_type(src, dst, promotion_type(Promote::Bishop)),
|
|
Move::new_with_type(src, dst, promotion_type(Promote::Rook)),
|
|
Move::new_with_type(src, dst, promotion_type(Promote::Queen)),
|
|
]);
|
|
}
|
|
|
|
fn white_pawn_quiet_moves(pawns: Bitboard, occupancies: Bitboard) -> Vec<Move> {
|
|
let mut moves = vec![];
|
|
let empty = !occupancies;
|
|
|
|
let mut single_push = (pawns << 8) & empty;
|
|
while single_push != 0 {
|
|
let dst = lsb(single_push);
|
|
let src = dst - 8;
|
|
|
|
if have_common_bit(square_to_bitboard(src), RANK_7) {
|
|
add_promotion_moves(&mut moves, src, dst, false);
|
|
} else {
|
|
moves.push(Move::new(src, dst));
|
|
}
|
|
single_push &= single_push - 1;
|
|
}
|
|
|
|
let single_push = (pawns << 8) & empty;
|
|
let mut double_push = (single_push << 8) & empty & RANK_4;
|
|
while double_push != 0 {
|
|
let dst = lsb(double_push);
|
|
let src = dst - 16;
|
|
moves.push(Move::new_with_type(src, dst, MoveType::DoublePush));
|
|
double_push &= double_push - 1;
|
|
}
|
|
moves
|
|
}
|
|
|
|
fn black_pawn_quiet_moves(pawns: Bitboard, occupancies: Bitboard) -> Vec<Move> {
|
|
let mut moves = vec![];
|
|
let empty = !occupancies;
|
|
|
|
let mut single_push = (pawns >> 8) & empty;
|
|
while single_push != 0 {
|
|
let dst = lsb(single_push);
|
|
let src = dst + 8;
|
|
|
|
if have_common_bit(square_to_bitboard(src), RANK_2) {
|
|
add_promotion_moves(&mut moves, src, dst, false);
|
|
} else {
|
|
moves.push(Move::new(src, dst));
|
|
}
|
|
single_push &= single_push - 1;
|
|
}
|
|
|
|
let single_push = (pawns >> 8) & empty;
|
|
let mut double_push = (single_push >> 8) & empty & RANK_5;
|
|
while double_push != 0 {
|
|
let dst = lsb(double_push);
|
|
let src = dst + 16;
|
|
moves.push(Move::new_with_type(src, dst, MoveType::DoublePush));
|
|
double_push &= double_push - 1;
|
|
}
|
|
moves
|
|
}
|
|
|
|
fn white_pawn_capture_moves(
|
|
pawns: Bitboard,
|
|
opponent_occupancies: Bitboard,
|
|
en_passant_square: Option<usize>,
|
|
) -> Vec<Move> {
|
|
let mut moves = vec![];
|
|
let mut w_pawns_capture_east = pawns & ((opponent_occupancies >> 9) & NOT_FILE_H);
|
|
let mut w_pawns_capture_west = pawns & ((opponent_occupancies >> 7) & NOT_FILE_A);
|
|
|
|
while w_pawns_capture_east != 0 {
|
|
let src = lsb(w_pawns_capture_east);
|
|
let dst = src + 9;
|
|
|
|
if have_common_bit(square_to_bitboard(dst), RANK_8) {
|
|
add_promotion_moves(&mut moves, src, dst, true);
|
|
} else {
|
|
moves.push(Move::new_with_type(src, dst, MoveType::Capture));
|
|
}
|
|
w_pawns_capture_east &= w_pawns_capture_east - 1;
|
|
}
|
|
while w_pawns_capture_west != 0 {
|
|
let src = lsb(w_pawns_capture_west);
|
|
let dst = src + 7;
|
|
|
|
if have_common_bit(square_to_bitboard(dst), RANK_8) {
|
|
add_promotion_moves(&mut moves, src, dst, true);
|
|
} else {
|
|
moves.push(Move::new_with_type(src, dst, MoveType::Capture));
|
|
}
|
|
w_pawns_capture_west &= w_pawns_capture_west - 1;
|
|
}
|
|
|
|
if let Some(en_passant_sq) = en_passant_square {
|
|
let attacked_src = fetch_pawn_attacks(en_passant_sq, Color::Black);
|
|
let mut result = attacked_src & pawns;
|
|
while result != 0 {
|
|
moves.push(Move::new_with_type(
|
|
lsb(result),
|
|
en_passant_sq,
|
|
MoveType::EnPassant,
|
|
));
|
|
result &= result - 1;
|
|
}
|
|
};
|
|
moves
|
|
}
|
|
|
|
fn black_pawn_capture_moves(
|
|
pawns: Bitboard,
|
|
opponent_occupancies: Bitboard,
|
|
en_passant_square: Option<usize>,
|
|
) -> Vec<Move> {
|
|
let mut moves = vec![];
|
|
let mut b_pawns_capture_east = pawns & ((opponent_occupancies << 7) & NOT_FILE_H);
|
|
let mut b_pawns_capture_west = pawns & ((opponent_occupancies << 9) & NOT_FILE_A);
|
|
|
|
while b_pawns_capture_east != 0 {
|
|
let src = lsb(b_pawns_capture_east);
|
|
let dst = src - 7;
|
|
|
|
if have_common_bit(square_to_bitboard(dst), RANK_1) {
|
|
add_promotion_moves(&mut moves, src, dst, true);
|
|
} else {
|
|
moves.push(Move::new_with_type(src, dst, MoveType::Capture));
|
|
}
|
|
b_pawns_capture_east &= b_pawns_capture_east - 1;
|
|
}
|
|
|
|
while b_pawns_capture_west != 0 {
|
|
let src = lsb(b_pawns_capture_west);
|
|
let dst = src - 9;
|
|
if have_common_bit(square_to_bitboard(dst), RANK_1) {
|
|
add_promotion_moves(&mut moves, src, dst, true);
|
|
} else {
|
|
moves.push(Move::new_with_type(src, dst, MoveType::Capture));
|
|
}
|
|
b_pawns_capture_west &= b_pawns_capture_west - 1;
|
|
}
|
|
|
|
if let Some(en_passant_square) = en_passant_square {
|
|
let attacked_src = fetch_pawn_attacks(en_passant_square, Color::White);
|
|
let mut result = attacked_src & pawns;
|
|
while result != 0 {
|
|
moves.push(Move::new_with_type(
|
|
lsb(result),
|
|
en_passant_square,
|
|
MoveType::EnPassant,
|
|
));
|
|
result &= result - 1;
|
|
}
|
|
};
|
|
moves
|
|
}
|
|
|
|
pub fn knight_pseudo_moves(
|
|
mut knights: Bitboard,
|
|
all_occupancies: Bitboard,
|
|
own_occupancies: Bitboard,
|
|
) -> Vec<Move> {
|
|
let mut moves = vec![];
|
|
let opponent_occupancies = all_occupancies ^ own_occupancies;
|
|
|
|
while knights != 0 {
|
|
let knight_square = lsb(knights);
|
|
let src = knight_square;
|
|
let mut attacks = fetch_knight_attacks(knight_square) & !own_occupancies;
|
|
|
|
while attacks != 0 {
|
|
let attack_sq = lsb(attacks);
|
|
if have_common_bit(square_to_bitboard(attack_sq), opponent_occupancies) {
|
|
moves.push(Move::new_with_type(src, attack_sq, MoveType::Capture));
|
|
} else {
|
|
moves.push(Move::new(src, attack_sq));
|
|
}
|
|
attacks &= attacks - 1;
|
|
}
|
|
knights &= knights - 1;
|
|
}
|
|
moves
|
|
}
|
|
|
|
pub fn bishop_pseudo_moves(
|
|
mut bishops: Bitboard,
|
|
all_occupancies: Bitboard,
|
|
own_occupancies: Bitboard,
|
|
) -> Vec<Move> {
|
|
let mut moves = vec![];
|
|
let opponent_occupancies = all_occupancies ^ own_occupancies;
|
|
|
|
while bishops != 0 {
|
|
let bishop_square = lsb(bishops);
|
|
let src = bishop_square;
|
|
let mut attacks = fetch_bishop_attacks(all_occupancies, bishop_square) & !own_occupancies;
|
|
|
|
while attacks != 0 {
|
|
let attack_sq = lsb(attacks);
|
|
if have_common_bit(square_to_bitboard(attack_sq), opponent_occupancies) {
|
|
moves.push(Move::new_with_type(src, attack_sq, MoveType::Capture));
|
|
} else {
|
|
moves.push(Move::new(src, attack_sq));
|
|
}
|
|
attacks &= attacks - 1;
|
|
}
|
|
bishops &= bishops - 1;
|
|
}
|
|
moves
|
|
}
|
|
|
|
pub fn rook_pseudo_moves(
|
|
mut rooks: Bitboard,
|
|
all_occupancies: Bitboard,
|
|
own_occupancies: Bitboard,
|
|
) -> Vec<Move> {
|
|
let mut moves = vec![];
|
|
let opponent_occupancies = all_occupancies ^ own_occupancies;
|
|
|
|
while rooks != 0 {
|
|
let rook_square = lsb(rooks);
|
|
let src = rook_square;
|
|
let mut attacks = fetch_rook_attacks(all_occupancies, rook_square) & !own_occupancies;
|
|
|
|
while attacks != 0 {
|
|
let attack_sq = lsb(attacks);
|
|
if have_common_bit(square_to_bitboard(attack_sq), opponent_occupancies) {
|
|
moves.push(Move::new_with_type(src, attack_sq, MoveType::Capture));
|
|
} else {
|
|
moves.push(Move::new(src, attack_sq));
|
|
}
|
|
attacks &= attacks - 1;
|
|
}
|
|
rooks &= rooks - 1;
|
|
}
|
|
moves
|
|
}
|
|
|
|
pub fn queen_pseudo_moves(
|
|
mut queens: Bitboard,
|
|
all_occupancies: Bitboard,
|
|
own_occupancies: Bitboard,
|
|
) -> Vec<Move> {
|
|
let mut moves = vec![];
|
|
let opponent_occupancies = all_occupancies ^ own_occupancies;
|
|
|
|
while queens != 0 {
|
|
let queen_square = lsb(queens);
|
|
let src = queen_square;
|
|
let mut attacks = fetch_queen_attacks(all_occupancies, queen_square) & !own_occupancies;
|
|
|
|
while attacks != 0 {
|
|
let attack_sq = lsb(attacks);
|
|
if have_common_bit(square_to_bitboard(attack_sq), opponent_occupancies) {
|
|
moves.push(Move::new_with_type(src, attack_sq, MoveType::Capture));
|
|
} else {
|
|
moves.push(Move::new(src, attack_sq));
|
|
}
|
|
attacks &= attacks - 1;
|
|
}
|
|
queens &= queens - 1;
|
|
}
|
|
moves
|
|
}
|
|
|
|
pub fn king_pseudo_moves(
|
|
king: Bitboard,
|
|
all_occupancies: Bitboard,
|
|
own_occupancies: Bitboard,
|
|
board: &Board,
|
|
color: Color,
|
|
) -> Vec<Move> {
|
|
let mut moves = vec![];
|
|
let king_square = lsb(king);
|
|
let src = king_square;
|
|
let mut attacks = fetch_king_attacks(king_square) & !own_occupancies;
|
|
let opponent_occupancies = all_occupancies ^ own_occupancies;
|
|
|
|
while attacks != 0 {
|
|
let attack_sq = lsb(attacks);
|
|
if have_common_bit(square_to_bitboard(attack_sq), opponent_occupancies) {
|
|
moves.push(Move::new_with_type(src, attack_sq, MoveType::Capture));
|
|
} else {
|
|
moves.push(Move::new(src, attack_sq));
|
|
}
|
|
attacks &= attacks - 1;
|
|
}
|
|
|
|
moves.extend(king_castling_moves(board, color, all_occupancies));
|
|
moves
|
|
}
|
|
|
|
fn king_castling_moves(board: &Board, color: Color, all_occupancies: Bitboard) -> Vec<Move> {
|
|
let mut moves = vec![];
|
|
let (king_src, king_dst_short, king_dst_long, path_short, path_long) = match color {
|
|
Color::White => (4, 6, 2, 0x60_u64, 0xe_u64),
|
|
Color::Black => (60, 62, 58, 0x6000000000000000_u64, 0xe00000000000000_u64),
|
|
};
|
|
|
|
let mut add_move_if_empty_path = |path_mask, king_dst| {
|
|
if !have_common_bit(all_occupancies, path_mask) {
|
|
moves.push(Move::new_with_type(king_src, king_dst, MoveType::Castle));
|
|
}
|
|
};
|
|
|
|
match (
|
|
board.state.castling_ability(color),
|
|
king_and_adj_square_safety(board, color),
|
|
) {
|
|
(Castle::Both, Castle::Both) => {
|
|
add_move_if_empty_path(path_short, king_dst_short);
|
|
add_move_if_empty_path(path_long, king_dst_long);
|
|
}
|
|
|
|
(Castle::Both | Castle::Short, Castle::Short) | (Castle::Short, Castle::Both) => {
|
|
add_move_if_empty_path(path_short, king_dst_short);
|
|
}
|
|
(Castle::Both | Castle::Long, Castle::Long) | (Castle::Long, Castle::Both) => {
|
|
add_move_if_empty_path(path_long, king_dst_long);
|
|
}
|
|
_ => (),
|
|
};
|
|
moves
|
|
}
|
|
|
|
fn king_and_adj_square_safety(board: &Board, color: Color) -> Castle {
|
|
let (king_at, opponent_color) = match color {
|
|
Color::White => (4, Color::Black),
|
|
Color::Black => (60, Color::White),
|
|
};
|
|
|
|
if board.is_attacked(king_at, opponent_color) {
|
|
return Castle::None;
|
|
}
|
|
|
|
let short_attacked = board.is_attacked(king_at + 1, opponent_color);
|
|
let long_attacked = board.is_attacked(king_at - 1, opponent_color);
|
|
match (short_attacked, long_attacked) {
|
|
(true, true) => Castle::None,
|
|
(true, false) => Castle::Long,
|
|
(false, true) => Castle::Short,
|
|
(false, false) => Castle::Both,
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use crate::{board::fen::from_fen, movegen::attack::init_attacks};
|
|
|
|
use super::*;
|
|
use crate::board::board::PieceType;
|
|
|
|
const FEN_PAWN_MOVES: &str = "r1bqk2r/p4pbp/1pnp1np1/P3P1B1/3NNP2/8/1PP3PP/R2QKB1R w - - 0 1";
|
|
|
|
#[test]
|
|
fn test_pawn_pseudo_moves() -> Result<(), String> {
|
|
init_attacks();
|
|
let new_game = from_fen(FEN_PAWN_MOVES)?;
|
|
let expected = vec![
|
|
Move::new(9, 17),
|
|
Move::new_with_type(9, 25, MoveType::DoublePush),
|
|
Move::new(10, 18),
|
|
Move::new_with_type(10, 26, MoveType::DoublePush),
|
|
Move::new(14, 22),
|
|
Move::new_with_type(14, 30, MoveType::DoublePush),
|
|
Move::new(15, 23),
|
|
Move::new_with_type(15, 31, MoveType::DoublePush),
|
|
Move::new(29, 37),
|
|
Move::new(32, 40),
|
|
Move::new_with_type(32, 41, MoveType::Capture),
|
|
Move::new_with_type(36, 43, MoveType::Capture),
|
|
Move::new(36, 44),
|
|
Move::new_with_type(36, 45, MoveType::Capture),
|
|
];
|
|
|
|
let mut actual = new_game.board.pseudo_moves(Color::White, PieceType::Pawn);
|
|
actual.sort();
|
|
assert_eq!(expected, actual);
|
|
|
|
let expected = vec![
|
|
Move::new_with_type(41, 32, MoveType::Capture),
|
|
Move::new(41, 33),
|
|
Move::new(43, 35),
|
|
Move::new_with_type(43, 36, MoveType::Capture),
|
|
Move::new(48, 40),
|
|
Move::new_with_type(55, 39, MoveType::DoublePush),
|
|
Move::new(55, 47),
|
|
];
|
|
let mut actual = new_game.board.pseudo_moves(Color::Black, PieceType::Pawn);
|
|
actual.sort();
|
|
assert_eq!(expected, actual);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
const FEN_KNIGHT_MOVES: &str = "r1bqkbnr/ppp2p1p/2np4/6p1/3PPp2/5N2/PPP3PP/RNBQKB1R w - - 0 1";
|
|
|
|
#[test]
|
|
fn test_knight_pseudo_moves() -> Result<(), String> {
|
|
init_attacks();
|
|
let new_game = from_fen(FEN_KNIGHT_MOVES)?;
|
|
let expected = vec![
|
|
Move::new(1, 11),
|
|
Move::new(1, 16),
|
|
Move::new(1, 18),
|
|
Move::new(21, 6),
|
|
Move::new(21, 11),
|
|
Move::new(21, 31),
|
|
Move::new(21, 36),
|
|
Move::new_with_type(21, 38, MoveType::Capture),
|
|
];
|
|
let mut actual = new_game.board.pseudo_moves(Color::White, PieceType::Knight);
|
|
actual.sort();
|
|
assert_eq!(expected, actual);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
const FEN_BISHOP_MOVES: &str = "rn1qk1nr/pbppbppp/1p6/8/2B1Pp2/3P1N2/PPB3PP/RN1QK2R w - - 0 1";
|
|
|
|
#[test]
|
|
fn test_bishop_pseudo_moves() -> Result<(), String> {
|
|
init_attacks();
|
|
let new_game = from_fen(FEN_BISHOP_MOVES)?;
|
|
let expected = vec![
|
|
Move::new(10, 17),
|
|
Move::new(10, 24),
|
|
Move::new(26, 17),
|
|
Move::new(26, 33),
|
|
Move::new(26, 35),
|
|
Move::new(26, 40),
|
|
Move::new(26, 44),
|
|
Move::new_with_type(26, 53, MoveType::Capture),
|
|
];
|
|
let mut actual = new_game.board.pseudo_moves(Color::White, PieceType::Bishop);
|
|
actual.sort();
|
|
assert_eq!(expected, actual);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
const FEN_ROOK_MOVES: &str = "rnbqkb1r/pp3p1p/4pn2/6p1/2P5/2N5/P1BRR3/3QK1N1 w kq - 0 1";
|
|
|
|
#[test]
|
|
fn test_rook_pseudo_moves() -> Result<(), String> {
|
|
init_attacks();
|
|
let new_game = from_fen(FEN_ROOK_MOVES)?;
|
|
let expected = vec![
|
|
Move::new(11, 19),
|
|
Move::new(11, 27),
|
|
Move::new(11, 35),
|
|
Move::new(11, 43),
|
|
Move::new(11, 51),
|
|
Move::new_with_type(11, 59, MoveType::Capture),
|
|
Move::new(12, 13),
|
|
Move::new(12, 14),
|
|
Move::new(12, 15),
|
|
Move::new(12, 20),
|
|
Move::new(12, 28),
|
|
Move::new(12, 36),
|
|
Move::new_with_type(12, 44, MoveType::Capture),
|
|
];
|
|
let mut actual = new_game.board.pseudo_moves(Color::White, PieceType::Rook);
|
|
actual.sort();
|
|
assert_eq!(expected, actual);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
const FEN_QUEEN_MOVES: &str = "rnbqkb1r/ppp1pp1p/5np1/3p4/2PP4/1QN5/PP2PPPP/R1B1KBNR w - - 0 1";
|
|
|
|
#[test]
|
|
fn test_queen_pseudo_moves() -> Result<(), String> {
|
|
init_attacks();
|
|
let new_game = from_fen(FEN_QUEEN_MOVES)?;
|
|
let expected = vec![
|
|
Move::new(17, 3),
|
|
Move::new(17, 10),
|
|
Move::new(17, 16),
|
|
Move::new(17, 24),
|
|
Move::new(17, 25),
|
|
Move::new(17, 33),
|
|
Move::new(17, 41),
|
|
Move::new_with_type(17, 49, MoveType::Capture),
|
|
];
|
|
let mut actual = new_game.board.pseudo_moves(Color::White, PieceType::Queen);
|
|
actual.sort();
|
|
assert_eq!(expected, actual);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
const FEN_KING_MOVES: [&str; 3] = [
|
|
"R7/6k1/8/8/P6P/6K1/8/4r3 w - - 0 1",
|
|
"rnbqkb1r/ppp1pp1p/5np1/3p4/2PP4/1QN5/PP1BPPPP/R3KBNR w KQkq - 0 1",
|
|
"rnq1k2r/pp2p2p/2pbb1p1/5pB1/3P2n1/2N3P1/PPQ1PPBP/R3K1NR b KQkq - 0 1",
|
|
];
|
|
|
|
#[test]
|
|
fn test_king_pseudo_moves() -> Result<(), String> {
|
|
init_attacks();
|
|
let new_game = from_fen(FEN_KING_MOVES[0])?;
|
|
let expected = vec![
|
|
Move::new(22, 13),
|
|
Move::new(22, 14),
|
|
Move::new(22, 15),
|
|
Move::new(22, 21),
|
|
Move::new(22, 23),
|
|
Move::new(22, 29),
|
|
Move::new(22, 30),
|
|
];
|
|
let mut actual = new_game.board.pseudo_moves(Color::White, PieceType::King);
|
|
actual.sort();
|
|
assert_eq!(expected, actual);
|
|
|
|
let new_game_2 = from_fen(FEN_KING_MOVES[1])?;
|
|
let expected = vec![Move::new_with_type(4, 2, MoveType::Castle), Move::new(4, 3)];
|
|
let mut actual = new_game_2.board.pseudo_moves(Color::White, PieceType::King);
|
|
actual.sort();
|
|
assert_eq!(expected, actual);
|
|
|
|
let new_game_3 = from_fen(FEN_KING_MOVES[2])?;
|
|
let expected = vec![
|
|
Move::new(60, 51),
|
|
Move::new(60, 53),
|
|
Move::new(60, 59),
|
|
Move::new(60, 61),
|
|
Move::new_with_type(60, 62, MoveType::Castle),
|
|
];
|
|
let mut actual = new_game_3.board.pseudo_moves(Color::Black, PieceType::King);
|
|
actual.sort();
|
|
assert_eq!(expected, actual);
|
|
|
|
Ok(())
|
|
}
|
|
}
|