Struct pleco::board::Board

pub struct Board { /* fields omitted */ }

Represents a Chessboard through a Board.

Board contains everything that needs to be known about the current state of the Game. It is used by both Engines and Players / Bots alike.

Ideally, the Engine contains the original Representation of a board (owns the board), and utilizes Board::shallow_clone() to share this representaion with Players.

Examples

use pleco::Board;

fn main() {
    let mut chessboard = Board::default();

    let moves = chessboard.generate_moves();
    chessboard.apply_move(moves[0]);

    let b2 = chessboard.shallow_clone(); // boards allow for easy cloning
    assert_eq!(chessboard.moves_played(), b2.moves_played());
}

BitBoard Representation

For the majority of the struct, the board utilizes [BitBoard]s, which is a u64 where each bit represents an occupied location, and each bit index represents a certain square (as in bit 0 is Square A1, bit 1 is B1, etc.). Indexes increase first horizontally by File, and then by Rank. See BitBoards article ChessWiki for more information.

The exact mapping from each square to bits is as follows:

8 | 56 57 58 59 60 61 62 63
7 | 48 49 50 51 52 53 54 55
6 | 40 41 42 43 44 45 46 47
5 | 32 33 34 35 36 37 38 39
4 | 24 25 26 27 28 29 30 31
3 | 16 17 18 19 20 21 22 23
2 | 8  9  10 11 12 13 14 15
1 | 0  1  2  3  4  5  6  7
  -------------------------
     a  b  c  d  e  f  g  h

Methods

impl Board

fn default() -> Board

Constructs a board from the starting position

Examples

use pleco::{Board,Player};

let chessboard = Board::default();
assert_eq!(chessboard.count_pieces_player(Player::White),16);

fn shallow_clone(&self) -> Board

Constructs a shallow clone of the Board.

Contains only the information necessary to apply future moves, more specifically does not clone the moves list, and sets depth to zero. Intended for an Engine or main thread to share the board to users wanting to search.

Safety

After this method has called, [Board::undo_move()] cannot be called immediately after. Undoing moves can only be done once a move has been played, and cannot be called more times than moves have been played since calling [Board::shallow_clone()].

Examples

use pleco::Board;

let mut chessboard = Board::default();
let moves = chessboard.generate_moves(); // generate all possible legal moves
chessboard.apply_move(moves[0]); // apply first move

assert_eq!(chessboard.moves_played(), 1);

let board_clone = chessboard.shallow_clone();
assert_eq!(chessboard.moves_played(), board_clone.moves_played());

assert_ne!(chessboard.depth(),board_clone.depth()); // different depths

fn parallel_clone(&self) -> Board

Constructs a parallel clone of the Board.

Similar to [Board::shallow_clone()], but keeps the current search depth the same. Should be used when implementing a searcher, and want to search a list of moves in parallel with different threads.

Safety

After this method has called, [Board::undo_move()] cannot be called immediately after. Undoing moves can only be done once a move has been played, and cannot be called more times than moves have been played since calling [Board::parallel_clone()].

Examples

use pleco::Board;

let mut chessboard = Board::default();
let moves = chessboard.generate_moves(); // generate all possible legal moves
chessboard.apply_move(moves[0]);
assert_eq!(chessboard.moves_played(), 1);

let board_clone = chessboard.parallel_clone();
assert_eq!(chessboard.moves_played(), board_clone.moves_played());

assert_eq!(chessboard.depth(),board_clone.depth()); // different depths

fn random() -> RandBoard

Creates a RandBoard (Random Board Generator) for generation of Boards with random positions. See the RandBoard structure for more information.

Examples

Create one Board with at least 5 moves played that is created in a pseudo-random fashion.

use pleco::Board;
let rand_boards: Board = Board::random()
    .pseudo_random(12455)
    .min_moves(5)
    .one();

Create a Vec of 10 random Boards that are guaranteed to not be in check.

use pleco::board::{Board,RandBoard};

