Struct Board 

pub struct Board { /* private fields */ }

A representation of a chess board that implement FEN notation (Board::from_str).

Examples

use chess::{Square, Board, Color, Piece, ChessMove};

let mut board = Board::default();
// 8 | r n b q k b n r
// 7 | p p p p p p p p
// 6 | . . . . . . . .
// 5 | . . . . . . . .
// 4 | . . . . . . . .
// 3 | . . . . . . . .
// 2 | P P P P P P P P
// 1 | R N B Q K B N R
//   +----------------
//     A B C D E F G H

assert_eq!(board.on(Square::E8), Some((Piece::King, Color::Black)));

// White move the pawn from E2 to E4
let m = ChessMove::new(Square::E2, Square::E4);
board.update(m);
// 8 | r n b q k b n r
// 7 | p p p p p p p p
// 6 | . . . . . . . .
// 5 | . . . . . . . .
// 4 | . . . . P . . .
// 3 | . . . . . . . .
// 2 | P P P P . P P P
// 1 | R N B Q K B N R
//   +----------------
//     A B C D E F G H

assert_eq!(board.on(Square::E4), Some((Piece::Pawn, Color::White)));
assert_eq!(board.side_to_move(), Color::Black);

Implementations

impl Board

pub fn new() -> Self

Create a new empty board.

Consider using the Default trait to initialize the board.

pub fn side_to_move(&self) -> Color

Get the Color of the player who has to play.

pub fn castle_rights(&self, color: Color) -> CastleRights

Get the CastleRights for a given side.

pub fn en_passant(&self) -> Option<Square>

Get the Square (if exist) of the En Passant.

pub fn halfmoves(&self) -> u64

Get the halfmoves number.

pub fn fullmoves(&self) -> u64

Get the fullmoves number.

pub fn state(&self) -> GameState

Get the GameState of the Board.

pub fn is_valid(&self, m: ChessMove) -> bool

Check if the ChessMove is valid. Legality is not verified.

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

Check if the ChessMove is legal.

pub fn update(&mut self, m: ChessMove)

Update the chessboard according to the chess rules.

Assume that the ChessMove is legal.

Examples

use chess::{Board, ChessMove, Square};

let mut board = Board::default();
let m = ChessMove::new(Square::E2, Square::E4);

board.update(m);

pub fn remove_castle_rights(&mut self, color: Color, remove: CastleRights)

Remove CastleRights for a particular side.

Examples

use chess::{Board, CastleRights, Color};
let mut board = Board::default();

assert_eq!(board.castle_rights(Color::White), CastleRights::Both);
assert_eq!(board.castle_rights(Color::Black), CastleRights::Both);

board.remove_castle_rights(Color::White, CastleRights::QueenSide);
board.remove_castle_rights(Color::Black, CastleRights::Both);

assert_eq!(board.castle_rights(Color::White), CastleRights::KingSide);
assert_eq!(board.castle_rights(Color::Black), CastleRights::NoRights);

pub fn piece_on(&self, square: Square) -> Option<Piece>

Get the Piece at a given Square.

pub fn piece_on_is(&self, square: Square, piece: Piece) -> bool

Verify if the Square is occupied by the given Piece.

pub fn color_on(&self, square: Square) -> Option<Color>

Get the Color at a given Square.

pub fn color_on_is(&self, square: Square, color: Color) -> bool

Verify if the Square is occupied by the given Color.

pub fn on(&self, square: Square) -> Option<(Piece, Color)>

Get the Color at a given Square.

pub fn on_is(&self, square: Square, (piece, color): (Piece, Color)) -> bool

Verify if the Square is occupied by the given Piece and Color.

pub fn is_pinned(&self, square: Square) -> bool

Verify if the given Square is pinned for the current side.

This implementation returns true only if the Piece has more than one valid move, if not or if the Square is empty, then it returns false.

pub fn pinned(&self) -> Vec<Square>

