eryn/chessfriend
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

[position] Lazily build move lists in MoveGenerator structs

Browse source 
Merge branch 'lazily-build-move-lists'
This commit is contained in:
Eryn Wells 2024-01-29 14:47:25 -08:00
commit d6bd6aec0f
14 changed files with 334 additions and 196 deletions
Download patch file Download diff file Expand all files Collapse all files

6
core/src/colors.rs
View file

@ -10,8 +10,10 @@ pub enum Color {
}
impl Color {
pub fn iter() -> impl Iterator<Item = Color> {
[Color::White, Color::Black].into_iter()
pub const ALL: [Color; 2] = [Color::White, Color::Black];
pub fn iter() -> impl Iterator<Item = &'static Color> {
Color::ALL.iter()
}
pub fn other(&self) -> Color {

4
position/src/lib.rs
View file

@ -11,5 +11,9 @@ mod sight;
#[macro_use]
mod macros;
#[cfg(test)]
#[macro_use]
mod tests;
pub use position::{MoveBuilder as MakeMoveBuilder, Position, PositionBuilder};
pub use r#move::{Castle, MakeMoveError, Move, MoveBuilder};

31
position/src/move.rs
View file

@ -16,6 +16,7 @@ pub enum MakeMoveError {
}
mod castle {
use chessfriend_bitboard::BitBoard;
use chessfriend_core::{Color, Square};
#[repr(u16)]
@ -25,12 +26,19 @@ mod castle {
QueenSide = 0b11,
}
pub(crate) struct CastlingParameters {
clear_squares: BitBoard,
check_squares: BitBoard,
}
pub(crate) struct Squares {
pub king: Square,
pub rook: Square,
}
impl Castle {
pub const ALL: [Castle; 2] = [Castle::KingSide, Castle::QueenSide];
const STARTING_SQUARES: [[Squares; 2]; 2] = [
[
Squares {
@ -91,6 +99,29 @@ mod castle {
Castle::QueenSide => 1,
}
}
pub(crate) fn parameters(&self) -> CastlingParameters {
match self {
Castle::KingSide => CastlingParameters {
clear_squares: BitBoard::new(0b01100000),
check_squares: BitBoard::new(0b01110000),
},
Castle::QueenSide => CastlingParameters {
clear_squares: BitBoard::new(0b00001110),
check_squares: BitBoard::new(0b00011100),
},
}
}
}
impl CastlingParameters {
pub fn clear_squares(&self) -> &BitBoard {
&self.clear_squares
}
pub fn check_squares(&self) -> &BitBoard {
&self.check_squares
}
}
}

3
position/src/move_generator.rs
View file

@ -57,7 +57,7 @@ macro_rules! move_generator_declaration {
};
($name:ident, getters) => {
impl $name {
pub(super) fn iter(&self) -> impl Iterator<Item = &$crate::Move> + '_ {
pub(super) fn iter(&self) -> impl Iterator<Item = $crate::Move> + '_ {
self.move_sets.values().map(|set| set.moves()).flatten()
}
@ -141,7 +141,6 @@ impl Moves {
.chain(self.rook_moves.iter())
.chain(self.queen_moves.iter())
.chain(self.king_moves.iter())
.cloned()
}
}

12
position/src/move_generator/bishop.rs
View file

@ -42,16 +42,12 @@ impl MoveGeneratorInternal for ClassicalMoveGenerator {
update_moves_with_ray!(SouthEast, occupied_squares);
update_moves_with_ray!(SouthWest, occupied_squares);
let quiet_moves_bb = all_moves & (empty_squares | !friendly_pieces);
let capture_moves_bb = all_moves & opposing_pieces;
let map_to_move = |sq| MoveBuilder::new(*piece, square, sq).build();
let quiet_moves = quiet_moves_bb.occupied_squares().map(map_to_move);
let capture_moves = capture_moves_bb.occupied_squares().map(map_to_move);
let quiet_moves = all_moves & (empty_squares | !friendly_pieces);
let capture_moves = all_moves & opposing_pieces;
MoveSet::new(placed_piece)
.quiet_moves(quiet_moves_bb, quiet_moves)
.capture_moves(capture_moves_bb, capture_moves)
.quiet_moves(quiet_moves)
.capture_moves(capture_moves)
}
}

186
position/src/move_generator/king.rs
View file

@ -12,28 +12,6 @@ move_generator_declaration!(KingMoveGenerator, struct);
move_generator_declaration!(KingMoveGenerator, new);
move_generator_declaration!(KingMoveGenerator, getters);
impl KingMoveGenerator {
#[allow(unused_variables)]
fn king_side_castle(position: &Position, color: Color) -> Option<Move> {
if !position.player_has_right_to_castle(color, Castle::KingSide) {
return None;
}
// TODO: Implement king side castle.
None
}
#[allow(unused_variables)]
fn queen_side_castle(position: &Position, color: Color) -> Option<Move> {
if !position.player_has_right_to_castle(color, Castle::QueenSide) {
return None;
}
// TODO: Implement queen side castle.
None
}
}
impl MoveGeneratorInternal for KingMoveGenerator {
fn piece(color: Color) -> Piece {
Piece::king(color)
@ -44,37 +22,37 @@ impl MoveGeneratorInternal for KingMoveGenerator {
let color = piece.color();
let square = placed_piece.square();
let safe_squares = !position.king_danger(color);
let all_king_moves = BitBoard::king_moves(square);
let empty_squares = position.empty_squares();
let safe_empty_squares = empty_squares & safe_squares;
let opposing_pieces = position.bitboard_for_color(color.other());
let opposing_pieces_on_safe_squares = opposing_pieces & safe_squares;
let all_moves = BitBoard::king_moves(square);
let quiet_moves_bb = all_moves & empty_squares;
let capture_moves_bb = all_moves & opposing_pieces;
let quiet_moves = all_king_moves & safe_empty_squares;
let capture_moves = all_king_moves & opposing_pieces_on_safe_squares;
// TODO: Handle checks. Prevent moving a king to a square attacked by a
// piece of the opposite color.
let mut move_set = MoveSet::new(placed_piece)
.quiet_moves(quiet_moves)
.capture_moves(capture_moves);
let map_to_move = |sq| MoveBuilder::new(*piece, square, sq).build();
if position.player_can_castle(color, Castle::KingSide) {
move_set.kingside_castle();
}
if position.player_can_castle(color, Castle::QueenSide) {
move_set.queenside_castle();
}
let king_side_castle = Self::king_side_castle(position, color);
let queen_side_castle = Self::queen_side_castle(position, color);
let quiet_moves = quiet_moves_bb
.occupied_squares()
.map(map_to_move)
.chain(king_side_castle.iter().cloned())
.chain(queen_side_castle.iter().cloned());
let capture_moves = capture_moves_bb.occupied_squares().map(map_to_move);
MoveSet::new(placed_piece)
.quiet_moves(quiet_moves_bb, quiet_moves)
.capture_moves(capture_moves_bb, capture_moves)
move_set
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::{position, r#move::AlgebraicMoveFormatter, PositionBuilder};
use crate::{assert_move_list, position, test_position, PositionBuilder};
use chessfriend_bitboard::bitboard;
use chessfriend_core::{piece, Square};
use std::collections::HashSet;
@ -90,7 +68,7 @@ mod tests {
bitboard![E5, F5, F4, F3, E3, D3, D4, D5]
);
let expected_moves = [
let expected_moves: HashSet<Move> = HashSet::from_iter([
MoveBuilder::new(piece!(White King), Square::E4, Square::D5).build(),
MoveBuilder::new(piece!(White King), Square::E4, Square::E5).build(),
MoveBuilder::new(piece!(White King), Square::E4, Square::F5).build(),
@ -99,23 +77,11 @@ mod tests {
MoveBuilder::new(piece!(White King), Square::E4, Square::E3).build(),
MoveBuilder::new(piece!(White King), Square::E4, Square::D3).build(),
MoveBuilder::new(piece!(White King), Square::E4, Square::D4).build(),
];
]);
let mut generated_moves: HashSet<Move> = generator.iter().cloned().collect();
let generated_moves: HashSet<Move> = generator.iter().collect();
for ex_move in expected_moves {
assert!(
generated_moves.remove(&ex_move),
"{:#?} was not generated",
&ex_move
);
}
assert!(
generated_moves.is_empty(),
"Moves unexpectedly present: {:#?}",
generated_moves
);
assert_move_list!(generated_moves, expected_moves, pos);
}
#[test]
@ -138,7 +104,7 @@ mod tests {
MoveBuilder::new(piece!(White King), Square::A1, Square::B2).build(),
];
let mut generated_moves: HashSet<Move> = generator.iter().cloned().collect();
let mut generated_moves: HashSet<Move> = generator.iter().collect();
for ex_move in expected_moves {
assert!(
@ -167,27 +133,93 @@ mod tests {
assert!(pos.is_king_in_check());
let generator = KingMoveGenerator::new(&pos, Color::Black);
let generated_moves: HashSet<Move> = generator.iter().cloned().collect();
let generated_moves = generator.bitboard();
let king = piece!(Black King);
let from_square = Square::E7;
let expected_moves = HashSet::from_iter([
MoveBuilder::new(king, from_square, Square::D6).build(),
MoveBuilder::new(king, from_square, Square::D7).build(),
MoveBuilder::new(king, from_square, Square::D8).build(),
MoveBuilder::new(king, from_square, Square::F6).build(),
MoveBuilder::new(king, from_square, Square::F7).build(),
MoveBuilder::new(king, from_square, Square::F8).build(),
]);
let expected_moves = bitboard![F8, F7, F6, D6, D7, D8];
assert_eq!(
generated_moves,
expected_moves,
"Difference: {:?}",
generated_moves
.symmetric_difference(&expected_moves)
.map(|mv| format!("{}", AlgebraicMoveFormatter::new(mv, &pos)))
.collect::<Vec<_>>()
assert_eq!(generated_moves, expected_moves);
}
#[test]
fn white_king_unobstructed_castles() {
let pos = test_position!(
White King on E1,
White Rook on A1,
White Rook on H1,
);
assert!(pos.player_can_castle(Color::White, Castle::KingSide));
assert!(pos.player_can_castle(Color::White, Castle::QueenSide));
let generator = KingMoveGenerator::new(&pos, Color::White);
let generated_moves: HashSet<Move> = generator.iter().collect();
let king = piece!(White King);
assert!(generated_moves.contains(
&MoveBuilder::new(king, Square::E1, Square::G1)
.castle(Castle::KingSide)
.build()
));
assert!(generated_moves.contains(
&MoveBuilder::new(king, Square::E1, Square::C1)
.castle(Castle::QueenSide)
.build()
));
}
#[test]
fn white_king_obstructed_queenside_castle() {
let pos = test_position!(
White King on E1,
White Knight on B1,
White Rook on A1,
White Rook on H1,
);
assert!(pos.player_can_castle(Color::White, Castle::KingSide));
assert!(!pos.player_can_castle(Color::White, Castle::QueenSide));
let generator = KingMoveGenerator::new(&pos, Color::White);
let generated_moves: HashSet<Move> = generator.iter().collect();
let king = piece!(White King);
assert!(generated_moves.contains(
&MoveBuilder::new(king, Square::E1, Square::G1)
.castle(Castle::KingSide)
.build()
));
assert!(!generated_moves.contains(
&MoveBuilder::new(king, Square::E1, Square::C1)
.castle(Castle::QueenSide)
.build()
));
}
#[test]
fn white_king_obstructed_kingside_castle() {
let pos = test_position!(
White King on E1,
White Rook on A1,
White Knight on G1,
White Rook on H1,
);
assert!(!pos.player_can_castle(Color::White, Castle::KingSide));
assert!(pos.player_can_castle(Color::White, Castle::QueenSide));
let generator = KingMoveGenerator::new(&pos, Color::White);
let generated_moves: HashSet<Move> = generator.iter().collect();
let king = piece!(White King);
assert!(!generated_moves.contains(
&MoveBuilder::new(king, Square::E1, Square::G1)
.castle(Castle::KingSide)
.build()
));
assert!(generated_moves.contains(
&MoveBuilder::new(king, Square::E1, Square::C1)
.castle(Castle::QueenSide)
.build()
));
}
}

20
position/src/move_generator/knight.rs
View file

@ -17,22 +17,12 @@ impl MoveGeneratorInternal for KnightMoveGenerator {
let empty_squares = position.empty_squares();
let knight_moves = BitBoard::knight_moves(placed_piece.square());
let quiet_moves_bb = knight_moves & empty_squares;
let capture_moves_bb = knight_moves & opposing_pieces;
let quiet_moves = quiet_moves_bb.occupied_squares().map(|to_sq| {
MoveBuilder::new(*placed_piece.piece(), placed_piece.square(), to_sq).build()
});
let capture_moves = capture_moves_bb.occupied_squares().map(|to_sq| {
let captured_piece = position.piece_on_square(to_sq).unwrap();
MoveBuilder::new(*placed_piece.piece(), placed_piece.square(), to_sq)
.capturing(captured_piece)
.build()
});
let quiet_moves = knight_moves & empty_squares;
let capture_moves = knight_moves & opposing_pieces;
MoveSet::new(placed_piece)
.quiet_moves(quiet_moves_bb, quiet_moves)
.capture_moves(capture_moves_bb, capture_moves)
.quiet_moves(quiet_moves)
.capture_moves(capture_moves)
}
}
@ -72,7 +62,7 @@ mod tests {
MoveBuilder::new(piece!(White Knight), Square::E4, Square::F6).build(),
];
let mut generated_moves: HashSet<Move> = generator.iter().cloned().collect();
let mut generated_moves: HashSet<Move> = generator.iter().collect();
for ex_move in expected_moves {
assert!(

100
position/src/move_generator/move_set.rs
View file

@ -1,10 +1,10 @@
// Eryn Wells <eryn@erynwells.me>
use crate::Move;
use crate::{r#move::Castle, Move, MoveBuilder};
use chessfriend_bitboard::BitBoard;
use chessfriend_core::PlacedPiece;
use chessfriend_core::{Color, Piece, PlacedPiece, Shape};
#[derive(Clone, Debug, Eq, PartialEq)]
#[derive(Clone, Debug, Default, Eq, PartialEq)]
struct BitBoardSet {
quiet: BitBoard,
captures: BitBoard,
@ -27,43 +27,35 @@ impl MoveListSet {
pub(crate) struct MoveSet {
piece: PlacedPiece,
bitboards: BitBoardSet,
move_lists: MoveListSet,
special: u8,
}
impl MoveSet {
pub(super) fn new(piece: PlacedPiece) -> MoveSet {
MoveSet {
piece,
bitboards: BitBoardSet {
quiet: BitBoard::empty(),
captures: BitBoard::empty(),
},
move_lists: MoveListSet {
quiet: Vec::new(),
captures: Vec::new(),
},
bitboards: BitBoardSet::default(),
special: 0,
}
}
pub(super) fn quiet_moves(
mut self,
bitboard: BitBoard,
move_list: impl Iterator<Item = Move>,
) -> MoveSet {
pub(super) fn quiet_moves(mut self, bitboard: BitBoard) -> MoveSet {
self.bitboards.quiet = bitboard;
self.move_lists.quiet = move_list.collect();
self
}
pub(super) fn capture_moves(
mut self,
bitboard: BitBoard,
move_list: impl Iterator<Item = Move>,
) -> MoveSet {
pub(super) fn capture_moves(mut self, bitboard: BitBoard) -> MoveSet {
self.bitboards.captures = bitboard;
self.move_lists.captures = move_list.collect();
self
}
pub(super) fn kingside_castle(&mut self) -> &mut MoveSet {
self.special |= 0b1;
self
}
pub(super) fn queenside_castle(&mut self) -> &mut MoveSet {
self.special |= 0b10;
self
}
@ -72,10 +64,58 @@ impl MoveSet {
self.bitboards.captures | self.bitboards.quiet
}
pub(super) fn moves(&self) -> impl Iterator<Item = &Move> {
self.move_lists
.captures
.iter()
.chain(self.move_lists.quiet.iter())
pub(super) fn moves(&self) -> impl Iterator<Item = Move> + '_ {
let piece = self.piece.piece();
let from_square = self.piece.square();
self.bitboards
.quiet
.occupied_squares()
.map(move |to_square| MoveBuilder::new(*piece, from_square, to_square).build())
.chain(
self.bitboards
.captures
.occupied_squares()
.map(move |to_square| {
MoveBuilder::new(*piece, from_square, to_square)
.capturing(PlacedPiece::new(
Piece::new(Color::White, Shape::Pawn),
to_square,
))
.build()
}),
)
.chain(
if (self.special & 0b1) != 0 {
Some(())
} else {
None
}
.map(|()| {
MoveBuilder::new(
*piece,
from_square,
Castle::KingSide.target_squares(piece.color()).king,
)
.castle(Castle::KingSide)
.build()
}),
)
.chain(
if (self.special & 0b10) != 0 {
Some(())
} else {
None
}
.map(|()| {
MoveBuilder::new(
*piece,
from_square,
Castle::QueenSide.target_squares(piece.color()).king,
)
.castle(Castle::QueenSide)
.build()
}),
)
}
}

51
position/src/move_generator/pawn.rs
View file

@ -1,7 +1,7 @@
// Eryn Wells <eryn@erynwells.me>
use super::{move_generator_declaration, MoveGeneratorInternal, MoveSet};
use crate::{MoveBuilder, Position};
use crate::Position;
use chessfriend_bitboard::BitBoard;
use chessfriend_core::{Color, Piece, PlacedPiece, Rank, Square};
@ -16,24 +16,12 @@ impl MoveGeneratorInternal for PawnMoveGenerator {
}
fn move_set_for_piece(position: &Position, placed_piece: PlacedPiece) -> MoveSet {
let from_square = placed_piece.square();
let captures_bitboard = Self::attacks(position, placed_piece);
let quiet_moves_bitboard = Self::pushes(position, placed_piece);
let quiet_moves = quiet_moves_bitboard.occupied_squares().map(|to_square| {
MoveBuilder::new(*placed_piece.piece(), from_square, to_square).build()
});
let capture_moves = captures_bitboard.occupied_squares().map(|to_square| {
let captured_piece = position.piece_on_square(to_square).unwrap();
MoveBuilder::new(*placed_piece.piece(), from_square, to_square)
.capturing(captured_piece)
.build()
});
let capture_moves = Self::attacks(position, placed_piece);
let quiet_moves = Self::pushes(position, placed_piece);
MoveSet::new(placed_piece)
.quiet_moves(quiet_moves_bitboard, quiet_moves)
.capture_moves(captures_bitboard, capture_moves)
.quiet_moves(quiet_moves)
.capture_moves(capture_moves)
}
}
@ -42,13 +30,11 @@ impl PawnMoveGenerator {
let square = piece.square();
let bitboard: BitBoard = square.into();
let empty_squares = position.empty_squares();
let starting_rank = Rank::PAWN_STARTING_RANKS[piece.color() as usize];
let empty_squares = position.empty_squares();
let mut moves = bitboard.shift_north_one() & empty_squares;
if !(bitboard
& BitBoard::rank(Rank::PAWN_STARTING_RANKS[piece.color() as usize].as_index()))
.is_empty()
{
if !(bitboard & BitBoard::rank(starting_rank.as_index())).is_empty() {
moves |= moves.shift_north_one() & empty_squares;
}
@ -71,7 +57,7 @@ impl PawnMoveGenerator {
#[cfg(test)]
mod tests {
use super::*;
use crate::{position::DiagramFormatter, test_position, Move};
use crate::{assert_move_list, position::DiagramFormatter, test_position, Move, MoveBuilder};
use chessfriend_core::{piece, Square};
use std::collections::HashSet;
@ -86,7 +72,7 @@ mod tests {
MoveBuilder::new(piece!(White Pawn), Square::E2, Square::E4).build(),
]);
let generated_moves: HashSet<Move> = generator.iter().cloned().collect();
let generated_moves: HashSet<Move> = generator.iter().collect();
assert_eq!(generated_moves, expected_moves);
}
@ -104,9 +90,9 @@ mod tests {
)
.build()]);
let generated_moves: HashSet<Move> = generator.iter().cloned().collect();
let generated_moves: HashSet<Move> = generator.iter().collect();
assert_eq!(generated_moves, expected_moves);
assert_move_list!(generated_moves, expected_moves, pos);
}
#[test]
@ -127,9 +113,9 @@ mod tests {
)
.build()]);
let generated_moves: HashSet<Move> = generator.iter().cloned().collect();
let generated_moves: HashSet<Move> = generator.iter().collect();
assert_eq!(generated_moves, expected_moves);
assert_move_list!(generated_moves, expected_moves, pos);
}
#[test]
@ -141,9 +127,10 @@ mod tests {
let generator = PawnMoveGenerator::new(&pos, Color::White);
let generated_moves: HashSet<Move> = generator.iter().cloned().collect();
let generated_moves: HashSet<Move> = generator.iter().collect();
let expected_moves: HashSet<Move> = HashSet::new();
assert_eq!(generated_moves, HashSet::new());
assert_move_list!(generated_moves, expected_moves, pos);
}
#[test]
@ -163,7 +150,7 @@ mod tests {
.build()],
);
let generated_moves: HashSet<Move> = generator.iter().cloned().collect();
let generated_moves: HashSet<Move> = generator.iter().collect();
assert_eq!(generated_moves, expected_moves);
}
@ -188,7 +175,7 @@ mod tests {
.build(),
]);
let generated_moves: HashSet<Move> = generator.iter().cloned().collect();
let generated_moves: HashSet<Move> = generator.iter().collect();
assert_eq!(
generated_moves, expected_moves,

14
position/src/move_generator/queen.rs
View file

@ -1,7 +1,7 @@
// Eryn Wells <eryn@erynwells.me>
use super::{move_generator_declaration, MoveGeneratorInternal, MoveSet};
use crate::{MoveBuilder, Position};
use crate::Position;
use chessfriend_bitboard::BitBoard;
use chessfriend_core::{Color, Direction, Piece, PlacedPiece};
@ -48,16 +48,12 @@ impl MoveGeneratorInternal for ClassicalMoveGenerator {
update_moves_with_ray!(SouthWest, occupied_squares);
update_moves_with_ray!(West, occupied_squares);
let quiet_moves_bb = all_moves & (empty_squares | !friendly_pieces);
let capture_moves_bb = all_moves & opposing_pieces;
let map_to_move = |sq| MoveBuilder::new(*piece, square, sq).build();
let quiet_moves = quiet_moves_bb.occupied_squares().map(map_to_move);
let capture_moves = capture_moves_bb.occupied_squares().map(map_to_move);
let quiet_moves = all_moves & (empty_squares | !friendly_pieces);
let capture_moves = all_moves & opposing_pieces;
MoveSet::new(placed_piece)
.quiet_moves(quiet_moves_bb, quiet_moves)
.capture_moves(capture_moves_bb, capture_moves)
.quiet_moves(quiet_moves)
.capture_moves(capture_moves)
}
}

14
position/src/move_generator/rook.rs
View file

@ -1,7 +1,7 @@
// Eryn Wells <eryn@erynwells.me>
use super::{move_generator_declaration, MoveGeneratorInternal, MoveSet};
use crate::{MoveBuilder, Position};
use crate::Position;
use chessfriend_bitboard::BitBoard;
use chessfriend_core::{Color, Direction, Piece, PlacedPiece};
@ -44,16 +44,12 @@ impl MoveGeneratorInternal for ClassicalMoveGenerator {
update_moves_with_ray!(South, occupied_squares);
update_moves_with_ray!(West, occupied_squares);
let quiet_moves_bb = all_moves & (empty_squares | !friendly_pieces);
let capture_moves_bb = all_moves & opposing_pieces;
let map_to_move = |sq| MoveBuilder::new(*piece, square, sq).build();
let quiet_moves = quiet_moves_bb.occupied_squares().map(map_to_move);
let capture_moves = capture_moves_bb.occupied_squares().map(map_to_move);
let quiet_moves = all_moves & (empty_squares | !friendly_pieces);
let capture_moves = all_moves & opposing_pieces;
MoveSet::new(placed_piece)
.quiet_moves(quiet_moves_bb, quiet_moves)
.capture_moves(capture_moves_bb, capture_moves)
.quiet_moves(quiet_moves)
.capture_moves(capture_moves)
}
}

26
position/src/position/builders/position_builder.rs
View file

@ -61,9 +61,11 @@ impl Builder {
pub fn place_piece(&mut self, piece: PlacedPiece) -> &mut Self {
let square = piece.square();
let shape = piece.shape();
if piece.shape() == Shape::King {
let color_index: usize = piece.color() as usize;
if shape == Shape::King {
let color = piece.color();
let color_index: usize = color as usize;
self.pieces.remove(&self.kings[color_index]);
self.kings[color_index] = square;
}
@ -81,9 +83,27 @@ impl Builder {
.filter(Self::is_piece_placement_valid),
);
let mut flags = self.flags;
for color in Color::ALL {
for castle in Castle::ALL {
let starting_squares = castle.starting_squares(color);
let has_rook_on_starting_square = self
.pieces
.get(&starting_squares.rook)
.is_some_and(|piece| piece.shape() == Shape::Rook);
let king_is_on_starting_square =
self.kings[color as usize] == starting_squares.king;
if !king_is_on_starting_square || !has_rook_on_starting_square {
flags.clear_player_has_right_to_castle_flag(color, castle);
}
}
}
Position::new(
self.player_to_move,
self.flags,
flags,
pieces,
None,
self.ply_counter,

44
position/src/position/position.rs
View file

@ -107,7 +107,17 @@ impl Position {
return false;
}
// TODO: Perform a real check that the player can castle.
let castling_parameters = castle.parameters();
let all_pieces = self.occupied_squares();
if !(all_pieces & castling_parameters.clear_squares()).is_empty() {
return false;
}
let danger_squares = self.king_danger(player);
if !(danger_squares & castling_parameters.check_squares()).is_empty() {
return false;
}
true
}
@ -159,7 +169,7 @@ impl Position {
pub fn piece_on_square(&self, sq: Square) -> Option<PlacedPiece> {
for color in Color::iter() {
for shape in Shape::iter() {
let piece = Piece::new(color, *shape);
let piece = Piece::new(*color, *shape);
if self.pieces.bitboard_for_piece(&piece).is_set(sq) {
return Some(PlacedPiece::new(piece, sq));
}
@ -212,19 +222,16 @@ impl Position {
/// A bitboard representing the squares where a king of the given color will
/// be in danger. The king cannot move to these squares.
pub(crate) fn king_danger(&self) -> BitBoard {
pub(crate) fn king_danger(&self, color: Color) -> BitBoard {
let pieces_without_king = {
let mut cloned_pieces = self.pieces.clone();
let placed_king = PlacedPiece::new(
Piece::king(self.color_to_move),
self.king_square(self.color_to_move),
);
let placed_king = PlacedPiece::new(Piece::king(color), self.king_square(color));
cloned_pieces.remove_piece(&placed_king);
cloned_pieces
};
self._sight_of_player(self.color_to_move.other(), &pieces_without_king)
self._sight_of_player(color.other(), &pieces_without_king)
}
pub(crate) fn is_king_in_check(&self) -> bool {
@ -363,6 +370,25 @@ mod tests {
assert!(!pos.is_king_in_check());
}
#[test]
fn king_not_on_starting_square_cannot_castle() {
let pos = test_position!(White King on E4);
assert!(!pos.player_can_castle(Color::White, Castle::KingSide));
assert!(!pos.player_can_castle(Color::White, Castle::QueenSide));
}
#[test]
fn king_on_starting_square_can_castle() {
let pos = test_position!(
White King on E1,
White Rook on A1,
White Rook on H1
);
assert!(pos.player_can_castle(Color::White, Castle::KingSide));
assert!(pos.player_can_castle(Color::White, Castle::QueenSide));
}
#[test]
fn rook_for_castle() {
let pos = position![
@ -390,7 +416,7 @@ mod tests {
.to_move(Color::Black)
.build();
let danger_squares = pos.king_danger();
let danger_squares = pos.king_danger(Color::Black);
let expected =
bitboard![D1, F1, D2, E2, F2, E3, A4, B4, C4, D4, F4, G4, H4, E5, E6, E7, E8];
assert_eq!(

19
position/src/tests.rs Normal file
View file

@ -0,0 +1,19 @@
// Eryn Wells <eryn@erynwells.me>
#[macro_export]
macro_rules! assert_move_list {
($generated:expr, $expected:expr, $position:expr) => {
assert_eq!(
$generated,
$expected,
"Difference: {:?}",
$generated
.symmetric_difference(&$expected)
.map(|mv| format!(
"{}",
$crate::r#move::AlgebraicMoveFormatter::new(mv, &$position)
))
.collect::<Vec<String>>()
)
};
}