pub struct Board { /* private fields */ }
Expand description
A representation of a chess board. That’s why you’re here, right?
Implementations§
source§impl Board
impl Board
sourcepub fn from_fen(fen: String) -> Option<Board>
👎Deprecated since 3.1.0: please use Board::from_str(fen)?
instead
pub fn from_fen(fen: String) -> Option<Board>
Board::from_str(fen)?
insteadConstruct a board from a FEN string.
use candidate::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
sourcepub fn status(&self) -> BoardStatus
pub fn status(&self) -> BoardStatus
Is this game Ongoing, is it Stalemate, or is it Checkmate?
use candidate::{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);
sourcepub fn combined(&self) -> &BitBoard ⓘ
pub fn combined(&self) -> &BitBoard ⓘ
Grab the “combined” BitBoard
. This is a BitBoard
with every piece.
use candidate::{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);
sourcepub fn color_combined(&self, color: Color) -> &BitBoard ⓘ
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 candidate::{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);
sourcepub fn king_square(&self, color: Color) -> Square
pub fn king_square(&self, color: Color) -> Square
Give me the Square
the color
king is on.
use candidate::{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);
sourcepub fn pieces(&self, piece: Piece) -> &BitBoard ⓘ
pub fn pieces(&self, piece: Piece) -> &BitBoard ⓘ
Grab the “pieces” BitBoard
. This is a BitBoard
with every piece of a particular type.
use candidate::{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);
sourcepub fn castle_rights(&self, color: Color) -> CastleRights
pub fn castle_rights(&self, color: Color) -> CastleRights
Grab the CastleRights
for a particular side.
use candidate::{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);
sourcepub 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.
pub fn add_castle_rights(&mut self, color: Color, add: CastleRights)
Add castle rights for a particular side. Note: this can create an invalid position.
sourcepub 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.
pub fn remove_castle_rights(&mut self, color: Color, remove: CastleRights)
Remove castle rights for a particular side.
use candidate::{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);
sourcepub fn side_to_move(&self) -> Color
pub fn side_to_move(&self) -> Color
Who’s turn is it?
use candidate::{Board, Color};
let mut board = Board::default();
assert_eq!(board.side_to_move(), Color::White);
sourcepub fn my_castle_rights(&self) -> CastleRights
pub fn my_castle_rights(&self) -> CastleRights
Grab my CastleRights
.
use candidate::{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));
sourcepub 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.
pub fn add_my_castle_rights(&mut self, add: CastleRights)
Add to my CastleRights
. Note: This can make the position invalid.
sourcepub 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.
pub fn remove_my_castle_rights(&mut self, remove: CastleRights)
Remove some of my CastleRights
.
use candidate::{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);
sourcepub fn their_castle_rights(&self) -> CastleRights
pub fn their_castle_rights(&self) -> CastleRights
My opponents CastleRights
.
use candidate::{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));
sourcepub 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.
pub fn add_their_castle_rights(&mut self, add: CastleRights)
Add to my opponents CastleRights
. Note: This can make the position invalid.
sourcepub 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.
pub fn remove_their_castle_rights(&mut self, remove: CastleRights)
Remove some of my opponents CastleRights
.
use candidate::{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);
sourcepub 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.
pub fn set_piece(
&self,
piece: Piece,
color: Color,
square: Square
) -> Option<Board>
For a chess UI: set a piece on a particular square.
use candidate::{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);
sourcepub 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.
pub fn clear_square(&self, square: Square) -> Option<Board>
For a chess UI: clear a particular square.
use candidate::{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);
sourcepub fn null_move(&self) -> Option<Board>
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 candidate::{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);
sourcepub fn is_sane(&self) -> bool
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 candidate::{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);
sourcepub fn get_pawn_hash(&self) -> u64
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…
sourcepub fn piece_on(&self, square: Square) -> Option<Piece>
pub fn piece_on(&self, square: Square) -> Option<Piece>
What piece is on a particular Square
? Is there even one?
use candidate::{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);
sourcepub fn color_on(&self, square: Square) -> Option<Color>
pub fn color_on(&self, square: Square) -> Option<Color>
What color piece is on a particular square?
sourcepub fn en_passant(self) -> Option<Square>
pub fn en_passant(self) -> Option<Square>
Give me the en_passant square, if it exists.
use candidate::{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 en_passant_target(self) -> Option<Square>
sourcepub fn legal(&self, m: ChessMove) -> bool
pub fn legal(&self, m: ChessMove) -> bool
Is a particular move legal? This function is very slow, but will work on unsanitized input.
use candidate::{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 legal_destinations_from(&self, square: Square) -> BitBoard ⓘ
sourcepub fn make_move_new(&self, m: ChessMove) -> Board
pub fn make_move_new(&self, m: ChessMove) -> Board
Make a chess move onto a new board.
panic!() if king is captured.
use candidate::{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);
sourcepub fn make_move(&self, m: ChessMove, result: &mut Board)
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 candidate::{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);