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

[board] Implement BitAnd and BitOr on BitBoard and make it's u64 private

Browse source
This commit is contained in:
Eryn Wells 2023-12-22 08:50:03 -08:00
parent aa7e901241
commit 6af64171a2
2 changed files with 69 additions and 28 deletions
Download patch file Download diff file Expand all files Collapse all files

43
board/src/bitboard.rs
View file

@ -2,11 +2,20 @@
use crate::square::Square; use crate::square::Square;
use std::arch::asm; use std::arch::asm;
use std::ops::{BitAnd, BitOr};
#[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] #[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct BitBoard(pub u64); pub struct BitBoard(u64);
impl BitBoard { impl BitBoard {
pub fn empty() -> BitBoard {
BitBoard(0)
}
pub fn from_bit_field(bits: u64) -> BitBoard {
BitBoard(bits)
}
fn is_empty(&self) -> bool { fn is_empty(&self) -> bool {
self.0 == 0 self.0 == 0
} }
@ -38,6 +47,38 @@ impl BitBoard {
} }
} }
impl BitAnd for BitBoard {
type Output = BitBoard;
fn bitand(self, rhs: Self) -> Self {
BitBoard(self.0 & rhs.0)
}
}
impl BitAnd<&BitBoard> for BitBoard {
type Output = BitBoard;
fn bitand(self, rhs: &Self) -> Self {
BitBoard(self.0 & rhs.0)
}
}
impl BitOr for BitBoard {
type Output = BitBoard;
fn bitor(self, rhs: Self) -> Self {
BitBoard(self.0 | rhs.0)
}
}
impl BitOr<&BitBoard> for BitBoard {
type Output = BitBoard;
fn bitor(self, rhs: &Self) -> Self {
BitBoard(self.0 | rhs.0)
}
}
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use super::*;

54
board/src/position.rs
View file

@ -29,23 +29,23 @@ pub struct Position {
impl Position { impl Position {
fn empty() -> Position { fn empty() -> Position {
Position { Position {
pieces_per_color: [BitBoard(0), BitBoard(0)], pieces_per_color: [BitBoard::empty(), BitBoard::empty()],
pieces_per_type: [ pieces_per_type: [
[ [
BitBoard(0), BitBoard::empty(),
BitBoard(0), BitBoard::empty(),
BitBoard(0), BitBoard::empty(),
BitBoard(0), BitBoard::empty(),
BitBoard(0), BitBoard::empty(),
BitBoard(0), BitBoard::empty(),
], ],
[ [
BitBoard(0), BitBoard::empty(),
BitBoard(0), BitBoard::empty(),
BitBoard(0), BitBoard::empty(),
BitBoard(0), BitBoard::empty(),
BitBoard(0), BitBoard::empty(),
BitBoard(0), BitBoard::empty(),
], ],
], ],
} }
@ -54,27 +54,27 @@ impl Position {
/// Return a starting position. /// Return a starting position.
fn starting() -> Position { fn starting() -> Position {
let white_pieces = [ let white_pieces = [
BitBoard(0x00FF000000000000), BitBoard::from_bit_field(0x00FF000000000000),
BitBoard(0x4200000000000000), BitBoard::from_bit_field(0x4200000000000000),
BitBoard(0x2400000000000000), BitBoard::from_bit_field(0x2400000000000000),
BitBoard(0x8100000000000000), BitBoard::from_bit_field(0x8100000000000000),
BitBoard(0x1000000000000000), BitBoard::from_bit_field(0x1000000000000000),
BitBoard(0x8000000000000000), BitBoard::from_bit_field(0x8000000000000000),
]; ];
let black_pieces = [ let black_pieces = [
BitBoard(0xFF00), BitBoard::from_bit_field(0xFF00),
BitBoard(0x0042), BitBoard::from_bit_field(0x0042),
BitBoard(0x0024), BitBoard::from_bit_field(0x0024),
BitBoard(0x0081), BitBoard::from_bit_field(0x0081),
BitBoard(0x0010), BitBoard::from_bit_field(0x0010),
BitBoard(0x0080), BitBoard::from_bit_field(0x0080),
]; ];
Position { Position {
pieces_per_color: [ pieces_per_color: [
BitBoard(white_pieces.iter().map(|bb| bb.0).fold(0, |a, b| a | b)), white_pieces.iter().fold(BitBoard::empty(), |a, b| a | b),
BitBoard(black_pieces.iter().map(|bb| bb.0).fold(0, |a, b| a | b)), black_pieces.iter().fold(BitBoard::empty(), |a, b| a | b),
], ],
pieces_per_type: [white_pieces, black_pieces], pieces_per_type: [white_pieces, black_pieces],
} }