Struct shakmaty::zobrist::Zobrist

pub struct Zobrist<P, V: ZobristValue> { /* private fields */ }

A wrapper for Position that maintains an incremental Zobrist hash.

Examples

use shakmaty::{Chess, Position, Move, Square, Role, zobrist::Zobrist};

let pos: Zobrist<Chess, u64> = Zobrist::default();

assert_eq!(pos.zobrist_hash(), 0x463b96181691fc9c);
assert_eq!(pos.zobrist_hash(), 0x463b96181691fc9c); // cached

// 1. e4
let pos = pos.play(&Move::Normal {
    role: Role::Pawn,
    from: Square::E2,
    to: Square::E4,
    capture: None,
    promotion: None,
})?;

// Incrementally updated (or recomputed from scratch if incremental
// updates not supported).
assert_eq!(pos.zobrist_hash(), 0x823c9b50fd114196);

Implementations

impl<P, V: ZobristValue> Zobrist<P, V>

pub fn new(pos: P) -> Zobrist<P, V>

pub fn into_inner(self) -> P

pub fn as_inner(&self) -> &P

impl<P: ZobristHash, V: ZobristValue> Zobrist<P, V>

pub fn zobrist_hash(&self) -> V

Trait Implementations

impl<P: Clone, V: Clone + ZobristValue> Clone for Zobrist<P, V>

fn clone(&self) -> Zobrist<P, V>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<P: Debug, V: Debug + ZobristValue> Debug for Zobrist<P, V>

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

Formats the value using the given formatter.

impl<P: Default, V: ZobristValue> Default for Zobrist<P, V>

fn default() -> Zobrist<P, V>

Returns the “default value” for a type.

impl<P: FromSetup + Position, V: ZobristValue> FromSetup for Zobrist<P, V>

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

Set up a playable Position.

impl<P: Position + ZobristHash, V: ZobristValue> Position for Zobrist<P, V>

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 legal_moves(&self) -> MoveList

Generates all legal 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 castling_moves(&self, side: CastlingSide) -> MoveList

Generates legal castling moves.

fn en_passant_moves(&self) -> MoveList

Generates en passant moves.

fn capture_moves(&self) -> MoveList

Generates capture moves.

fn promotion_moves(&self) -> MoveList

Generate promotion 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 is_variant_end(&self) -> bool

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

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

Tests if a side has insufficient winning material.

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

Tests special variant winning, losing and drawing conditions.

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

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

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”.