stefiosif/zeal
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Implement redundant mailbox representation

Browse Source
This commit is contained in:
stefiosif
2024-09-19 22:57:03 +03:00
parent 3739e6e169
commit f74f1ef364
11 changed files with 252 additions and 132 deletions
Download Patch File Download Diff File Expand all files Collapse all files

50
src/board/board.rs
View File

@@ -164,30 +164,6 @@ impl Board {
self.state = state;
}
pub fn piece_type_at_color(&self, square: usize, color: Color) -> Option<PieceType> {
let pieces = match color {
Color::White => &self.white_pieces,
Color::Black => &self.black_pieces,
};
pieces
.iter()
.find(|p| have_common_bit(p.bitboard, square_to_bitboard(square)))
.map(|p| p.piece_type)
}
pub fn piece_type_at(&self, square: usize) -> Option<PieceType> {
if let Some(at_white) = self.piece_type_at_color(square, Color::White) {
return Some(at_white);
}
if let Some(at_black) = self.piece_type_at_color(square, Color::Black) {
return Some(at_black);
}
None
}
pub fn update_game_state(
state: &mut State,
mv: &Move,
@@ -212,6 +188,10 @@ impl Board {
p.bitboard &= !square_to_bitboard(src);
p.bitboard |= square_to_bitboard(dst);
});
//TODO:
// pieces[piece_type].bitboard &= !square_to_bitboard(src);
// pieces[piece_type].bitboard |= square_to_bitboard(dst);
}
pub fn remove_own_piece(&mut self, square: usize) {
@@ -234,16 +214,6 @@ impl Board {
});
}
pub fn move_rook_castle(&mut self, king_dst: usize) {
let (rook_src, rook_dst) = match king_dst {
Square::C1 | Square::C8 => (king_dst - 2, king_dst + 1),
Square::G1 | Square::G8 => (king_dst + 1, king_dst - 1),
_ => return,
};
self.move_piece(rook_src, rook_dst);
}
pub fn promote_piece(&mut self, square: usize, promote: &Promote) {
let pieces = self.own_pieces();
match promote {
@@ -254,15 +224,6 @@ impl Board {
};
}
pub fn remove_pawn_enpassant(&mut self, square: usize, color: Color) {
let piece_to_remove = match color {
Color::White => square - 8,
Color::Black => square + 8,
};
self.remove_opponent_piece(piece_to_remove);
}
pub fn is_pawn_move(&mut self, square: usize) -> bool {
let pieces = self.own_pieces();
have_common_bit(square_to_bitboard(square), pieces[PieceType::Pawn].bitboard)
@@ -331,7 +292,6 @@ impl PieceType {
use std::ops::{Index, IndexMut};
use super::bitboard::square_to_bitboard;
use super::square::Square;
impl Index<PieceType> for [Piece] {
type Output = Piece;
@@ -365,7 +325,7 @@ impl Color {
#[cfg(test)]
mod tests {
use crate::{
board::fen::from_fen,
board::{fen::from_fen, square::Square},
movegen::{attack_generator::init_attacks, r#move::MoveType},
};

5
src/board/fen.rs
View File

@@ -25,9 +25,13 @@ pub fn from_fen(fen: &str) -> Result<Game, FenError> {
halfmove_clock,
fullmove_counter,
));
let mailbox = Mailbox::new_from_board(&board);
Ok(Game {
board,
history: History::new(),
mailbox,
})
}
@@ -127,6 +131,7 @@ fn castling_ability(castling: &str) -> Result<[Castle; 2], FenError> {
use std::collections::HashMap;
use super::history::History;
use super::mailbox::Mailbox;
fn en_passant_square(square: &str) -> Result<Option<usize>, FenError> {
let mut sqr = square.chars();

104
src/board/game.rs
View File

@@ -8,6 +8,7 @@ use super::{
bitboard::square_to_bitboard,
board::{Board, Color, PieceType},
history::{History, MoveParameters},
mailbox::Mailbox,
square::Square,
state::Castle,
};
@@ -20,17 +21,19 @@ impl PartialEq for Game {
}
}
#[derive(Debug, Eq)]
#[derive(Debug, Clone, Eq)]
pub struct Game {
pub board: Board,
pub history: History,
pub mailbox: Mailbox,
}
impl Game {
pub const fn new() -> Self {
pub fn new() -> Self {
Self {
board: Board::new(),
history: History::new(),
mailbox: Mailbox::new_from_board(&Board::new()),
}
}
@@ -43,24 +46,34 @@ impl Game {
}
pub fn make_move(&mut self, mv: &Move) {
self.history
.push_move_parameters(MoveParameters::build(&self, mv));
let board = &mut self.board;
let mailbox = &mut self.mailbox;
let color = board.state.current_player();
let pawn_move = board.is_pawn_move(mv.src);
let mut en_passant_square = None;
self.history
.push_move_parameters(MoveParameters::build(board, mv));
match &mv.move_type {
MoveType::Quiet => {
board.move_piece(mv.src, mv.dst);
mailbox.set_piece_at(mv.dst, mailbox.find_piece_at(mv.src));
}
MoveType::Capture => {
board.move_piece(mv.src, mv.dst);
board.remove_opponent_piece(mv.dst);
mailbox.set_piece_at(mv.dst, mailbox.find_piece_at(mv.src));
}
MoveType::EnPassant => {
board.move_piece(mv.src, mv.dst);
board.remove_pawn_enpassant(mv.dst, color);
let piece_to_remove = match color {
Color::White => mv.dst - 8,
Color::Black => mv.dst + 8,
};
board.remove_opponent_piece(piece_to_remove);
mailbox.set_piece_at(mv.dst, mailbox.find_piece_at(mv.src));
mailbox.set_piece_at(piece_to_remove, None);
}
MoveType::DoublePush => {
board.move_piece(mv.src, mv.dst);
@@ -68,29 +81,45 @@ impl Game {
Color::White => Some(mv.src + 8),
Color::Black => Some(mv.src.saturating_sub(8)),
};
mailbox.set_piece_at(mv.dst, mailbox.find_piece_at(mv.src));
}
MoveType::Promotion(promote) => {
board.remove_own_piece(mv.src);
board.promote_piece(mv.dst, promote);
mailbox.set_piece_at(mv.dst, Some(promote.into_piece_type()));
}
MoveType::PromotionCapture(promote) => {
board.remove_own_piece(mv.src);
board.remove_opponent_piece(mv.dst);
board.promote_piece(mv.dst, promote);
mailbox.set_piece_at(mv.dst, Some(promote.into_piece_type()));
}
MoveType::Castle => {
board.move_piece(mv.src, mv.dst);
board.move_rook_castle(mv.dst);
let (rook_src, rook_dst) = match mv.dst {
Square::C1 | Square::C8 => (mv.dst - 2, mv.dst + 1),
Square::G1 | Square::G8 => (mv.dst + 1, mv.dst - 1),
_ => return,
};
board.move_piece(rook_src, rook_dst);
board.state.set_castling_ability(color, Castle::None);
mailbox.set_piece_at(mv.dst, mailbox.find_piece_at(mv.src));
mailbox.set_piece_at(rook_src, None);
mailbox.set_piece_at(rook_dst, Some(PieceType::Rook));
}
}
mailbox.set_piece_at(mv.src, None);
Board::update_game_state(&mut board.state, mv, color, pawn_move, en_passant_square);
}
pub fn unmake_move(&mut self) {
let board = &mut self.board;
let move_parameters = &mut self.history.pop_move_parameters().unwrap_or_default();
let mailbox = &mut self.mailbox;
let move_parameters = &mut self
.history
.pop_move_parameters()
.expect("History stack is empty");
let color_before_move = board.state.change_side();
board.state.revert_full_move(color_before_move);
board.state.en_passant_square = move_parameters.en_passant_square;
@@ -108,27 +137,42 @@ impl Game {
match &mv.move_type {
MoveType::Quiet | MoveType::DoublePush => {
board.move_piece(mv.dst, mv.src);
mailbox.set_piece_at(mv.src, mailbox.find_piece_at(mv.dst));
mailbox.set_piece_at(mv.dst, None);
}
MoveType::Capture | MoveType::Promotion(_) | MoveType::PromotionCapture(_) => {
if let (Some(captured_piece_type), Some(promoted_piece_type)) = (
move_parameters.captured_piece,
move_parameters.promoted_piece,
) {
let (own_pieces, opponent_pieces) = board.all_pieces();
opponent_pieces[captured_piece_type].bitboard |= square_to_bitboard(mv.dst);
own_pieces[promoted_piece_type].bitboard &= !square_to_bitboard(mv.dst);
own_pieces[PieceType::Pawn].bitboard |= square_to_bitboard(mv.src);
} else if let Some(captured_piece_type) = move_parameters.captured_piece {
board.move_piece(mv.dst, mv.src);
let opponent_pieces = board.opponent_pieces();
opponent_pieces[captured_piece_type].bitboard |= square_to_bitboard(mv.dst);
} else if let Some(promoted_piece_type) = move_parameters.promoted_piece {
let own_pieces = board.own_pieces();
own_pieces[promoted_piece_type].bitboard &= !square_to_bitboard(mv.dst);
own_pieces[PieceType::Pawn].bitboard |= square_to_bitboard(mv.src);
}
MoveType::Capture => {
let captured_piece = move_parameters
.captured_piece
.expect("Expected captured piece to unmake Capture");
board.move_piece(mv.dst, mv.src);
let opponent_pieces = board.opponent_pieces();
opponent_pieces[captured_piece].bitboard |= square_to_bitboard(mv.dst);
mailbox.set_piece_at(mv.src, move_parameters.moved_piece);
mailbox.set_piece_at(mv.dst, Some(captured_piece));
}
MoveType::Promotion(_) => {
let promoted_piece = move_parameters
.promoted_piece
.expect("Expected promoted piece to unmake Promotion");
let own_pieces = board.own_pieces();
own_pieces[promoted_piece].bitboard &= !square_to_bitboard(mv.dst);
own_pieces[PieceType::Pawn].bitboard |= square_to_bitboard(mv.src);
mailbox.set_piece_at(mv.src, Some(PieceType::Pawn));
mailbox.set_piece_at(mv.dst, None);
}
MoveType::PromotionCapture(_) => {
let promoted_piece = move_parameters
.promoted_piece
.expect("Expected promoted piece to unmake PromotionCapture");
let captured_piece = move_parameters
.captured_piece
.expect("Expected captured piece to unmake PromotionCapture");
let (own_pieces, opponent_pieces) = board.all_pieces();
opponent_pieces[captured_piece].bitboard |= square_to_bitboard(mv.dst);
own_pieces[promoted_piece].bitboard &= !square_to_bitboard(mv.dst);
own_pieces[PieceType::Pawn].bitboard |= square_to_bitboard(mv.src);
mailbox.set_piece_at(mv.src, Some(PieceType::Pawn));
mailbox.set_piece_at(mv.dst, Some(captured_piece));
}
MoveType::EnPassant => {
board.move_piece(mv.dst, mv.src);
@@ -138,6 +182,8 @@ impl Game {
};
let opponent_pieces = board.opponent_pieces();
opponent_pieces[PieceType::Pawn].bitboard |= square_to_bitboard(enemy_pawn_square);
mailbox.set_piece_at(mv.src, Some(PieceType::Pawn));
mailbox.set_piece_at(enemy_pawn_square, Some(PieceType::Pawn));
}
MoveType::Castle => {
board.move_piece(mv.dst, mv.src);
@@ -149,6 +195,10 @@ impl Game {
let own_pieces = board.own_pieces();
own_pieces[PieceType::Rook].bitboard &= !square_to_bitboard(rook_dst);
own_pieces[PieceType::Rook].bitboard |= square_to_bitboard(rook_src);
mailbox.set_piece_at(mv.src, mailbox.find_piece_at(mv.dst));
mailbox.set_piece_at(mv.dst, None);
mailbox.set_piece_at(rook_src, Some(PieceType::Rook));
mailbox.set_piece_at(rook_dst, None);
}
}
}

67
src/board/history.rs
View File

@@ -1,7 +1,8 @@
use crate::movegen::r#move::{Move, MoveType, Promote};
use crate::movegen::r#move::{Move, MoveType};
use super::{
board::{Board, Color, PieceType},
board::PieceType,
game::Game,
state::{Castle, State},
};
@@ -29,6 +30,7 @@ impl History {
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct MoveParameters {
pub mv: Option<Move>,
pub moved_piece: Option<PieceType>,
pub captured_piece: Option<PieceType>,
pub promoted_piece: Option<PieceType>,
pub castling_ability: Option<[Castle; 2]>,
@@ -40,6 +42,7 @@ impl MoveParameters {
pub const fn new() -> Self {
Self {
mv: None,
moved_piece: None,
captured_piece: None,
promoted_piece: None,
castling_ability: None,
@@ -48,11 +51,13 @@ impl MoveParameters {
}
}
pub fn build(board: &Board, mv: &Move) -> Self {
pub fn build(game: &Game, mv: &Move) -> Self {
let mut move_parameters = Self::new();
move_parameters.add_move(*mv);
move_parameters.add_irreversible_parameters(board.state);
move_parameters.add_capture_and_promotion_piece(board, *mv, board.state.current_player());
move_parameters.add_irreversible_parameters(game.board.state);
move_parameters.add_moved_piece(game, mv);
move_parameters.add_captured_piece(game, mv);
move_parameters.add_promoted_piece(mv);
move_parameters
}
@@ -61,31 +66,27 @@ impl MoveParameters {
self.mv = Some(mv);
}
fn add_captured_piece(&mut self, board: &Board, dst: usize, color: Color) {
self.captured_piece = board.piece_type_at_color(dst, color);
fn add_moved_piece(&mut self, game: &Game, mv: &Move) {
self.moved_piece = game.mailbox.find_piece_at(mv.src);
}
fn add_promoted_piece(&mut self, promote: Promote) {
self.promoted_piece = Some(promote.into_piece_type());
fn add_captured_piece(&mut self, game: &Game, mv: &Move) {
if let MoveType::Capture | MoveType::PromotionCapture(_) = mv.move_type {
self.captured_piece = game.mailbox.find_piece_at(mv.dst)
}
}
pub fn add_irreversible_parameters(&mut self, state: State) {
fn add_promoted_piece(&mut self, mv: &Move) {
if let MoveType::Promotion(promote) | MoveType::PromotionCapture(promote) = mv.move_type {
self.promoted_piece = Some(promote.into_piece_type())
}
}
fn add_irreversible_parameters(&mut self, state: State) {
self.castling_ability = Some(state.castling_ability);
self.en_passant_square = state.en_passant_square;
self.halfmove_clock = Some(state.halfmove_clock);
}
pub fn add_capture_and_promotion_piece(&mut self, board: &Board, mv: Move, color: Color) {
match mv.move_type {
MoveType::Capture => self.add_captured_piece(board, mv.dst, color.opponent()),
MoveType::Promotion(piece) => self.add_promoted_piece(piece),
MoveType::PromotionCapture(piece) => {
self.add_promoted_piece(piece);
self.add_captured_piece(board, mv.dst, color.opponent());
}
_ => (),
}
}
}
impl Default for MoveParameters {
@@ -107,18 +108,18 @@ mod tests {
#[test]
fn test_unmake_quiet_and_double_push() -> Result<(), String> {
let mut game = from_fen(FEN)?;
let board_before_make = game.board.clone();
let game_before_make = game.clone();
let mv = Move::new_with_type(Square::B2, Square::B3, MoveType::Quiet);
game.make_move(&mv);
game.unmake_move();
assert_eq!(board_before_make, game.board);
assert_eq!(game_before_make, game);
let mv = Move::new_with_type(Square::B2, Square::B4, MoveType::DoublePush);
game.make_move(&mv);
game.unmake_move();
assert_eq!(board_before_make, game.board);
assert_eq!(game_before_make, game);
Ok(())
}
@@ -126,18 +127,18 @@ mod tests {
#[test]
fn test_unmake_capture_and_promotion() -> Result<(), String> {
let mut game = from_fen(FEN)?;
let board_before_make = game.board.clone();
let game_before_make = game.clone();
let mv = Move::new_with_type(Square::D3, Square::B5, MoveType::Capture);
game.make_move(&mv);
game.unmake_move();
assert_eq!(board_before_make, game.board);
assert_eq!(game_before_make, game);
let mv = Move::new_with_type(Square::C7, Square::C8, MoveType::Promotion(Promote::Queen));
game.make_move(&mv);
game.unmake_move();
assert_eq!(board_before_make, game.board);
assert_eq!(game_before_make, game);
let mv = Move::new_with_type(
Square::C7,
@@ -147,7 +148,7 @@ mod tests {
game.make_move(&mv);
game.unmake_move();
assert_eq!(board_before_make, game.board);
assert_eq!(game_before_make, game);
Ok(())
}
@@ -155,12 +156,12 @@ mod tests {
#[test]
fn test_unmake_en_passant() -> Result<(), String> {
let mut game = from_fen(FEN_2)?;
let board_before_make = game.board.clone();
let game_before_make = game.clone();
let mv = Move::new_with_type(Square::A4, Square::B3, MoveType::EnPassant);
game.make_move(&mv);
game.unmake_move();
assert_eq!(board_before_make, game.board);
assert_eq!(game_before_make, game);
Ok(())
}
@@ -168,12 +169,12 @@ mod tests {
#[test]
fn test_unmake_castle() -> Result<(), String> {
let mut game = from_fen(FEN)?;
let board_before_make = game.board.clone();
let game_before_make = game.clone();
let mv = Move::new_with_type(Square::E1, Square::C1, MoveType::Castle);
game.make_move(&mv);
game.unmake_move();
assert_eq!(board_before_make, game.board);
assert_eq!(game_before_make, game);
Ok(())
}

101
src/board/mailbox.rs Normal file
View File

@@ -0,0 +1,101 @@
use super::{
bitboard::{have_common_bit, square_to_bitboard},
board::{Board, PieceType},
square::Square,
};
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Mailbox {
pub mailbox: [Option<PieceType>; 64],
}
impl Mailbox {
pub const fn new() -> Self {
Self {
mailbox: [None; 64],
}
}
pub fn new_from_board(board: &Board) -> Self {
let mut mailbox: [Option<PieceType>; 64] = [None; 64];
for square in Square::A1..=Square::H8 {
mailbox[square] = board
.white_pieces
.iter()
.chain(board.black_pieces.iter())
.find(|p| have_common_bit(p.bitboard, square_to_bitboard(square)))
.map(|p| p.piece_type);
}
Self { mailbox }
}
pub fn set_piece_at(&mut self, square: usize, piece_type: Option<PieceType>) {
self.mailbox[square] = piece_type;
}
pub const fn find_piece_at(&self, square: usize) -> Option<PieceType> {
self.mailbox[square]
}
}
#[cfg(test)]
mod tests {
use crate::board::{board::PieceType, fen::from_fen, square::Square};
use super::Mailbox;
const FEN_MATE_IN_1: &str = "8/8/8/8/8/4q1k1/8/5K2 b - - 0 1";
const FEN_STARTPOS: &str = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1";
#[test]
fn test_new_from_board() -> Result<(), String> {
let game = from_fen(FEN_MATE_IN_1)?;
let mailbox = Mailbox::new_from_board(&game.board);
#[rustfmt::skip]
let expected: [Option<PieceType>; 64] = [
None, None, None, None, None, Some(PieceType::King), None, None,
None, None, None, None, None, None, None, None,
None, None, None, None, Some(PieceType::Queen), None, Some(PieceType::King), None,
None, None, None, None, None, None, None, None,
None, None, None, None, None, None, None, None,
None, None, None, None, None, None, None, None,
None, None, None, None, None, None, None, None,
None, None, None, None, None, None, None, None,
];
assert_eq!(expected, mailbox.mailbox);
let game = from_fen(FEN_STARTPOS)?;
let mailbox = Mailbox::new_from_board(&game.board);
#[rustfmt::skip]
let expected: [Option<PieceType>; 64] = [
Some(PieceType::Rook), Some(PieceType::Knight), Some(PieceType::Bishop), Some(PieceType::Queen),
Some(PieceType::King), Some(PieceType::Bishop), Some(PieceType::Knight), Some(PieceType::Rook),
Some(PieceType::Pawn), Some(PieceType::Pawn), Some(PieceType::Pawn), Some(PieceType::Pawn),
Some(PieceType::Pawn), Some(PieceType::Pawn), Some(PieceType::Pawn), Some(PieceType::Pawn),
None, None, None, None, None, None, None, None,
None, None, None, None, None, None, None, None,
None, None, None, None, None, None, None, None,
None, None, None, None, None, None, None, None,
Some(PieceType::Pawn), Some(PieceType::Pawn), Some(PieceType::Pawn), Some(PieceType::Pawn),
Some(PieceType::Pawn), Some(PieceType::Pawn), Some(PieceType::Pawn), Some(PieceType::Pawn),
Some(PieceType::Rook), Some(PieceType::Knight), Some(PieceType::Bishop), Some(PieceType::Queen),
Some(PieceType::King), Some(PieceType::Bishop), Some(PieceType::Knight), Some(PieceType::Rook),
];
assert_eq!(expected, mailbox.mailbox);
Ok(())
}
#[test]
fn test_find_piece_at() -> Result<(), String> {
let game = from_fen(FEN_MATE_IN_1)?;
let mailbox = Mailbox::new_from_board(&game.board);
assert_eq!(PieceType::King, mailbox.find_piece_at(Square::F1).unwrap());
Ok(())
}
}

1
src/board/mod.rs
View File

@@ -3,5 +3,6 @@ pub mod board;
pub mod fen;
pub mod game;
pub mod history;
pub mod mailbox;
pub mod square;
pub mod state;