[−][src]Trait shakmaty::Position

pub trait Position: Setup {
    pub fn legal_moves(&self, moves: &mut MoveList);
    pub fn castles(&self) -> &Castles;
    pub fn is_variant_end(&self) -> bool;
    pub fn has_insufficient_material(&self, color: Color) -> bool;
    pub fn variant_outcome(&self) -> Option<Outcome>;
    pub fn play_unchecked(&mut self, m: &Move);

    pub fn san_candidates(&self, role: Role, to: Square, moves: &mut MoveList) { ... }
    pub fn castling_moves(&self, side: CastlingSide, moves: &mut MoveList) { ... }
    pub fn en_passant_moves(&self, moves: &mut MoveList) { ... }
    pub fn capture_moves(&self, moves: &mut MoveList) { ... }
    pub fn promotion_moves(&self, moves: &mut MoveList) { ... }
    pub fn is_irreversible(&self, m: &Move) -> bool { ... }
    pub fn king_attackers(
        &self, 
        square: Square, 
        attacker: Color, 
        occupied: Bitboard
    ) -> Bitboard { ... }
    pub fn swap_turn(self) -> Result<Self, PositionError<Self>>
    where
        Self: Sized + FromSetup,
    { ... }
    pub fn legals(&self) -> MoveList { ... }
    pub fn is_legal(&self, m: &Move) -> bool { ... }
    pub fn checkers(&self) -> Bitboard { ... }
    pub fn is_check(&self) -> bool { ... }
    pub fn is_checkmate(&self) -> bool { ... }
    pub fn is_stalemate(&self) -> bool { ... }
    pub fn is_insufficient_material(&self) -> bool { ... }
    pub fn is_game_over(&self) -> bool { ... }
    pub fn outcome(&self) -> Option<Outcome> { ... }
    pub fn play(mut self: Self, m: &Move) -> Result<Self, Self>
    where
        Self: Sized,
    { ... }
}

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

Required methods

`pub fn legal_moves(&self, moves: &mut MoveList)`[src]

Collects all legal moves in an existing buffer.

`pub fn castles(&self) -> &Castles`[src]

Castling paths and unmoved rooks.

`pub fn is_variant_end(&self) -> bool`[src]

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.

`pub fn has_insufficient_material(&self, color: Color) -> bool`[src]

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 if bishops are positioned on dark or light squares, 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.

`pub fn variant_outcome(&self) -> Option<Outcome>`[src]

Tests special variant winning, losing and drawing conditions.

`pub fn play_unchecked(&mut self, m: &Move)`[src]

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() instead.

Loading content...

Provided methods

`pub fn san_candidates(&self, role: Role, to: Square, moves: &mut MoveList)`[src]

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

`pub fn castling_moves(&self, side: CastlingSide, moves: &mut MoveList)`[src]

Generates legal castling moves.

`pub fn en_passant_moves(&self, moves: &mut MoveList)`[src]

Generates en passant moves.

`pub fn capture_moves(&self, moves: &mut MoveList)`[src]

Generates capture moves.

`pub fn promotion_moves(&self, moves: &mut MoveList)`[src]

Generate promotion moves.

`pub fn is_irreversible(&self, m: &Move) -> bool`[src]

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.