Struct ChessBoard

pub struct ChessBoard { /* private fields */ }

Implementations

impl ChessBoard

pub fn default_with_rules(rules: Rules) -> Self

pub fn new_without_history_fen(fen: &str, rules: Rules) -> Self

pub fn new_without_history(inner: Board, rules: Rules) -> Self

Construct a new board from an inner chess board, without any history (including repetition and reset counters). To get a board with history start from the initial board and play the moves on it instead.

pub fn parse_move(&self, mv_str: &str) -> Result<ChessMove, Box<ParseMoveError>>

pub fn to_san(&self, mv: ChessMove) -> Result<String, PlayError>

pub fn repetitions_for(&self, board: &Board) -> usize

Count how often the given position occurs in this boards history.

pub fn rules(&self) -> Rules

pub fn inner(&self) -> &Board

pub fn history(&self) -> &Vec<Board>

pub fn non_pawn_or_capture_moves(&self) -> u16

pub fn repetitions(&self) -> u16

Trait Implementations

impl Board for ChessBoard

type Move = ChessMove

The type used to represent moves on this board.

fn next_player(&self) -> Player

Return the next player to make a move. If the board is done this is the player that did not play the last move for consistency.

fn is_available_move(&self, mv: Self::Move) -> Result<bool, BoardDone>

Return whether the given move is available.

fn random_available_move( &self, rng: &mut impl Rng, ) -> Result<Self::Move, BoardDone>

Pick a random move from the available_moves with a uniform distribution. Can be overridden for better performance.

fn play(&mut self, mv: Self::Move) -> Result<(), PlayError>

Play the move mv, modifying this board.

fn outcome(&self) -> Option<Outcome>

The outcome of this board, is None when this games is not done yet.

fn can_lose_after_move() -> bool

Whether the player who plays a move can lose by playing that move. Symbolically whether b.won_by() == Some(Winner::Player(b.next_player())) can ever be true. This may be pessimistic, returning true is always correct.

fn clone_and_play(&self, mv: Self::Move) -> Result<Self, PlayError>

Clone this board, play mv on it and return the new board. Can be overridden for better performance.

fn is_done(&self) -> bool

Whether this games is done.

fn check_done(&self) -> Result<(), BoardDone>

Returns

fn check_can_play(&self, mv: Self::Move) -> Result<(), PlayError>

Returns

fn play_random_available_move( &mut self, rng: &mut impl Rng, ) -> Result<(), BoardDone>

The same as self.play(self.random_available_move(rng)), but needs less error handling. Can be overridden for better performance by skipping the valid move check.

fn children(&self) -> Result<BoardChildrenIterator<'_, Self>, BoardDone>

The same as self.available_moves().map(|mv| self.clone_and_play(mv)), but needs less error handling. Can be overridden for better performance by skipping the valid move check.

impl<'a> BoardMoves<'a, ChessBoard> for ChessBoard

type AllMovesIterator = AllMovesIterator<ChessBoard>

type AvailableMovesIterator = AvailableMovesIterator<'a, ChessBoard>

fn all_possible_moves() -> Self::AllMovesIterator

All theoretically possible moves, for any possible board. Moves returned by available_moves will always be a subset of these moves. The order of these moves does not need to match the order from available_moves.

fn available_moves(&'a self) -> Result<Self::AvailableMovesIterator, BoardDone>

Return an iterator over available moves, is always nonempty. No guarantees are made about the ordering except that it stays consistent when the board is not modified. Panics if this board is done.

impl BoardSymmetry<ChessBoard> for ChessBoard

type Symmetry = UnitSymmetry

The type used to represent symmetries.

type CanonicalKey = ()

The type used by Self::canonical_key.

fn map(&self, _: Self::Symmetry) -> Self

Map this board under the given symmetry.

fn map_move( &self, _: Self::Symmetry, mv: <ChessBoard as Board>::Move, ) -> <ChessBoard as Board>::Move

Map a move under the given symmetry.

fn canonical_key(&self) -> Self::CanonicalKey

Extract all of the state from this board that can potentially change when calling Self::map. This is used by Self::canonicalize to determine which symmetry ends up as the canonical one for the given board.

fn canonicalize(&self) -> Self

Convert this board to a canonical version, by mapping it with the symmetry that results in the smallest Self::canonical_key.

impl Clone for ChessBoard

fn clone(&self) -> ChessBoard

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ChessBoard

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

Formats the value using the given formatter.

impl Default for ChessBoard

fn default() -> Self

Returns the “default value” for a type.

impl Display for ChessBoard

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

Formats the value using the given formatter.

impl Hash for ChessBoard

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 Heuristic<ChessBoard> for ChessPieceValueHeuristic

type V = i32

The type used to represent the heuristic value of a board.

fn value(&self, board: &ChessBoard, length: u32) -> Self::V

Return the heuristic value for the given board from the the next player POV. depth is the current depth, the number of moves played since the board the search was started on. Can be used to prefer faster wins or slower losses.

fn merge(old: Self::V, new: Self::V) -> (Self::V, Ordering)

Merge old and new into a new value, and compare their values. For standard minimax searches this can simply be implemented as: (max(old, new), new.cmp(old))

fn value_update( &self, board: &B, board_value: Self::V, board_length: u32, mv: B::Move, child: &B, ) -> Self::V

Return the value of child, given the previous board, its value and the move that was just played. This function can be overridden to improve performance.

impl PartialEq for ChessBoard

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Alternating for ChessBoard

impl Eq for ChessBoard

impl StructuralPartialEq for ChessBoard