Struct bughouse::Board

pub struct Board { /* fields omitted */ }

A representation of a chess board. That’s why you’re here, right?

Implementations

impl Board

pub fn from_fen(fen: String) -> Option<Board>

👎 Deprecated since 3.1.0:

please use Board::from_str(fen)? instead

Construct a board from a FEN string.

use chess::Board;
use std::str::FromStr;


// This is no longer supported
let init_position = Board::from_fen("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1".to_owned()).expect("Valid FEN");
assert_eq!(init_position, Board::default());

// This is the new way
let init_position_2 = Board::from_str("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1")?;
assert_eq!(init_position_2, Board::default());

pub fn enumerate_moves(&self, moves: &mut [ChessMove; 256]) -> usize

👎 Deprecated since 3.0.0:

please use the MoveGen structure instead. It is faster and more idiomatic.

pub fn status(&self) -> BoardStatus

Is this game Ongoing, is it Stalemate, or is it Checkmate?

use chess::{Board, BoardStatus, Square, ChessMove};

let mut board = Board::default();

assert_eq!(board.status(), BoardStatus::Ongoing);

board = board.make_move_new(ChessMove::new(Square::E2,
                                           Square::E4,
                                           None));

assert_eq!(board.status(), BoardStatus::Ongoing);

board = board.make_move_new(ChessMove::new(Square::F7,
                                           Square::F6,
                                           None));

assert_eq!(board.status(), BoardStatus::Ongoing);

board = board.make_move_new(ChessMove::new(Square::D2,
                                           Square::D4,
                                           None));

assert_eq!(board.status(), BoardStatus::Ongoing);

board = board.make_move_new(ChessMove::new(Square::G7,
                                           Square::G5,
                                           None));

assert_eq!(board.status(), BoardStatus::Ongoing);

board = board.make_move_new(ChessMove::new(Square::D1,
                                           Square::H5,
                                           None));

assert_eq!(board.status(), BoardStatus::Checkmate);

pub fn combined(&self) -> &BitBoard

Grab the “combined” BitBoard. This is a BitBoard with every piece.

use chess::{Board, BitBoard, Rank, get_rank};

let board = Board::default();

let combined_should_be = get_rank(Rank::First) |
                         get_rank(Rank::Second) |
                         get_rank(Rank::Seventh) |
                         get_rank(Rank::Eighth);

assert_eq!(*board.combined(), combined_should_be);

pub fn color_combined(&self, color: Color) -> &BitBoard

Grab the “color combined” BitBoard. This is a BitBoard with every piece of a particular color.

use chess::{Board, BitBoard, Rank, get_rank, Color};

let board = Board::default();

let white_pieces = get_rank(Rank::First) |
                   get_rank(Rank::Second);

let black_pieces = get_rank(Rank::Seventh) |
                   get_rank(Rank::Eighth);

assert_eq!(*board.color_combined(Color::White), white_pieces);
assert_eq!(*board.color_combined(Color::Black), black_pieces);

pub fn king_square(&self, color: Color) -> Square

Give me the Square the color king is on.

use chess::{Board, Square, Color};

let board = Board::default();

assert_eq!(board.king_square(Color::White), Square::E1);
assert_eq!(board.king_square(Color::Black), Square::E8);

pub fn pieces(&self, piece: Piece) -> &BitBoard

Grab the “pieces” BitBoard. This is a BitBoard with every piece of a particular type.

use chess::{Board, BitBoard, Piece, Square};

// The rooks should be in each corner of the board
let rooks = BitBoard::from_square(Square::A1) |
            BitBoard::from_square(Square::H1) |
            BitBoard::from_square(Square::A8) |
            BitBoard::from_square(Square::H8);

let board = Board::default();

assert_eq!(*board.pieces(Piece::Rook), rooks);

pub fn castle_rights(&self, color: Color) -> CastleRights

Grab the CastleRights for a particular side.

use chess::{Board, Square, CastleRights, Color, ChessMove};

let move1 = ChessMove::new(Square::A2,
                           Square::A4,
                           None);

let move2 = ChessMove::new(Square::E7,
                           Square::E5,
                           None);

let move3 = ChessMove::new(Square::A1,
                           Square::A2,
                           None);

let move4 = ChessMove::new(Square::E8,
                           Square::E7,
                           None);

let mut board = Board::default();

assert_eq!(board.castle_rights(Color::White), CastleRights::Both);
assert_eq!(board.castle_rights(Color::Black), CastleRights::Both);

board = board.make_move_new(move1)
             .make_move_new(move2)
             .make_move_new(move3)
             .make_move_new(move4);

assert_eq!(board.castle_rights(Color::White), CastleRights::KingSide);
assert_eq!(board.castle_rights(Color::Black), CastleRights::NoRights);

pub fn add_castle_rights(&mut self, color: Color, add: CastleRights)

