Struct shakmaty::board::Board

pub struct Board { /* private fields */ }

Piece positions on a board.

Examples

use shakmaty::{Square, Board, Color::Black};

let board = Board::new();
// r n b q k b n r
// p p p p p p p p
// . . . . . . . .
// . . . . . . . .
// . . . . . . . .
// . . . . . . . .
// P P P P P P P P
// R N B Q K B N R

assert_eq!(board.piece_at(Square::E8), Some(Black.king()));

Implementations

impl Board

pub const fn new() -> Board

pub const fn empty() -> Board

pub fn from_bitboards( by_role: ByRole<Bitboard>, by_color: ByColor<Bitboard> ) -> Board

Creates a board from bitboard constituents.

Panics

Panics if the bitboards are inconsistent.

pub const fn into_bitboards(self) -> (ByRole<Bitboard>, ByColor<Bitboard>)

pub const fn racing_kings() -> Board

Available on crate feature variant only.

pub const fn horde() -> Board

Available on crate feature variant only.

pub const fn occupied(&self) -> Bitboard

pub const fn pawns(&self) -> Bitboard

pub const fn knights(&self) -> Bitboard

pub const fn bishops(&self) -> Bitboard

pub const fn rooks(&self) -> Bitboard

pub const fn queens(&self) -> Bitboard

pub const fn kings(&self) -> Bitboard

pub const fn white(&self) -> Bitboard

pub const fn black(&self) -> Bitboard

pub const fn sliders(&self) -> Bitboard

Bishops, rooks and queens.

pub const fn steppers(&self) -> Bitboard

Pawns, knights and kings.

pub const fn rooks_and_queens(&self) -> Bitboard

pub const fn bishops_and_queens(&self) -> Bitboard

pub const fn king_of(&self, color: Color) -> Option<Square>

The (unique!) king of the given side, if any.

pub fn color_at(&self, sq: Square) -> Option<Color>

pub fn role_at(&self, sq: Square) -> Option<Role>

pub fn piece_at(&self, sq: Square) -> Option<Piece>

pub fn remove_piece_at(&mut self, sq: Square) -> Option<Piece>

pub fn discard_piece_at(&mut self, sq: Square)

pub fn set_piece_at(&mut self, sq: Square, _: Piece)

pub const fn by_color(&self, color: Color) -> Bitboard

pub const fn by_role(&self, role: Role) -> Bitboard

pub const fn by_piece(&self, piece: Piece) -> Bitboard

pub fn attacks_from(&self, sq: Square) -> Bitboard

pub fn attacks_to( &self, sq: Square, attacker: Color, occupied: Bitboard ) -> Bitboard

pub fn material_side(&self, color: Color) -> ByRole<u8>

pub fn material(&self) -> ByColor<ByRole<u8>>

pub fn flip_vertical(&mut self)

Mirror the board vertically. See Bitboard::flip_vertical.

pub fn flip_horizontal(&mut self)

Mirror the board horizontally. See Bitboard::flip_horizontal.

pub fn flip_diagonal(&mut self)

Mirror the board at the a1-h8 diagonal. See Bitboard::flip_diagonal.

pub fn flip_anti_diagonal(&mut self)

Mirror the board at the h1-a8 diagonal. See Bitboard::flip_anti_diagonal.

pub fn rotate_90(&mut self)

Rotate the board 90 degrees clockwise. See Bitboard::rotate_90.

pub fn rotate_180(&mut self)

Rotate the board 180 degrees. See Bitboard::rotate_180.

pub fn rotate_270(&mut self)

Rotate the board 270 degrees clockwise. See Bitboard::rotate_270.

pub fn swap_colors(&mut self)

Makes black pieces white and vice versa.

pub fn pop_front(&mut self) -> Option<(Square, Piece)>

pub fn pop_back(&mut self) -> Option<(Square, Piece)>

impl Board

pub fn from_ascii_board_fen(board_fen: &[u8]) -> Result<Board, ParseFenError>

pub const fn board_fen(&self, promoted: Bitboard) -> BoardFen<'_>

Create a board FEN such as rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR.

Promoted pieces are marked like Q~.

Returns a BoardFen which implements Display.

Trait Implementations

impl Clone for Board

fn clone(&self) -> Board

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Board

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Board

fn default() -> Board

Returns the “default value” for a type.

impl Display for Board

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Extend<(Square, Piece)> for Board

fn extend<T: IntoIterator<Item = (Square, Piece)>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl FromIterator<(Square, Piece)> for Board

fn from_iter<T>(iter: T) -> Board

where T: IntoIterator<Item = (Square, Piece)>,

Creates a value from an iterator.

impl FromStr for Board

type Err = ParseFenError

The associated error which can be returned from parsing.

fn from_str(board_fen: &str) -> Result<Board, ParseFenError>

Parses a string s to return a value of this type.

impl Hash for Board

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl IntoIterator for Board

type IntoIter = IntoIter

Which kind of iterator are we turning this into?

type Item = (Square, Piece)

The type of the elements being iterated over.

fn into_iter(self) -> IntoIter

Creates an iterator from a value.

impl PartialEq for Board

fn eq(&self, other: &Board) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Board

impl StructuralPartialEq for Board