let rand_boards: Vec<Board> = Board::random()
    .pseudo_random(12455)
    .no_check()
    .many(10);

fn new_from_fen(fen: &str) -> Result<Board, FenBuildError>

Constructs a board from a FEN String.

FEN stands for Forsyth-Edwards Notation, and is a way of representing a board through a string of characters. More information can be found on the ChessWiki.

Examples

use pleco::Board;

let board = Board::new_from_fen("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1").unwrap();
assert_eq!(board.count_all_pieces(),32);

Panics

The FEN string must be valid, or else the method will panic.

There is a possibility of the FEN string representing an unvalid position, with no panics resulting. The Constructed Board may have some Undefined Behavior as a result. It is up to the user to give a valid FEN string.

fn get_fen(&self) -> String

Creates a FEN String of the Given Board.

FEN stands for Forsyth-Edwards Notation, and is a way of representing a board through a string of characters. More information can be found on the ChessWiki.

Examples

use pleco::Board;

let board = Board::default();
assert_eq!(board.get_fen(),"rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1");

fn apply_move(&mut self, bit_move: BitMove)

Applies a move to the Board.

Safety

The passed in [BitMove] must be a legal move for the current position.

Panics

The supplied BitMove must be both a valid move for that position, as well as a valid [BitMove], Otherwise, a panic will occur. Valid BitMoves can be generated with [Board::generate_moves()], which guarantees that only Legal moves will be created.

fn apply_unknown_move(&mut self, bit_move: BitMove, gives_check: bool)

Applies a move to the Board. This method is only useful if before a move is applied to a board, the ability of the move to give check is applied. If it is not needed to know if the move gives check or not, consider using Board::apply_move instead.

Safety

The passed in [BitMove] must be a legal move for the current position.

Panics

The supplied BitMove must be both a valid move for that position, as well as a valid [BitMove], Otherwise, a panic will occur. Valid BitMoves can be generated with [Board::generate_moves()], which guarantees that only Legal moves will be created.

The second parameter, gives_check, must be true if the move gives check, or false if the move doesn't give check. If an incorrect gives_check is supplied, undefined behavior will follow.

fn apply_uci_move(&mut self, uci_move: &str) -> bool

Applies a UCI move to the board. If the move is a valid string representing a UCI move, then true will be returned & the move will be applied. Otherwise, false is returned and the board isn't changed.

Examples

use pleco::Board;

let mut board = Board::default();
let success = board.apply_uci_move("e2e4");

assert!(success);

fn undo_move(&mut self)

Un-does the previously applied move, allowing the Board to return to it's most recently held state.

Panics

Cannot be done if after any Board::shallow_clone() has been applied, or if Board::parallel_clone() has been done and there is no previous move.

Examples

use pleco::Board;

let mut chessboard = Board::default();

let moves = chessboard.generate_moves();
chessboard.apply_move(moves[0]);

let mut board_clone = chessboard.shallow_clone();

chessboard.undo_move(); // works, chessboard existed before the move was played
board_clone.undo_move(); // error: board_clone was created after the move was applied

unsafe fn apply_null_move(&mut self)

Apply a "Null Move" to the board, essentially swapping the current turn of the board without moving any pieces.

Safety

This method should only be used for special evaluation purposes, as it does not give an accurate or legal state of the chess board.

Unsafe as it allows for Null Moves to be applied in states of check, which is never a valid state of a chess game.

Panics

Panics if the Board is currently in check.

Examples

use pleco::board::*;

let mut chessboard = Board::default();
let board_clone = chessboard.shallow_clone();

unsafe { chessboard.apply_null_move(); }

assert_ne!(chessboard.depth(), board_clone.depth());

unsafe fn undo_null_move(&mut self)

Undo a "Null Move" to the Board, returning to the previous state.

Safety

This method should only be used if it can be guaranteed that the last played move from the current state is a Null-Move, eg Board::apply_null_move(). Otherwise, a panic will occur.