👎 Deprecated since 3.1.0:

When doing board setup, use the BoardBuilder structure. It ensures you don’t end up with an invalid position.

Add castle rights for a particular side. Note: this can create an invalid position.

pub fn remove_castle_rights(&mut self, color: Color, remove: CastleRights)

👎 Deprecated since 3.1.0:

When doing board setup, use the BoardBuilder structure. It ensures you don’t end up with an invalid position.

Remove castle rights for a particular side.

use chess::{Board, CastleRights, Color};

let mut board = Board::default();
assert_eq!(board.castle_rights(Color::White), CastleRights::Both);

board.remove_castle_rights(Color::White, CastleRights::KingSide);
assert_eq!(board.castle_rights(Color::White), CastleRights::QueenSide);

pub fn side_to_move(&self) -> Color

Who’s turn is it?

use chess::{Board, Color};

let mut board = Board::default();
assert_eq!(board.side_to_move(), Color::White);

pub fn my_castle_rights(&self) -> CastleRights

Grab my CastleRights.

use chess::{Board, Color, CastleRights};

let mut board = Board::default();
board.remove_castle_rights(Color::White, CastleRights::KingSide);
board.remove_castle_rights(Color::Black, CastleRights::QueenSide);

assert_eq!(board.my_castle_rights(), board.castle_rights(Color::White));

pub fn add_my_castle_rights(&mut self, add: CastleRights)

👎 Deprecated since 3.1.0:

When doing board setup, use the BoardBuilder structure. It ensures you don’t end up with an invalid position.

Add to my CastleRights. Note: This can make the position invalid.

pub fn remove_my_castle_rights(&mut self, remove: CastleRights)

👎 Deprecated since 3.1.0:

When doing board setup, use the BoardBuilder structure. It ensures you don’t end up with an invalid position.

Remove some of my CastleRights.

use chess::{Board, CastleRights};

let mut board = Board::default();
assert_eq!(board.my_castle_rights(), CastleRights::Both);

board.remove_my_castle_rights(CastleRights::KingSide);
assert_eq!(board.my_castle_rights(), CastleRights::QueenSide);

pub fn their_castle_rights(&self) -> CastleRights

My opponents CastleRights.

use chess::{Board, Color, CastleRights};

let mut board = Board::default();
board.remove_castle_rights(Color::White, CastleRights::KingSide);
board.remove_castle_rights(Color::Black, CastleRights::QueenSide);

assert_eq!(board.their_castle_rights(), board.castle_rights(Color::Black));

pub fn add_their_castle_rights(&mut self, add: CastleRights)

👎 Deprecated since 3.1.0:

When doing board setup, use the BoardBuilder structure. It ensures you don’t end up with an invalid position.

Add to my opponents CastleRights. Note: This can make the position invalid.

pub fn remove_their_castle_rights(&mut self, remove: CastleRights)

👎 Deprecated since 3.1.0:

When doing board setup, use the BoardBuilder structure. It ensures you don’t end up with an invalid position.

Remove some of my opponents CastleRights.

use chess::{Board, CastleRights};

let mut board = Board::default();
assert_eq!(board.their_castle_rights(), CastleRights::Both);

board.remove_their_castle_rights(CastleRights::KingSide);
assert_eq!(board.their_castle_rights(), CastleRights::QueenSide);

pub fn set_piece(
    &self,
    piece: Piece,
    color: Color,
    square: Square
) -> Option<Board>

👎 Deprecated since 3.1.0:

When doing board setup, use the BoardBuilder structure. It ensures you don’t end up with an invalid position.

For a chess UI: set a piece on a particular square.

use chess::{Board, Piece, Color, Square};

let board = Board::default();

let new_board = board.set_piece(Piece::Queen,
                                Color::White,
                                Square::E4)
                     .expect("Valid Position");

assert_eq!(new_board.pieces(Piece::Queen).count(), 3);

pub fn clear_square(&self, square: Square) -> Option<Board>

👎 Deprecated since 3.1.0:

When doing board setup, use the BoardBuilder structure. It ensures you don’t end up with an invalid position.

For a chess UI: clear a particular square.

use chess::{Board, Square, Piece};

let board = Board::default();

let new_board = board.clear_square(Square::A1)
                     .expect("Valid Position");

assert_eq!(new_board.pieces(Piece::Rook).count(), 3);

pub fn null_move(&self) -> Option<Board>

Switch the color of the player without actually making a move. Returns None if the current player is in check.

Note that this erases the en-passant information, so applying this function twice does not always give the same result back.

use chess::{Board, Color};

let board = Board::default();

assert_eq!(board.side_to_move(), Color::White);

let new_board = board.null_move().expect("Valid Position");

assert_eq!(new_board.side_to_move(), Color::Black);

pub fn is_sane(&self) -> bool

Does this board “make sense”? Do all the pieces make sense, do the bitboards combine correctly, etc? This is for sanity checking.

