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

[board] Implement a PositionBuilder; refactor piece bitboards into a PieceBitBoards struct

Browse source 
This makes Position immutable, even if declared mut. I think this will also make
it easier to build positions going forward.

Moving to a PieceBitBoards struct also required a lot of places that return owned
BitBoards to return refs. This is basically fine except for adding a few more &
here and there.

This was a huge refactoring project. All the move generators and a bunch of
BitBoard stuff needed to be updated.
This commit is contained in:
Eryn Wells 2024-01-19 18:08:41 -08:00
parent 939fac80d7
commit 24cce95a88
17 changed files with 472 additions and 381 deletions
Download patch file Download diff file Expand all files Collapse all files

53
board/src/move_generator/bishop.rs
View file

@ -21,8 +21,7 @@ impl<'pos> MoveGeneratorInternal for ClassicalMoveGenerator<'pos> {
let blockers = position.occupied_squares();
let empty_squares = !blockers;
let friendly_pieces = position.bitboard_for_color(color);
let opposing_pieces = position.bitboard_for_color(color.other());
let (friendly_pieces, opposing_pieces) = position.all_pieces();
let mut all_moves = BitBoard::empty();
@ -63,20 +62,18 @@ impl<'pos> MoveGeneratorInternal for ClassicalMoveGenerator<'pos> {
mod tests {
use super::*;
use crate::{
piece,
piece::{Color, Piece},
position,
position::DiagramFormatter,
BitBoard, Position, Square,
};
#[test]
fn classical_single_bishop_bitboard() {
let mut pos = Position::empty();
[(Piece::bishop(Color::White), Square::A1)]
.into_iter()
.for_each(|(p, sq)| {
pos.place_piece(p, sq)
.expect(&format!("Unable to place {:?} on {}", &p, &sq))
});
let pos = position![
White Bishop on A1,
];
let generator = ClassicalMoveGenerator::new(&pos, Color::White);
@ -91,16 +88,10 @@ mod tests {
/// Test that a bishop can move up to, but not onto, a friendly piece.
#[test]
fn classical_single_bishop_with_same_color_blocker_bitboard() {
let mut pos = Position::empty();
[
(Piece::bishop(Color::White), Square::A1),
(Piece::knight(Color::White), Square::E5),
]
.into_iter()
.for_each(|(p, sq)| {
pos.place_piece(p, sq)
.expect(&format!("Unable to place {} on {}", p, sq))
});
let pos = position![
White Bishop on A1,
White Knight on E5,
];
println!("{}", DiagramFormatter::new(&pos));
@ -117,16 +108,10 @@ mod tests {
/// Test that a rook can move up to, and then capture, an enemy piece.
#[test]
fn classical_single_bishop_with_opposing_color_blocker_bitboard() {
let mut pos = Position::empty();
[
(Piece::bishop(Color::White), Square::A1),
(Piece::knight(Color::Black), Square::C3),
]
.into_iter()
.for_each(|(p, sq)| {
pos.place_piece(p, sq)
.expect(&format!("Unable to place {} on {}", p, sq))
});
let mut pos = position![
White Bishop on A1,
Black Knight on C3,
];
let generator = ClassicalMoveGenerator::new(&pos, Color::White);
@ -140,13 +125,9 @@ mod tests {
#[test]
fn classical_single_bishop_in_center() {
let mut pos = Position::empty();
[(Piece::bishop(Color::White), Square::E4)]
.into_iter()
.for_each(|(p, sq)| {
pos.place_piece(p, sq)
.expect(&format!("Unable to place {} on {}", p, sq))
});
let mut pos = position![
White Bishop on E4,
];
println!("{}", DiagramFormatter::new(&pos));

27
board/src/move_generator/king.rs
View file

@ -76,23 +76,18 @@ impl<'pos> MoveGeneratorInternal for KingMoveGenerator<'pos> {
#[cfg(test)]
mod tests {
use super::*;
use crate::{piece, piece::Piece, Position, Square};
use crate::Square;
use std::collections::HashSet;
#[test]
fn one_king() {
let mut pos = Position::empty();
pos.place_piece(Piece::king(Color::White), Square::E4)
.expect("Failed to place king on e4");
let pos = position![White King on E4];
let generator = KingMoveGenerator::new(&pos, Color::White);
let bb = generator.bitboard();
assert_eq!(
bb,
BitBoard::new(
0b00000000_00000000_00000000_00111000_00101000_00111000_00000000_00000000
)
generator.bitboard(),
bitboard![E5, F5, F4, F3, E3, D3, D4, D5]
);
let expected_moves = [
@ -125,18 +120,16 @@ mod tests {
#[test]
fn one_king_corner() {
let mut pos = Position::empty();
pos.place_piece(Piece::king(Color::White), Square::A1)
.expect("Failed to place king on a1");
let pos = position![White King on A1];
let generator = KingMoveGenerator::new(&pos, Color::White);
let bb = generator.bitboard();
let generated_bitboard = generator.bitboard();
let expected_bitboard = bitboard![A2, B2, B1];
assert_eq!(
bb,
BitBoard::new(
0b00000000_00000000_00000000_00000000_00000000_00000000_00000011_00000010
)
generator.bitboard(),
bitboard![A2, B2, B1],
"Generated:\n{generated_bitboard}\nExpected:\n{expected_bitboard}"
);
let expected_moves = [

8
board/src/move_generator/knight.rs
View file

@ -40,14 +40,14 @@ impl<'pos> MoveGeneratorInternal for KnightMoveGenerator<'pos> {
#[cfg(test)]
mod tests {
use super::*;
use crate::{piece, Move, Square};
use crate::{piece, position, Move, Square};
use std::collections::HashSet;
#[test]
fn one_knight() {
let mut pos = Position::empty();
pos.place_piece(Piece::knight(Color::White), Square::E4)
.expect("Failed to place knight on e4");
let pos = position![
White Knight on E4,
];
let generator = KnightMoveGenerator::new(&pos, Color::White);

90
board/src/move_generator/pawn.rs
View file

@ -17,9 +17,9 @@ struct MoveIterator(usize, usize);
struct MoveGenerationParameters {
starting_rank: BitBoard,
promotion_rank: BitBoard,
push_shift: fn(BitBoard) -> BitBoard,
left_capture_shift: fn(BitBoard) -> BitBoard,
right_capture_shift: fn(BitBoard) -> BitBoard,
push_shift: fn(&BitBoard) -> BitBoard,
left_capture_shift: fn(&BitBoard) -> BitBoard,
right_capture_shift: fn(&BitBoard) -> BitBoard,
}
pub(super) struct PawnMoveGenerator<'pos> {
@ -105,7 +105,7 @@ impl<'pos> PawnMoveGenerator<'pos> {
let legal_1square_pushes = (parameters.push_shift)(bb) & empty_squares;
let legal_2square_pushes =
(parameters.push_shift)(legal_1square_pushes & BitBoard::rank(2)) & empty_squares;
(parameters.push_shift)(&(legal_1square_pushes & BitBoard::rank(2))) & empty_squares;
self.pushes = legal_1square_pushes | legal_2square_pushes;
}
@ -146,7 +146,7 @@ impl<'pos> PawnMoveGenerator<'pos> {
for from_sq in bb.occupied_squares() {
let pawn: BitBoard = from_sq.into();
let push = (parameters.push_shift)(pawn);
let push = (parameters.push_shift)(&pawn);
if !(push & empty_squares).is_empty() {
let to_sq = push.occupied_squares().next().unwrap();
@ -161,7 +161,7 @@ impl<'pos> PawnMoveGenerator<'pos> {
}
if !(pawn & parameters.starting_rank).is_empty() {
let push = (parameters.push_shift)(push);
let push = (parameters.push_shift)(&push);
if !(push & empty_squares).is_empty() {
let to_sq = push.occupied_squares().next().unwrap();
self.quiet_move_list()
@ -171,8 +171,8 @@ impl<'pos> PawnMoveGenerator<'pos> {
}
for attack in [
(parameters.left_capture_shift)(pawn),
(parameters.right_capture_shift)(pawn),
(parameters.left_capture_shift)(&pawn),
(parameters.right_capture_shift)(&pawn),
] {
if !(attack & black_pieces).is_empty() {
let to_sq = attack.occupied_squares().next().unwrap();
@ -245,17 +245,13 @@ impl<'pos> Iterator for PawnMoveGenerator<'pos> {
#[cfg(test)]
mod tests {
use super::*;
use crate::piece::PlacedPiece;
use crate::position::DiagramFormatter;
use crate::{piece, Position, Square};
use std::collections::HashSet;
#[test]
fn one_2square_push() {
let mut pos = Position::empty();
pos.place_piece(piece!(White Pawn), Square::E2)
.expect("Failed to place pawn on e2");
let pos = position![White Pawn on E2];
let generator = PawnMoveGenerator::new(&pos, Color::White);
@ -271,10 +267,7 @@ mod tests {
#[test]
fn one_1square_push() {
let mut pos = Position::empty();
pos.place_piece(Piece::pawn(Color::White), Square::E3)
.expect("Failed to place pawn on e3");
let mut pos = position![White Pawn on E3];
let generator = PawnMoveGenerator::new(&pos, Color::White);
@ -292,12 +285,10 @@ mod tests {
#[test]
fn one_obstructed_2square_push() {
let mut pos = Position::empty();
pos.place_piece(Piece::pawn(Color::White), Square::E2)
.expect("Failed to place pawn on e2");
pos.place_piece(Piece::knight(Color::White), Square::E4)
.expect("Failed to place knight on e4");
let pos = position![
White Pawn on E2,
White Knight on E4,
];
println!("{}", DiagramFormatter::new(&pos));
@ -317,13 +308,10 @@ mod tests {
#[test]
fn one_obstructed_1square_push() {
let mut pos = Position::empty();
pos.place_piece(Piece::pawn(Color::White), Square::E2)
.expect("Failed to place pawn on e2");
pos.place_piece(Piece::knight(Color::White), Square::E3)
.expect("Failed to place knight on e4");
let mut pos = position![
White Pawn on E2,
White Knight on E3,
];
println!("{}", DiagramFormatter::new(&pos));
let generator = PawnMoveGenerator::new(&pos, Color::White);
@ -335,25 +323,21 @@ mod tests {
#[test]
fn one_attack() {
let mut pos = Position::empty();
pos.place_piece(Piece::pawn(Color::White), Square::E4)
.expect("Failed to place pawn on e4");
pos.place_piece(Piece::bishop(Color::White), Square::E5)
.expect("Failed to place pawn on e4");
pos.place_piece(Piece::knight(Color::Black), Square::D5)
.expect("Failed to place knight on d5");
let pos = position![
White Pawn on E4,
White Bishop on E5,
Black Knight on D5,
];
println!("{}", DiagramFormatter::new(&pos));
let generator = PawnMoveGenerator::new(&pos, Color::White);
let expected_moves = HashSet::from_iter([MoveBuilder::new(
Piece::pawn(Color::White),
Square::E4,
Square::D5,
)
.capturing(piece!(Black Knight on D5))
.build()]);
let expected_moves =
HashSet::from_iter(
[MoveBuilder::new(piece!(White Pawn), Square::E4, Square::D5)
.capturing(piece!(Black Knight on D5))
.build()],
);
let generated_moves: HashSet<Move> = generator.collect();
@ -362,16 +346,12 @@ mod tests {
#[test]
fn one_double_attack() {
let mut pos = Position::empty();
pos.place_piece(Piece::pawn(Color::White), Square::E4)
.expect("Failed to place pawn on e4");
pos.place_piece(Piece::bishop(Color::White), Square::E5)
.expect("Failed to place pawn on e4");
pos.place_piece(Piece::knight(Color::Black), Square::D5)
.expect("Failed to place knight on d5");
pos.place_piece(Piece::queen(Color::Black), Square::F5)
.expect("Failed to place knight on f5");
let pos = position![
White Pawn on E4,
White Bishop on E5,
Black Knight on D5,
Black Queen on F5,
];
println!("{}", DiagramFormatter::new(&pos));
let generator = PawnMoveGenerator::new(&pos, Color::White);

79
board/src/move_generator/queen.rs
View file

@ -66,27 +66,20 @@ impl<'pos> MoveGeneratorInternal for ClassicalMoveGenerator<'pos> {
#[cfg(test)]
mod tests {
use super::*;
use crate::{
piece::{Color, Piece},
position::DiagramFormatter,
BitBoard, Position, Square,
};
use crate::{piece, position, position::DiagramFormatter, BitBoard, Color};
#[test]
fn classical_single_queen_bitboard() {
let mut pos = Position::empty();
[(Piece::queen(Color::White), Square::A1)]
.into_iter()
.for_each(|(p, sq)| {
pos.place_piece(p, sq)
.expect(&format!("Unable to place {:?} on {}", &p, &sq))
});
let pos = position![White Queen on B2];
let generator = ClassicalMoveGenerator::new(&pos, Color::White);
let bitboard = generator.bitboard();
let expected = BitBoard::new(
0b10000001_01000001_00100001_00010001_00001001_00000101_00000011_11111110,
);
let expected = bitboard![
A2, C2, D2, E2, F2, G2, H2, // Rank
B1, B3, B4, B5, B6, B7, B8, // File
A1, C3, D4, E5, F6, G7, H8, // Diagonal
C1, A3 // Anti-diagonal
];
assert_eq!(
bitboard, expected,
@ -98,16 +91,10 @@ mod tests {
/// Test that a rook can move up to, but not onto, a friendly piece.
#[test]
fn classical_single_queen_with_same_color_blocker_bitboard() {
let mut pos = Position::empty();
[
(Piece::queen(Color::White), Square::A1),
(Piece::knight(Color::White), Square::E1),
]
.into_iter()
.for_each(|(p, sq)| {
pos.place_piece(p, sq)
.expect(&format!("Unable to place {} on {}", p, sq))
});
let pos = position![
White Queen on A1,
White Knight on E1,
];
println!("{}", DiagramFormatter::new(&pos));
@ -127,44 +114,40 @@ mod tests {
/// Test that a rook can move up to, and then capture, an enemy piece.
#[test]
fn classical_single_queen_with_opposing_color_blocker_bitboard() {
let mut pos = Position::empty();
[
(Piece::queen(Color::White), Square::A1),
(Piece::knight(Color::Black), Square::E5),
]
.into_iter()
.for_each(|(p, sq)| {
pos.place_piece(p, sq)
.expect(&format!("Unable to place {} on {}", p, sq))
});
let pos = position![
White Queen on B2,
Black Knight on E5,
];
println!("{}", DiagramFormatter::new(&pos));
let generator = ClassicalMoveGenerator::new(&pos, Color::White);
assert_eq!(
generator.bitboard(),
BitBoard::new(
0b00000001_00000001_00000001_00010001_00001001_00000101_00000011_11111110,
)
bitboard![
A2, C2, D2, E2, F2, G2, H2, // Rank
B1, B3, B4, B5, B6, B7, B8, // File
A1, C3, D4, E5, // Diagonal
C1, A3 // Anti-diagonal
]
);
}
#[test]
fn classical_single_queen_in_center() {
let mut pos = Position::empty();
[(Piece::queen(Color::White), Square::E4)]
.into_iter()
.for_each(|(p, sq)| {
pos.place_piece(p, sq)
.expect(&format!("Unable to place {} on {}", p, sq))
});
let pos = position![White Queen on D3];
println!("{}", DiagramFormatter::new(&pos));
let generator = ClassicalMoveGenerator::new(&pos, Color::White);
assert_eq!(
generator.bitboard(),
BitBoard::new(
0b00010001_10010010_01010100_00111000_11101111_00111000_01010100_10010010
)
bitboard![
A3, B3, C3, E3, F3, G3, H3, // Rank
D1, D2, D4, D5, D6, D7, D8, // File
B1, C2, E4, F5, G6, H7, // Diagonal
F1, E2, C4, B5, A6, // Anti-diagonal
]
);
}
}

61
board/src/move_generator/rook.rs
View file

@ -63,44 +63,29 @@ impl<'pos> MoveGeneratorInternal for ClassicalMoveGenerator<'pos> {
mod tests {
use super::*;
use crate::{
piece::{Color, Piece},
position::DiagramFormatter,
BitBoard, Position, Square,
piece::Piece, position, position::DiagramFormatter, BitBoard, Color, Position, Square,
};
#[test]
fn classical_single_rook_bitboard() {
let mut pos = Position::empty();
[(Piece::rook(Color::White), Square::A1)]
.into_iter()
.for_each(|(p, sq)| {
pos.place_piece(p, sq)
.expect(&format!("Unable to place {:?} on {}", &p, &sq))
});
let pos = position![White Rook on A2];
println!("{}", DiagramFormatter::new(&pos));
let generator = ClassicalMoveGenerator::new(&pos, Color::White);
assert_eq!(
generator.bitboard(),
BitBoard::new(
0b00000001_00000001_00000001_00000001_00000001_00000001_00000001_11111110
)
bitboard![A1, A3, A4, A5, A6, A7, A8, B2, C2, D2, E2, F2, G2, H2]
);
}
/// Test that a rook can move up to, but not onto, a friendly piece.
#[test]
fn classical_single_rook_with_same_color_blocker_bitboard() {
let mut pos = Position::empty();
[
(Piece::rook(Color::White), Square::A1),
(Piece::knight(Color::White), Square::E1),
]
.into_iter()
.for_each(|(p, sq)| {
pos.place_piece(p, sq)
.expect(&format!("Unable to place {} on {}", p, sq))
});
let mut pos = position![
White Rook on A1,
White Knight on E1,
];
println!("{}", DiagramFormatter::new(&pos));
@ -117,44 +102,28 @@ mod tests {
/// Test that a rook can move up to, and then capture, an enemy piece.
#[test]
fn classical_single_rook_with_opposing_color_blocker_bitboard() {
let mut pos = Position::empty();
[
(Piece::rook(Color::White), Square::A1),
(Piece::knight(Color::Black), Square::E1),
]
.into_iter()
.for_each(|(p, sq)| {
pos.place_piece(p, sq)
.expect(&format!("Unable to place {} on {}", p, sq))
});
let pos = position![
White Rook on A1,
Black Knight on E1,
];
let generator = ClassicalMoveGenerator::new(&pos, Color::White);
assert_eq!(
generator.bitboard(),
BitBoard::new(
0b00000001_00000001_00000001_00000001_00000001_00000001_00000001_00011110
)
bitboard![A2, A3, A4, A5, A6, A7, A8, B1, C1, D1, E1]
);
}
#[test]
fn classical_single_rook_in_center() {
let mut pos = Position::empty();
[(Piece::rook(Color::White), Square::E4)]
.into_iter()
.for_each(|(p, sq)| {
pos.place_piece(p, sq)
.expect(&format!("Unable to place {} on {}", p, sq))
});
let pos = position![White Rook on D4];
let generator = ClassicalMoveGenerator::new(&pos, Color::White);
assert_eq!(
generator.bitboard(),
BitBoard::new(
0b00010000_00010000_00010000_00010000_11101111_00010000_00010000_00010000
)
bitboard![A4, B4, C4, E4, F4, G4, H4, D1, D2, D3, D5, D6, D7, D8]
);
}
}