Get the piece pinned for the current side.

pub fn king_of(&self, color: Color) -> Square

Get the Square of the Piece::King of the given Color.

pub fn is_empty(&self, square: Square) -> bool

Verify if the Square is empty (i.e. not occupied).

pub fn is_occupied(&self, square: Square) -> bool

Verify if the Square is occupied.

pub fn is_check(&self) -> bool

Verify if the Piece::King is in check.

pub fn is_targeted(&self, target: Square, attacker: Color) -> bool

Verify if a Square can be taken by the given Color in the current Board.

Reciprocal: see Board::is_not_targeted.

pub fn is_not_targeted(&self, target: Square, attacker: Color) -> bool

Verify if a Square cannot be taken by the given Color in the current Board.

Reciprocal: see Board::is_targeted.

pub fn has_valid_move(&self, square: Square) -> bool

Verify if the Piece on the Square has one or more valid moves.

If no Piece exist on the Square, then return false.

Note: The legality is not verify, if you want to: use has_legal_move.

pub fn has_legal_move(&self, square: Square) -> bool

Verify if the Piece on the Square has one or more legal moves.

If no Piece exist on the Square, then return false.

pub fn has_any_move(&self) -> bool

Verify if the player has one or more legal moves in all the Board.

If no Piece exist on the Square, then return false.

pub fn get_valid_moves(&self, from: Square) -> Vec<Square>

Compute and return all the valid moves for a Piece (if exist) at a given Square.

If no Piece exist on the Square, then return an empty Vec.

Note: The legality is not verify, if you want to: use get_legal_moves.

pub fn get_legal_moves(&self, from: Square) -> Vec<Square>

Compute and return all the legal moves for a Piece (if exist) at a given Square.

If no Piece exist on the Square, then return an empty Vec.

pub fn get_line(&self, from: Square, direction: Direction) -> Vec<Square>

Construct a Vec of Square from a Square (exclusive) to the first Piece (inclusive) with a given direction.

Examples

use chess::{Board, ChessMove, Direction, Square};

let mut board = Board::default();
board.update(ChessMove::new(Square::D2, Square::D3));
board.update(ChessMove::new(Square::G7, Square::G5));
// 8 | r n b q k b n r
// 7 | p p p p p p . p
// 6 | . . . . . . . .
// 5 | . . . . . . p .
// 4 | . . . . . . . .
// 3 | . . . P . . . .
// 2 | P P P . P P P P
// 1 | R N B Q K B N R
//   +----------------
//     A B C D E F G H

assert_eq!(
    board.get_line(Square::C1, Direction::UpRight),
    vec![Square::D2, Square::E3, Square::F4, Square::G5]
)

Trait Implementations

impl Clone for Board

fn clone(&self) -> Board

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Board

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

Formats the value using the given formatter.

impl Default for Board

fn default() -> Self

Default board is his initial state at the beginning of a chess game.

8 | r n b q k b n r
7 | p p p p p p p p
6 | . . . . . . . .
5 | . . . . . . . .
4 | . . . . . . . .
3 | . . . . . . . .
2 | P P P P P P P P
1 | R N B Q K B N R
  +----------------
    A B C D E F G H

impl Display for Board

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

Formats the value using the given formatter.

impl FromStr for Board

fn from_str(value: &str) -> Result<Self, Self::Err>

From Forsyth-Edwards Notation (FEN).

https://www.chess.com/terms/fen-chess

type Err = Error

The associated error which can be returned from parsing.

impl Index<Square> for Board

type Output = Option<(Piece, Color)>

The returned type after indexing.

fn index(&self, index: Square) -> &Self::Output

Performs the indexing (container[index]) operation.

impl IndexMut<Square> for Board

fn index_mut(&mut self, index: Square) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl PartialEq for Board

fn eq(&self, other: &Board) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Board

impl Eq for Board

impl StructuralPartialEq for Board