Examples

use pleco::board::*;

let mut chessboard = Board::default();
let board_clone = chessboard.shallow_clone();

unsafe { chessboard.apply_null_move(); }

assert_ne!(chessboard.ply(), board_clone.ply());

unsafe { chessboard.undo_null_move(); }

assert_eq!(chessboard.moves_played(), board_clone.moves_played());
assert_eq!(chessboard.get_fen(), board_clone.get_fen());

fn generate_moves(&self) -> MoveList

Get a List of legal BitMoves for the player whose turn it is to move.

This method already takes into account if the Board is currently in check, and will return legal moves only.

Examples

use pleco::Board;

let chessboard = Board::default();
let moves = chessboard.generate_moves();

println!("There are {} possible legal moves.", moves.len());

fn generate_pseudolegal_moves(&self) -> MoveList

Get a List of all PseudoLegal BitMoves for the player whose turn it is to move. Works exactly the same as Board::generate_moves(), but doesn't guarantee that all the moves are legal for the current position. Moves need to be checked with a Board::legal_move(move) in order to be certain of a legal move.

fn generate_moves_of_type(&self, gen_type: GenTypes) -> MoveList

Get a List of legal BitMoves for the player whose turn it is to move and of a certain type.

This method already takes into account if the Board is currently in check, and will return legal moves only. If a non-ALL GenTypes is supplied, only a subset of the total moves will be given.

Panics

Panics if given GenTypes::QuietChecks while the current board is in check

Examples

use pleco::board::*;
use pleco::core::GenTypes;

let chessboard = Board::default();
let capturing_moves = chessboard.generate_moves_of_type(GenTypes::Captures);

assert_eq!(capturing_moves.len(), 0); // no possible captures for the starting position

fn generate_pseudolegal_moves_of_type(&self, gen_type: GenTypes) -> MoveList

Get a List of all PseudoLegal BitMoves for the player whose turn it is to move. Works exactly the same as Board::generate_moves(), but doesn't guarantee that all the moves are legal for the current position. Moves need to be checked with a Board::legal_move(move) in order to be certain of a legal move.

This method already takes into account if the Board is currently in check. If a non-ALL GenType is supplied, only a subset of the total moves will be given.

Panics

Panics if given GenTypes::QuietChecks while the current board is in check

impl Board

fn turn(&self) -> Player

Get the Player whose turn it is to move.

Examples

use pleco::{Board,Player};

let chessboard = Board::default();
assert_eq!(chessboard.turn(), Player::White);

fn zobrist(&self) -> u64

Return the Zobrist Hash of the board.

fn moves_played(&self) -> u16

Get the total number of moves played.

Examples

use pleco::Board;

let mut chessboard = Board::default();
assert_eq!(chessboard.moves_played(), 0);

let moves = chessboard.generate_moves();
chessboard.apply_move(moves[0]);
assert_eq!(chessboard.moves_played(), 1);

fn depth(&self) -> u16

