[−][src]Trait shakmaty::Position

pub trait Position: Setup {
    fn legal_moves(&self, moves: &mut MoveList);
    fn castles(&self) -> &Castles;
    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 swap_turn(self) -> Result<Self, PositionError>
    where
        Self: Sized + FromSetup,
    { ... }
    fn legals(&self) -> MoveList { ... }
    fn san_candidates(&self, role: Role, to: Square, moves: &mut MoveList) { ... }
    fn castling_moves(&self, side: CastlingSide, moves: &mut MoveList) { ... }
    fn en_passant_moves(&self, moves: &mut MoveList) { ... }
    fn capture_moves(&self, moves: &mut MoveList) { ... }
    fn promotion_moves(&self, moves: &mut MoveList) { ... }
    fn is_legal(&self, m: &Move) -> bool { ... }
    fn is_irreversible(&self, m: &Move) -> bool { ... }
    fn king_attackers(
        &self, 
        square: Square, 
        attacker: Color, 
        occupied: Bitboard
    ) -> Bitboard { ... }
    fn is_check(&self) -> bool { ... }
    fn checkers(&self) -> Bitboard { ... }
    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, IllegalMoveError>
    where
        Self: Sized,
    { ... }
}

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

Required methods

`fn legal_moves(&self, moves: &mut MoveList)`

Collects all legal moves in an existing buffer.

`fn castles(&self) -> &Castles`

Castling paths and unmoved rooks.

`fn is_variant_end(&self) -> bool`

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.

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

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.

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

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