Struct shakmaty::Chess

pub struct Chess { /* private fields */ }

A standard Chess position.

Trait Implementations

impl Clone for Chess

fn clone(&self) -> Chess

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Chess

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

Formats the value using the given formatter.

impl Default for Chess

fn default() -> Chess

Returns the “default value” for a type.

impl From<Chess> for VariantPosition

Available on crate feature variant only.

fn from(pos: Chess) -> VariantPosition

Converts to this type from the input type.

impl FromSetup for Chess

fn from_setup(
    setup: Setup,
    mode: CastlingMode
) -> Result<Chess, PositionError<Chess>>

Set up a playable Position.

impl Hash for Chess

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, 

Feeds a slice of this type into the given Hasher.

impl PartialEq<Chess> for Chess

fn eq(&self, other: &Self) -> 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 Position for Chess

fn board(&self) -> &Board

Piece positions on the board.

fn promoted(&self) -> Bitboard

Positions of tracked promoted pieces. Used only for Crazyhouse.

fn pockets(&self) -> Option<&ByColor<ByRole<u8>>>

Pockets in chess variants like Crazyhouse.

fn turn(&self) -> Color

Side to move.

fn castles(&self) -> &Castles

Castling paths and unmoved rooks.

fn maybe_ep_square(&self) -> Option<Square>

Unconditionally gets the en passant target square after a double pawn push, even if no en passant capture is actually possible.

fn remaining_checks(&self) -> Option<&ByColor<RemainingChecks>>

Remaining checks in Three-Check.

fn halfmoves(&self) -> u32

Number of half-moves since the last capture or pawn move.

fn fullmoves(&self) -> NonZeroU32

Move number. Starts at 1 and is increased after every black move.

fn into_setup(self, mode: EnPassantMode) -> Setup

Converts the position to the current Setup.

fn play_unchecked(&mut self, m: &Move)

Plays a move. It is the callers responsibility to ensure the move is legal.

fn legal_moves(&self) -> MoveList

Generates all legal moves.

fn castling_moves(&self, side: CastlingSide) -> MoveList

Generates legal castling moves.

fn en_passant_moves(&self) -> MoveList

Generates en passant moves.

fn promotion_moves(&self) -> MoveList

Generate promotion moves.

fn san_candidates(&self, role: Role, to: Square) -> MoveList

Generates a subset of legal moves: All piece moves and drops of type role to the square to, excluding castling moves.

fn has_insufficient_material(&self, color: Color) -> bool

Tests if a side has insufficient winning material.

fn is_variant_end(&self) -> bool

Checks if the game is over due to a special variant end condition.

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

Tests special variant winning, losing and drawing conditions.

fn capture_moves(&self) -> MoveList

Generates capture moves.

fn is_irreversible(&self, m: &Move) -> bool

Tests if a move is irreversible.

fn king_attackers(
    &self,
    square: Square,
    attacker: Color,
    occupied: Bitboard
) -> Bitboard

Attacks that a king on square would have to deal with.

fn us(&self) -> Bitboard

Squares occupied by the side to move.

fn our(&self, role: Role) -> Bitboard

Squares occupied with the given piece type by the side to move.

fn them(&self) -> Bitboard

Squares occupied by the opponent of the side to move.

fn their(&self, role: Role) -> Bitboard

Squares occupied with the given piece type by the opponent of the side to move.

fn is_legal(&self, m: &Move) -> bool

Tests a move for legality.

fn pseudo_legal_ep_square(&self) -> Option<Square>

The en passant square, if it is the target of a pseudo-legal en passant move.

fn legal_ep_square(&self) -> Option<Square>

The en passant square, if it really is the target of a legal en passant move.

fn ep_square(&self, mode: EnPassantMode) -> Option<Square>

The en passant square.

fn checkers(&self) -> Bitboard

Bitboard of pieces giving check.

fn is_check(&self) -> bool

Tests if the king is in check.

fn is_checkmate(&self) -> bool

Tests for checkmate.

fn is_stalemate(&self) -> bool

Tests for stalemate.

fn is_insufficient_material(&self) -> bool

Tests if both sides have insufficient winning material.

fn is_game_over(&self) -> bool

Tests if the game is over due to checkmate, stalemate, insufficient material or variant end.

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

The outcome of the game, or None if the game is not over.

fn play(self, m: &Move) -> Result<Self, PlayError<Self>> where
    Self: Sized, 

Plays a move.

fn swap_turn(self) -> Result<Self, PositionError<Self>> where
    Self: Sized + FromSetup, 

Swap turns. This is sometimes called “playing a null move”.

impl ZobristHash for Chess

fn zobrist_hash<V: ZobristValue>(&self) -> V

Computes the Zobrist hash of the position from scratch. Hash includes the position, except halfmove clock and fullmove number.

fn prepare_incremental_zobrist_hash<V: ZobristValue>(
    &self,
    _previous: V,
    _m: &Move
) -> Option<V>

Prepares an incremental update of the Zobrist hash before playing move m in self. Returns a new intermediate Zobrist hash, or None if incremental updating is not supported.

fn finalize_incremental_zobrist_hash<V: ZobristValue>(
    &self,
    _intermediate: V,
    _m: &Move
) -> Option<V>

Finalizes an incremental update of the Zobrist hash after playing move m in self. Returns the new Zobrist hash, or None if incremental updating is not supported.

impl Eq for Chess

Equivalent to comparing Position::into_setup(EnPassantMode::Legal).

Positions with different CastlingMode may be equivalent. En passant squares are considered only if there is a legal en passant capture.

Example

use shakmaty::{CastlingMode, Chess, fen::Fen};

let fen: Fen = "r1bqkbnr/ppp2Qpp/2np4/4p3/2B1P3/8/PPPP1PPP/RNB1K1NR b KQkq - 0 4".parse()?;
let position: Chess = fen.clone().into_position(CastlingMode::Standard)?;
let position_960: Chess = fen.into_position(CastlingMode::Chess960)?;
assert_eq!(position, position_960);