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

Move make/unmake and History on Game

Browse Source
This commit is contained in:
stefiosif
2024-09-15 18:38:32 +03:00
parent 3383435af7
commit f128b35252
8 changed files with 172 additions and 159 deletions
Download Patch File Download Diff File Expand all files Collapse all files

153
src/board/board.rs
View File

@@ -10,14 +10,13 @@ use crate::movegen::move_generator::{
bishop_pseudo_moves, king_pseudo_moves, knight_pseudo_moves, pawn_pseudo_moves,
queen_pseudo_moves, rook_pseudo_moves,
};
use crate::movegen::r#move::{Move, MoveType, Promote};
use crate::movegen::r#move::{Move, Promote};
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Board {
pub white_pieces: [Piece; 6],
pub black_pieces: [Piece; 6],
pub state: State,
pub history: History,
}
impl Board {
@@ -40,7 +39,6 @@ impl Board {
Piece::new(0x1000000000000000, PieceType::King, Color::Black),
],
state: State::new(),
history: History::new(),
}
}
@@ -63,7 +61,6 @@ impl Board {
Piece::new(0x0, PieceType::King, Color::Black),
],
state: State::new(),
history: History::new(),
}
}
@@ -191,117 +188,7 @@ impl Board {
None
}
pub fn make_move(&mut self, mv: &Move) {
let color = self.state.current_player();
let pawn_move = self.is_pawn_move(mv.src);
let mut en_passant_square = None;
self.history
.push_move_parameters(MoveParameters::build(&self, mv));
match &mv.move_type {
MoveType::Quiet => {
self.move_piece(mv.src, mv.dst);
}
MoveType::Capture => {
self.move_piece(mv.src, mv.dst);
self.remove_opponent_piece(mv.dst);
}
MoveType::EnPassant => {
self.move_piece(mv.src, mv.dst);
self.remove_pawn_enpassant(mv.dst, color);
}
MoveType::DoublePush => {
self.move_piece(mv.src, mv.dst);
en_passant_square = match color {
Color::White => Some(mv.src + 8),
Color::Black => Some(mv.src.saturating_sub(8)),
};
}
MoveType::Promotion(promote) => {
self.remove_own_piece(mv.src);
self.promote_piece(mv.dst, promote);
}
MoveType::PromotionCapture(promote) => {
self.remove_own_piece(mv.src);
self.remove_opponent_piece(mv.dst);
self.promote_piece(mv.dst, promote);
}
MoveType::Castle => {
self.move_piece(mv.src, mv.dst);
self.move_rook_castle(mv.dst);
self.state.set_castling_ability(color, Castle::None);
}
}
Self::update_game_state(&mut self.state, mv, color, pawn_move, en_passant_square);
}
pub fn unmake_move(&mut self) {
let move_parameters =
std::mem::take(&mut self.history.pop_move_parameters()).unwrap_or_default();
let color_before_move = self.state.change_side();
self.state.revert_full_move(color_before_move);
self.state.en_passant_square = move_parameters.en_passant_square;
if let Some(new_castling_ability) = move_parameters.castling_ability {
self.state.castling_ability = new_castling_ability;
}
if let Some(new_halfmove_clock) = move_parameters.halfmove_clock {
self.state.halfmove_clock = new_halfmove_clock;
}
let mv = move_parameters.mv.unwrap();
match &mv.move_type {
MoveType::Quiet | MoveType::DoublePush => {
self.move_piece(mv.dst, mv.src);
}
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) = self.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 {
self.move_piece(mv.dst, mv.src);
let opponent_pieces = self.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 = self.own_pieces();
own_pieces[promoted_piece_type].bitboard &= !square_to_bitboard(mv.dst);
own_pieces[PieceType::Pawn].bitboard |= square_to_bitboard(mv.src);
}
}
MoveType::EnPassant => {
self.move_piece(mv.dst, mv.src);
let enemy_pawn_square = match color_before_move {
Color::White => mv.dst - 8,
Color::Black => mv.dst + 8,
};
let opponent_pieces = self.opponent_pieces();
opponent_pieces[PieceType::Pawn].bitboard |= square_to_bitboard(enemy_pawn_square);
}
MoveType::Castle => {
self.move_piece(mv.dst, mv.src);
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,
};
let own_pieces = self.own_pieces();
own_pieces[PieceType::Rook].bitboard &= !square_to_bitboard(rook_dst);
own_pieces[PieceType::Rook].bitboard |= square_to_bitboard(rook_src);
}
}
}
fn update_game_state(
pub fn update_game_state(
state: &mut State,
mv: &Move,
color: Color,
@@ -316,7 +203,7 @@ impl Board {
state.change_side();
}
fn move_piece(&mut self, src: usize, dst: usize) {
pub fn move_piece(&mut self, src: usize, dst: usize) {
let pieces = self.own_pieces();
pieces
.iter_mut()
@@ -327,7 +214,7 @@ impl Board {
});
}
fn remove_own_piece(&mut self, square: usize) {
pub fn remove_own_piece(&mut self, square: usize) {
let pieces = self.own_pieces();
pieces
.iter_mut()
@@ -337,7 +224,7 @@ impl Board {
});
}
fn remove_opponent_piece(&mut self, square: usize) {
pub fn remove_opponent_piece(&mut self, square: usize) {
let pieces = self.opponent_pieces();
pieces
.iter_mut()
@@ -347,7 +234,7 @@ impl Board {
});
}
fn move_rook_castle(&mut self, king_dst: usize) {
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),
@@ -357,7 +244,7 @@ impl Board {
self.move_piece(rook_src, rook_dst);
}
fn promote_piece(&mut self, square: usize, promote: &Promote) {
pub fn promote_piece(&mut self, square: usize, promote: &Promote) {
let pieces = self.own_pieces();
match promote {
Promote::Knight => pieces[PieceType::Knight].bitboard |= square_to_bitboard(square),
@@ -367,7 +254,7 @@ impl Board {
};
}
fn remove_pawn_enpassant(&mut self, square: usize, color: Color) {
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,
@@ -376,26 +263,26 @@ impl Board {
self.remove_opponent_piece(piece_to_remove);
}
fn is_pawn_move(&mut self, square: usize) -> bool {
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)
}
fn own_pieces(&mut self) -> &mut [Piece; 6] {
pub fn own_pieces(&mut self) -> &mut [Piece; 6] {
match self.state.current_player() {
Color::White => &mut self.white_pieces,
Color::Black => &mut self.black_pieces,
}
}
fn opponent_pieces(&mut self) -> &mut [Piece; 6] {
pub fn opponent_pieces(&mut self) -> &mut [Piece; 6] {
match self.state.current_player() {
Color::White => &mut self.black_pieces,
Color::Black => &mut self.white_pieces,
}
}
fn all_pieces(&mut self) -> (&mut [Piece; 6], &mut [Piece; 6]) {
pub fn all_pieces(&mut self) -> (&mut [Piece; 6], &mut [Piece; 6]) {
match self.state.current_player() {
Color::White => (&mut self.white_pieces, &mut self.black_pieces),
Color::Black => (&mut self.black_pieces, &mut self.white_pieces),
@@ -444,9 +331,7 @@ impl PieceType {
use std::ops::{Index, IndexMut};
use super::bitboard::square_to_bitboard;
use super::history::{History, MoveParameters};
use super::square::Square;
use super::state::Castle;
impl Index<PieceType> for [Piece] {
type Output = Piece;
@@ -516,7 +401,7 @@ mod tests {
fn test_make_move_quiet() -> Result<(), String> {
let mut game = from_fen(FEN)?;
let b1c3 = Move::new(Square::F3, Square::E3);
game.board.make_move(&b1c3);
game.make_move(&b1c3);
assert_eq!(game, from_fen(FEN_QUIET)?);
@@ -529,7 +414,7 @@ mod tests {
fn test_make_move_capture() -> Result<(), String> {
let mut game = from_fen(FEN)?;
let f3f5 = Move::new_with_type(Square::F3, Square::F5, MoveType::Capture);
game.board.make_move(&f3f5);
game.make_move(&f3f5);
assert_eq!(game, from_fen(FEN_CAPTURE)?);
@@ -543,7 +428,7 @@ mod tests {
fn test_make_move_en_passant() -> Result<(), String> {
let mut game = from_fen(FEN)?;
let h5g6 = Move::new_with_type(Square::H5, Square::G6, MoveType::EnPassant);
game.board.make_move(&h5g6);
game.make_move(&h5g6);
assert_eq!(game, from_fen(FEN_EN_PASSANT)?);
@@ -557,7 +442,7 @@ mod tests {
fn test_make_move_double_push() -> Result<(), String> {
let mut game = from_fen(FEN)?;
let b2b4 = Move::new_with_type(Square::B2, Square::B4, MoveType::DoublePush);
game.board.make_move(&b2b4);
game.make_move(&b2b4);
assert_eq!(game, from_fen(FEN_DOUBLE_PUSH)?);
Ok(())
@@ -569,7 +454,7 @@ mod tests {
fn test_make_move_promotion() -> Result<(), String> {
let mut game = from_fen(FEN)?;
let c7c8 = Move::new_with_type(Square::C7, Square::C8, MoveType::Promotion(Promote::Queen));
game.board.make_move(&c7c8);
game.make_move(&c7c8);
assert_eq!(game, from_fen(FEN_PROMOTION)?);
Ok(())
@@ -586,7 +471,7 @@ mod tests {
Square::B8,
MoveType::PromotionCapture(Promote::Queen),
);
game.board.make_move(&c7b8);
game.make_move(&c7b8);
assert_eq!(game, from_fen(FEN_PROMOTION_CAPTURE)?);
Ok(())
@@ -598,7 +483,7 @@ mod tests {
fn test_make_move_castle() -> Result<(), String> {
let mut game = from_fen(FEN)?;
let e1g1 = Move::new_with_type(Square::E1, Square::G1, MoveType::Castle);
game.board.make_move(&e1g1);
game.make_move(&e1g1);
assert_eq!(game, from_fen(FEN_CASTLE)?);
Ok(())
}