Trait shakmaty::Position

source · [−]
pub trait Position {

Show 39 methods    fn board(&self) -> &Board;
    fn promoted(&self) -> Bitboard;
    fn pockets(&self) -> Option<&ByColor<ByRole<u8>>>;
    fn turn(&self) -> Color;
    fn castles(&self) -> &Castles;
    fn maybe_ep_square(&self) -> Option<Square>;
    fn remaining_checks(&self) -> Option<&ByColor<RemainingChecks>>;
    fn halfmoves(&self) -> u32;
    fn fullmoves(&self) -> NonZeroU32;
    fn into_setup(self, mode: EnPassantMode) -> Setup;
    fn legal_moves(&self) -> MoveList;
    fn is_variant_end(&self) -> bool;
    fn has_insufficient_material(&self, color: Color) -> bool;
    fn variant_outcome(&self) -> Option<Outcome>;
    fn play_unchecked(&mut self, m: &Move);

    fn san_candidates(&self, role: Role, to: Square) -> MoveList { ... }
    fn castling_moves(&self, side: CastlingSide) -> MoveList { ... }
    fn en_passant_moves(&self) -> MoveList { ... }
    fn capture_moves(&self) -> MoveList { ... }
    fn promotion_moves(&self) -> MoveList { ... }
    fn is_irreversible(&self, m: &Move) -> bool { ... }
    fn king_attackers(
        &self,
        square: Square,
        attacker: Color,
        occupied: Bitboard
    ) -> Bitboard { ... }
    fn us(&self) -> Bitboard { ... }
    fn our(&self, role: Role) -> Bitboard { ... }
    fn them(&self) -> Bitboard { ... }
    fn their(&self, role: Role) -> Bitboard { ... }
    fn is_legal(&self, m: &Move) -> bool { ... }
    fn pseudo_legal_ep_square(&self) -> Option<Square> { ... }
    fn legal_ep_square(&self) -> Option<Square> { ... }
    fn ep_square(&self, mode: EnPassantMode) -> Option<Square> { ... }
    fn checkers(&self) -> Bitboard { ... }
    fn is_check(&self) -> bool { ... }
    fn is_checkmate(&self) -> bool { ... }
    fn is_stalemate(&self) -> bool { ... }
    fn is_insufficient_material(&self) -> bool { ... }
    fn is_game_over(&self) -> bool { ... }
    fn outcome(&self) -> Option<Outcome> { ... }
    fn play(self, m: &Move) -> Result<Self, PlayError<Self>>
    where
        Self: Sized,
    { ... }
    fn swap_turn(self) -> Result<Self, PositionError<Self>>
    where
        Self: Sized + FromSetup,
    { ... }

}
Expand description

A playable chess or chess variant position. See Chess for a concrete implementation.

Required Methods

Piece positions on the board.

Positions of tracked promoted pieces. Used only for Crazyhouse.

Pockets in chess variants like Crazyhouse.

Side to move.

Castling paths and unmoved rooks.

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

Also see Position::pseudo_legal_ep_square() and Position::legal_ep_square().

Remaining checks in Three-Check.

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

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

Converts the position to the current Setup.

Generates all legal moves.

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

Note that for example stalemate is not considered a variant-specific end condition (is_variant_end() will return false), but it can have a special variant_outcome() in suicide chess.

Tests if a side has insufficient winning material.

Returns false if there is any series of legal moves that allows color to win the game.

The converse is not necessarily true: The position might be locked up such that color can never win the game (even if !color cooperates), or insufficient material might only become apparent after a forced sequence of moves.

The current implementation can be summarized as follows: Looking only at the material configuration, taking into account color complexes of bishops and knights, but not concrete piece positions, is there a position with the same material configuration where color can win with a series of legal moves. If not, then color has insufficient winning material.

Tests special variant winning, losing and drawing conditions.

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

Panics

Illegal moves can corrupt the state of the position and may (or may not) panic or cause panics on future calls. Consider using Position::play() if you cannot guarantee legality.

Provided Methods

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

Generates legal castling moves.

Generates en passant moves.

Generates capture moves.

Generate promotion moves.

Tests if a move is irreversible.

In standard chess, pawn moves, captures, moves that destroy castling rights, and moves that cede en-passant are irreversible.

The implementation has false-negatives, because it does not consider forced lines. For example, a checking move that will force the king to lose castling rights is not considered irreversible, only the actual king move is.

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

Squares occupied by the side to move.

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

Squares occupied by the opponent of the side to move.

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

Tests a move for legality.

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

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

The en passant square.

Bitboard of pieces giving check.

Tests if the king is in check.

Tests for checkmate.

Tests for stalemate.

Tests if both sides have insufficient winning material.

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

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

Plays a move.

Errors

Returns a PlayError if the move is not legal. You can use Position::play_unchecked() if you can guarantee legality.

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

Errors

Returns PositionError if swapping turns is not possible (usually due to a check that has to be averted).

Implementors