use chess::{Board, Color, Piece, Square};

let board = Board::default();

assert_eq!(board.is_sane(), true);

// Remove the king
let bad_board = board.clear_square(Square::E1).expect("Valid Position");
assert_eq!(bad_board.is_sane(), false);

pub fn get_hash(&self) -> u64

Get a hash of the board.

pub fn get_pawn_hash(&self) -> u64

Get a pawn hash of the board (a hash that only changes on color change and pawn moves).

Currently not implemented…

pub fn piece_on(&self, square: Square) -> Option<Piece>

What piece is on a particular Square? Is there even one?

use chess::{Board, Piece, Square};

let board = Board::default();

assert_eq!(board.piece_on(Square::A1), Some(Piece::Rook));
assert_eq!(board.piece_on(Square::D4), None);

pub fn color_on(&self, square: Square) -> Option<Color>

What color piece is on a particular square?

pub fn en_passant(self) -> Option<Square>

Give me the en_passant square, if it exists.

use chess::{Board, ChessMove, Square};

let move1 = ChessMove::new(Square::D2,
                           Square::D4,
                           None);

let move2 = ChessMove::new(Square::H7,
                           Square::H5,
                           None);

let move3 = ChessMove::new(Square::D4,
                           Square::D5,
                           None);

let move4 = ChessMove::new(Square::E7,
                           Square::E5,
                           None);

let board = Board::default().make_move_new(move1)
                            .make_move_new(move2)
                            .make_move_new(move3)
                            .make_move_new(move4);

assert_eq!(board.en_passant(), Some(Square::E5));

pub fn legal(&self, m: ChessMove) -> bool

Is a particular move legal? This function is very slow, but will work on unsanitized input.

use chess::{Board, ChessMove, Square, MoveGen};

let move1 = ChessMove::new(Square::E2,
                           Square::E4,
                           None);

let move2 = ChessMove::new(Square::E2,
                           Square::E5,
                           None);

let board = Board::default();

assert_eq!(board.legal(move1), true);
assert_eq!(board.legal(move2), false);

pub fn make_move_new(&self, m: ChessMove) -> Board

Make a chess move onto a new board.

panic!() if king is captured.

use chess::{Board, ChessMove, Square, Color};

let m = ChessMove::new(Square::D2,
                       Square::D4,
                       None);

let board = Board::default();
assert_eq!(board.make_move_new(m).side_to_move(), Color::Black);

pub fn make_move(&self, m: ChessMove, result: &mut Board)

Make a chess move onto an already allocated Board.

panic!() if king is captured.

use chess::{Board, ChessMove, Square, Color};

let m = ChessMove::new(Square::D2,
                       Square::D4,
                       None);

let board = Board::default();
let mut result = Board::default();
board.make_move(m, &mut result);
assert_eq!(result.side_to_move(), Color::Black);

pub fn pinned(&self) -> &BitBoard

Give me the BitBoard of my pinned pieces.

pub fn checkers(&self) -> &BitBoard

Give me the Bitboard of the pieces putting me in check.

Trait Implementations

impl Clone for Board

pub 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

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

Formats the value using the given formatter.

impl Default for Board

Construct the initial position.

pub fn default() -> Board

Returns the “default value” for a type.

impl Display for Board

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

Formats the value using the given formatter.

impl<'_> From<&'_ Board> for BoardBuilder

pub fn from(board: &Board) -> BoardBuilder

Performs the conversion.

impl From<Board> for BoardBuilder

pub fn from(board: Board) -> BoardBuilder

Performs the conversion.

impl FromStr for Board

type Err = Error

The associated error which can be returned from parsing.

pub fn from_str(value: &str) -> Result<Board, <Board as FromStr>::Err>

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

impl Hash for Board

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl PartialEq<Board> for Board

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

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

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

This method tests for !=.

impl<'_> TryFrom<&'_ BoardBuilder> for Board

type Error = Error

The type returned in the event of a conversion error.

pub fn try_from(
    fen: &BoardBuilder
) -> Result<Board, <Board as TryFrom<&'_ BoardBuilder>>::Error>

Performs the conversion.

impl<'_> TryFrom<&'_ mut BoardBuilder> for Board

type Error = Error

The type returned in the event of a conversion error.

pub fn try_from(
    fen: &mut BoardBuilder
) -> Result<Board, <Board as TryFrom<&'_ mut BoardBuilder>>::Error>

Performs the conversion.

impl TryFrom<BoardBuilder> for Board

type Error = Error

The type returned in the event of a conversion error.

pub fn try_from(
    fen: BoardBuilder
) -> Result<Board, <Board as TryFrom<BoardBuilder>>::Error>

Performs the conversion.

impl Copy for Board

impl Eq for Board

impl StructuralEq for Board

impl StructuralPartialEq for Board