Struct chess::BoardBuilder

pub struct BoardBuilder { /* fields omitted */ }

Represents a chess position that has not been validated for legality.

This structure is useful in the following cases:

• You are trying to build a chess board manually in code.
• The Board structure will try to keep the position fully legal, which will prevent you from placing pieces arbitrarily. This structure will not.
• You want to display the chess position in a UI.
• You want to convert between formats like FEN.

use chess::{BoardBuilder, Board, Square, Color, Piece};
use std::convert::TryFrom;
let mut position = BoardBuilder::new();
position.piece(Square::A1, Piece::King, Color::White);
position.piece(Square::A8, Piece::Rook, Color::Black);
position.piece(Square::D1, Piece::King, Color::Black);

// You can index the position by the square:
assert_eq!(position[Square::A1], Some((Piece::King, Color::White)));

// White is in check, but that's ok, it's white's turn to move.
assert!(Board::try_from(&position).is_ok());

// Now White is in check, but Black is ready to move.  This position is invalid.
position.side_to_move(Color::Black);
assert!(Board::try_from(position).is_err());

// One liners are possible with the builder pattern.
use std::convert::TryInto;

let res: Result<Board, _> = BoardBuilder::new()
                       .piece(Square::A1, Piece::King, Color::White)
                       .piece(Square::A8, Piece::King, Color::Black)
                       .try_into();
assert!(res.is_ok());

Methods

impl BoardBuilder

pub fn new() -> BoardBuilder

Construct a new, empty, BoardBuilder.

• No pieces are on the board
• CastleRights are empty for both sides
• en_passant is not set
• side_to_move is Color::White

use chess::{BoardBuilder, Board, Square, Color, Piece};
use std::convert::TryInto;

let board: Board = BoardBuilder::new()
    .piece(Square::A1, Piece::King, Color::White)
    .piece(Square::A8, Piece::King, Color::Black)
    .try_into()?;

pub fn setup<'a>(
    pieces: impl IntoIterator<Item = &'a (Square, Piece, Color)>,
    side_to_move: Color,
    white_castle_rights: CastleRights,
    black_castle_rights: CastleRights,
    en_passant: Option<File>
) -> BoardBuilder

Set up a board with everything pre-loaded.

use chess::{BoardBuilder, Board, Square, Color, Piece, CastleRights};
use std::convert::TryInto;

let board: Board = BoardBuilder::setup(
        &[
            (Square::A1, Piece::King, Color::White),
            (Square::H8, Piece::King, Color::Black)
        ],
        Color::Black,
        CastleRights::NoRights,
        CastleRights::NoRights,
        None)
    .try_into()?;

pub fn get_side_to_move(&self) -> Color

Get the current player

use chess::{BoardBuilder, Board, Color};

let bb: BoardBuilder = Board::default().into();
assert_eq!(bb.get_side_to_move(), Color::White);

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

Get the castle rights for a player

use chess::{BoardBuilder, Board, CastleRights, Color};

let bb: BoardBuilder = Board::default().into();
assert_eq!(bb.get_castle_rights(Color::White), CastleRights::Both);

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

Get the current en_passant square

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

let board = Board::default()
    .make_move_new(ChessMove::new(Square::E2, Square::E4, None))
    .make_move_new(ChessMove::new(Square::H7, Square::H6, None))
    .make_move_new(ChessMove::new(Square::E4, Square::E5, None))
    .make_move_new(ChessMove::new(Square::D7, Square::D5, None));
let bb: BoardBuilder = board.into();
assert_eq!(bb.get_en_passant(), Some(Square::D5));

pub fn side_to_move<'a>(&'a mut self, color: Color) -> &'a mut Self

Set the side to move on the position

This function can be used on self directly or in a builder pattern.

use chess::{BoardBuilder, Color};
BoardBuilder::new()
             .side_to_move(Color::Black);      

let mut bb = BoardBuilder::new();
bb.side_to_move(Color::Black);

pub fn castle_rights<'a>(
    &'a mut self,
    color: Color,
    castle_rights: CastleRights
) -> &'a mut Self

Set the castle rights for a particular color on the position

This function can be used on self directly or in a builder pattern.

use chess::{BoardBuilder, Color, CastleRights};
BoardBuilder::new()
             .castle_rights(Color::White, CastleRights::NoRights);

let mut bb = BoardBuilder::new();
bb.castle_rights(Color::Black, CastleRights::Both);

pub fn piece<'a>(
    &'a mut self,
    square: Square,
    piece: Piece,
    color: Color
) -> &'a mut Self

Set a piece on a square.

Note that this can and will overwrite another piece on the square if need.

Note also that this will not update your castle rights.

This function can be used on self directly or in a builder pattern.

use chess::{BoardBuilder, Color, Square, Piece};

BoardBuilder::new()
             .piece(Square::A1, Piece::Rook, Color::White);

let mut bb = BoardBuilder::new();
bb.piece(Square::A8, Piece::Rook, Color::Black);

pub fn clear_square<'a>(&'a mut self, square: Square) -> &'a mut Self

Clear a square on the board.

Note that this will not update your castle rights.

This function can be used on self directly or in a builder pattern.

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

let mut bb: BoardBuilder = Board::default().into();
bb.clear_square(Square::A1);

pub fn en_passant<'a>(&'a mut self, file: Option<File>) -> &'a mut Self

Set or clear the en_passant File.

This function can be used directly or in a builder pattern.

use chess::{BoardBuilder, Square, Board, File, Color, Piece};

BoardBuilder::new()
             .piece(Square::E4, Piece::Pawn, Color::White)
             .en_passant(Some(File::E));

Trait Implementations

impl Clone for BoardBuilder

fn clone(&self) -> BoardBuilder

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for BoardBuilder

impl Default for BoardBuilder

fn default() -> BoardBuilder

Returns the "default value" for a type.

impl Display for BoardBuilder

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

Formats the value using the given formatter.

impl<'_> From<&'_ Board> for BoardBuilder

fn from(board: &Board) -> Self

Performs the conversion.

impl From<Board> for BoardBuilder

fn from(board: Board) -> Self

Performs the conversion.

impl FromStr for BoardBuilder

type Err = Error

The associated error which can be returned from parsing.

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

Parses a string s to return a value of this type.

impl Index<Square> for BoardBuilder

type Output = Option<(Piece, Color)>

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl IndexMut<Square> for BoardBuilder

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

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

impl<'_> TryFrom<&'_ BoardBuilder> for Board

type Error = Error

The type returned in the event of a conversion error.

fn try_from(fen: &BoardBuilder) -> Result<Self, Self::Error>

Performs the conversion.

impl<'_> TryFrom<&'_ mut BoardBuilder> for Board

type Error = Error

The type returned in the event of a conversion error.

fn try_from(fen: &mut BoardBuilder) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<BoardBuilder> for Board

type Error = Error

The type returned in the event of a conversion error.

fn try_from(fen: BoardBuilder) -> Result<Self, Self::Error>

Performs the conversion.