Get the current depth (half moves from a [Board::shallow_clone()].

fn rule_50(&self) -> i16

Get the number of half-moves since a Pawn Push, castle, or capture.

fn piece_captured_last_turn(&self) -> Option<Piece>

Return the Piece, if any, that was last captured.

fn magic_helper(&self) -> &'static MagicHelper

Get a reference to the MagicHelper pre-computed BitBoards.

fn ply(&self) -> u16

Get the current ply of the board.

fn ep_square(&self) -> SQ

Get the current square of en_passant.

If the current en-passant square is none, it should return 64.

fn get_occupied(&self) -> BitBoard

Gets the BitBoard of all pieces.

Examples

use pleco::{Board,BitBoard};

let chessboard = Board::default();
assert_eq!(chessboard.get_occupied().0, 0xFFFF00000000FFFF);

fn get_occupied_player(&self, player: Player) -> BitBoard

Get the BitBoard of the squares occupied by the given player.

Examples

use pleco::{Board,Player,BitBoard};

let chessboard = Board::default();
assert_eq!(chessboard.get_occupied_player(Player::White).0, 0x000000000000FFFF);

fn occupied_white(&self) -> BitBoard

Returns a Bitboard consisting of only the squares occupied by the White Player.

fn occupied_black(&self) -> BitBoard

Returns a BitBoard consisting of only the squares occupied by the Black Player.

fn piece_bb(&self, player: Player, piece: Piece) -> BitBoard

Returns BitBoard of a single player and that one type of piece.

Examples

use pleco::Board;
use pleco::{Player,Piece};

let chessboard = Board::default();
assert_eq!(chessboard.piece_bb(Player::White,Piece::P).0, 0x000000000000FF00);

fn sliding_piece_bb(&self, player: Player) -> BitBoard

Returns the BitBoard of the Queens and Rooks of a given player.

Examples

use pleco::{Board,Player,BitBoard};
use pleco::core::bit_twiddles::*;

let chessboard = Board::default();
assert_eq!(chessboard.sliding_piece_bb(Player::White).count_bits(), 3);

fn diagonal_piece_bb(&self, player: Player) -> BitBoard

Returns the BitBoard of the Queens and Bishops of a given player.

Examples

use pleco::{Board,Player,BitBoard};
use pleco::core::bit_twiddles::*;

let chessboard = Board::default();
assert_eq!(chessboard.diagonal_piece_bb(Player::White).count_bits(), 3);

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

Returns the combined BitBoard of both players for a given piece.

Examples

use pleco::{Board,Piece};

let chessboard = Board::default();
assert_eq!(chessboard.piece_bb_both_players(Piece::P).0, 0x00FF00000000FF00);

fn piece_two_bb_both_players(&self, piece: Piece, piece2: Piece) -> BitBoard

Returns the combined BitBoard of both players for two pieces.

Examples

use pleco::{Board,Piece,BitBoard};
use pleco::core::bit_twiddles::*;

let chessboard = Board::default();
assert_eq!(chessboard.piece_two_bb_both_players(Piece::Q,Piece::K).count_bits(), 4);

fn piece_two_bb(&self, piece: Piece, piece2: Piece, player: Player) -> BitBoard

Returns the BitBoard containing the locations of two given types of pieces for the given player.

fn count_piece(&self, player: Player, piece: Piece) -> u8

Get the total number of pieces of the given piece and player.

Examples

use pleco::{Board,Player,Piece};

let chessboard = Board::default();
assert_eq!(chessboard.count_piece(Player::White, Piece::P), 8);

fn count_pieces_player(&self, player: Player) -> u8

Get the total number of pieces a given player has.

Examples

use pleco::{Board,Player,Piece};
use pleco::core::bit_twiddles::*;

let chessboard = Board::default();
assert_eq!(chessboard.count_pieces_player(Player::White), 16);

fn count_all_pieces(&self) -> u8

Get the total number of pieces on the board.

Examples

use pleco::{Board,Player,Piece};
use pleco::core::bit_twiddles::*;

let chessboard = Board::default();
assert_eq!(chessboard.count_all_pieces(), 32);

fn piece_at_sq(&self, sq: SQ) -> Option<Piece>

Returns the Piece, if any, at the square.

Panics

Panics if the square is not a legal square.

fn color_of_sq(&self, sq: SQ) -> Option<Player>

Returns the Player, if any, occupying a square.

Panics

Panics if the square is not a legal square.

fn player_at_sq(&self, s: SQ) -> Option<Player>

Returns the player, if any, at the square.

fn king_sq(&self, player: Player) -> SQ

Returns the square of the King for a given player.

fn pinned_pieces(&self, player: Player) -> BitBoard

Returns the pinned pieces of the given player.

Pinned is defined as pinned to the same players king

fn all_pinned_pieces(&self, player: Player) -> BitBoard

Returns the pinned pieces for a given players king. Can contain piece of from both players, but all are guaranteed to be pinned to the given player's king.

fn pinning_pieces(&self, player: Player) -> BitBoard

Returns the pinning pieces of a given player. e.g, pieces that are pinning a piece to the opponent's king. This will return the pinned pieces of both players, pinned to the given player's king.

fn can_castle(&self, player: Player, castle_type: CastleType) -> bool

Return if a player has the possibility of castling for a given CastleType. This does not ensure a castling is possible for the player, just that the player has the castling-right available.

fn castle_impeded(&self, castle_type: CastleType) -> bool

Check if the castle path is impeded for the current player. Does not assume that the current player has the ability to castle, whether by having the castling-rights to, or having the rook and king be in the correct square.

fn castling_rook_square(&self, castle_type: CastleType) -> SQ

Square of the Rook that is involved with the current player's castle.

fn last_move(&self) -> Option<BitMove>

Return the last move played, if any.

fn has_castled(&self, player: Player) -> bool

Returns if the current player has castled ever.

fn piece_last_captured(&self) -> Option<Piece>

Returns if the piece (if any) that was captured last move. This method does not distinguish between not having any last move played and not having a piece last captured.

fn in_check(&self) -> bool

Returns if current side to move is in check.

fn checkmate(&self) -> bool

Return if the current side to move is in check mate.

This method can be computationally expensive, do not use outside of Engines.

fn stalemate(&self) -> bool

Returns if the current side to move is in stalemate.

This method can be computationally expensive, do not use outside of Engines.

fn checkers(&self) -> BitBoard

Return the BitBoard of all checks on the current player's king. If the current side to move is not in check, the BitBoard will be empty.

fn discovered_check_candidates(&self) -> BitBoard

Returns the BitBoard of pieces the current side can move to discover check. Discovered check candidates are pieces for the current side to move, that are currently blocking a check from another piece of the same color.

fn pieces_pinned(&self, player: Player) -> BitBoard

Gets the Pinned pieces for the given player. A pinned piece is defined as a piece that if suddenly removed, the player would find itself in check.

fn attackers_to(&self, sq: SQ, occupied: BitBoard) -> BitBoard

Returns a BitBoard of possible attacks / defends to a square with a given occupancy. Includes pieces from both players.

fn legal_move(&self, m: BitMove) -> bool

Tests if a given move is a legal. This is mostly for checking the legality of moves that were generated in a pseudo-legal fashion. Generating moves like this is faster, but doesn't guarantee legality due to the possibility of a discovered check happening.

Safety

Assumes the move is legal for the current board.

fn gives_check(&self, m: BitMove) -> bool

Returns if a move gives check to the opposing player's King.

Safety

Assumes the move is legal for the current board.

fn moved_piece(&self, m: BitMove) -> Piece

Returns the piece that was moved from a given BitMove.

Safety

Assumes the move is legal for the current board.

fn captured_piece(&self, m: BitMove) -> Option<Piece>

Returns the piece that was captured, if any from a given BitMove.

Safety

Assumes the move is legal for the current board.

fn pretty_string(&self) -> String

Returns a prettified String of the current Board, for easy command line displaying.

Capital Letters represent white pieces, while lower case represents black pieces.

fn get_piece_locations(&self) -> PieceLocations

Returns a clone of the current PieceLocations.

fn print_debug_info(&self)

Get Debug Information.

fn pretty_print(&self)

Prints a prettified representation of the board.

fn fancy_print(&self)

Print the board alongside useful information.

Mostly for Debugging useage.

impl Board

fn is_ok_quick(&self) -> bool

Checks the basic status of the board, returning false if something is wrong.

fn is_okay(&self) -> Result<(), BoardError>

Checks if the current state of the Board is okay.

Trait Implementations

impl Display for Board

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

Formats the value using the given formatter.

impl Debug for Board

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

Formats the value using the given formatter.

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 !=.

impl Clone for Board

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.