[−][src]Struct chess::Board
A representation of a chess board. That's why you're here, right?
Methods
impl Board
[src]
pub fn from_fen(fen: String) -> Option<Board>
[src]
Construct a board from a FEN string.
use chess::Board; let init_position = Board::from_fen("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1".to_owned()).expect("Valid FEN"); assert_eq!(init_position, Board::default());
pub fn enumerate_moves(&self, moves: &mut [ChessMove; 256]) -> usize
[src]
please use the MoveGen structure instead. It is faster and more idiomatic.
pub fn status(&self) -> BoardStatus
[src]
Is this game Ongoing, is it Stalemate, or is it Checkmate?
use chess::{Board, BoardStatus, Square, Rank, File, ChessMove}; let mut board = Board::default(); assert_eq!(board.status(), BoardStatus::Ongoing); board = board.make_move_new(ChessMove::new(Square::make_square(Rank::Second, File::E), Square::make_square(Rank::Fourth, File::E), None)); assert_eq!(board.status(), BoardStatus::Ongoing); board = board.make_move_new(ChessMove::new(Square::make_square(Rank::Seventh, File::F), Square::make_square(Rank::Sixth, File::F), None)); assert_eq!(board.status(), BoardStatus::Ongoing); board = board.make_move_new(ChessMove::new(Square::make_square(Rank::Second, File::D), Square::make_square(Rank::Fourth, File::D), None)); assert_eq!(board.status(), BoardStatus::Ongoing); board = board.make_move_new(ChessMove::new(Square::make_square(Rank::Seventh, File::G), Square::make_square(Rank::Fifth, File::G), None)); assert_eq!(board.status(), BoardStatus::Ongoing); board = board.make_move_new(ChessMove::new(Square::make_square(Rank::First, File::D), Square::make_square(Rank::Fifth, File::H), None)); assert_eq!(board.status(), BoardStatus::Checkmate);
ⓘImportant traits for BitBoardpub fn combined(&self) -> &BitBoard
[src]
Grab the "combined" BitBoard
. This is a BitBoard
with every piece.
use chess::{Board, BitBoard, Rank, get_rank}; let board = Board::default(); let combined_should_be = get_rank(Rank::First) | get_rank(Rank::Second) | get_rank(Rank::Seventh) | get_rank(Rank::Eighth); assert_eq!(*board.combined(), combined_should_be);
ⓘImportant traits for BitBoardpub fn color_combined(&self, color: Color) -> &BitBoard
[src]
Grab the "color combined" BitBoard
. This is a BitBoard
with every piece of a particular
color.
use chess::{Board, BitBoard, Rank, get_rank, Color}; let board = Board::default(); let white_pieces = get_rank(Rank::First) | get_rank(Rank::Second); let black_pieces = get_rank(Rank::Seventh) | get_rank(Rank::Eighth); assert_eq!(*board.color_combined(Color::White), white_pieces); assert_eq!(*board.color_combined(Color::Black), black_pieces);
pub fn king_square(&self, color: Color) -> Square
[src]
Give me the Square
the color
king is on.
use chess::{Board, Square, Color, Rank, File}; let board = Board::default(); assert_eq!(board.king_square(Color::White), Square::make_square(Rank::First, File::E)); assert_eq!(board.king_square(Color::Black), Square::make_square(Rank::Eighth, File::E));
ⓘImportant traits for BitBoardpub fn pieces(&self, piece: Piece) -> &BitBoard
[src]
Grab the "pieces" BitBoard
. This is a BitBoard
with every piece of a particular type.
use chess::{Board, BitBoard, Piece, Square, Rank, File}; // The rooks should be in each corner of the board let rooks = BitBoard::from_square(Square::make_square(Rank::First, File::A)) | BitBoard::from_square(Square::make_square(Rank::First, File::H)) | BitBoard::from_square(Square::make_square(Rank::Eighth, File::A)) | BitBoard::from_square(Square::make_square(Rank::Eighth, File::H)); let board = Board::default(); assert_eq!(*board.pieces(Piece::Rook), rooks);
pub fn castle_rights(&self, color: Color) -> CastleRights
[src]
Grab the CastleRights
for a particular side.
use chess::{Board, Square, Rank, File, CastleRights, Color, ChessMove}; let move1 = ChessMove::new(Square::make_square(Rank::Second, File::A), Square::make_square(Rank::Fourth, File::A), None); let move2 = ChessMove::new(Square::make_square(Rank::Seventh, File::E), Square::make_square(Rank::Fifth, File::E), None); let move3 = ChessMove::new(Square::make_square(Rank::First, File::A), Square::make_square(Rank::Second, File::A), None); let move4 = ChessMove::new(Square::make_square(Rank::Eighth, File::E), Square::make_square(Rank::Seventh, File::E), None); let mut board = Board::default(); assert_eq!(board.castle_rights(Color::White), CastleRights::Both); assert_eq!(board.castle_rights(Color::Black), CastleRights::Both); board = board.make_move_new(move1) .make_move_new(move2) .make_move_new(move3) .make_move_new(move4); assert_eq!(board.castle_rights(Color::White), CastleRights::KingSide); assert_eq!(board.castle_rights(Color::Black), CastleRights::NoRights);
pub fn add_castle_rights(&mut self, color: Color, add: CastleRights)
[src]
Add castle rights for a particular side. Note: this can create an invalid position.
pub fn remove_castle_rights(&mut self, color: Color, remove: CastleRights)
[src]
Remove castle rights for a particular side.
use chess::{Board, CastleRights, Color}; let mut board = Board::default(); assert_eq!(board.castle_rights(Color::White), CastleRights::Both); board.remove_castle_rights(Color::White, CastleRights::KingSide); assert_eq!(board.castle_rights(Color::White), CastleRights::QueenSide);
pub fn side_to_move(&self) -> Color
[src]
Who's turn is it?
use chess::{Board, Color}; let mut board = Board::default(); assert_eq!(board.side_to_move(), Color::White);
pub fn my_castle_rights(&self) -> CastleRights
[src]
Grab my CastleRights
.
use chess::{Board, Color, CastleRights}; let mut board = Board::default(); board.remove_castle_rights(Color::White, CastleRights::KingSide); board.remove_castle_rights(Color::Black, CastleRights::QueenSide); assert_eq!(board.my_castle_rights(), board.castle_rights(Color::White));
pub fn add_my_castle_rights(&mut self, add: CastleRights)
[src]
Add to my CastleRights
. Note: This can make the position invalid.
pub fn remove_my_castle_rights(&mut self, remove: CastleRights)
[src]
Remove some of my CastleRights
.
use chess::{Board, CastleRights}; let mut board = Board::default(); assert_eq!(board.my_castle_rights(), CastleRights::Both); board.remove_my_castle_rights(CastleRights::KingSide); assert_eq!(board.my_castle_rights(), CastleRights::QueenSide);
pub fn their_castle_rights(&self) -> CastleRights
[src]
My opponents CastleRights
.
use chess::{Board, Color, CastleRights}; let mut board = Board::default(); board.remove_castle_rights(Color::White, CastleRights::KingSide); board.remove_castle_rights(Color::Black, CastleRights::QueenSide); assert_eq!(board.their_castle_rights(), board.castle_rights(Color::Black));
pub fn add_their_castle_rights(&mut self, add: CastleRights)
[src]
Add to my opponents CastleRights
. Note: This can make the position invalid.
pub fn remove_their_castle_rights(&mut self, remove: CastleRights)
[src]
Remove some of my opponents CastleRights
.
use chess::{Board, CastleRights}; let mut board = Board::default(); assert_eq!(board.their_castle_rights(), CastleRights::Both); board.remove_their_castle_rights(CastleRights::KingSide); assert_eq!(board.their_castle_rights(), CastleRights::QueenSide);
pub fn set_piece(
&self,
piece: Piece,
color: Color,
square: Square
) -> Option<Board>
[src]
&self,
piece: Piece,
color: Color,
square: Square
) -> Option<Board>
For a chess UI: set a piece on a particular square.
use chess::{Board, Piece, Color, Square, Rank, File}; let board = Board::default(); let new_board = board.set_piece(Piece::Queen, Color::White, Square::make_square(Rank::Fourth, File::E)) .expect("Valid Position"); assert_eq!(new_board.pieces(Piece::Queen).count(), 3);
pub fn clear_square(&self, square: Square) -> Option<Board>
[src]
For a chess UI: clear a particular square.
use chess::{Board, Square, Rank, File, Piece}; let board = Board::default(); let new_board = board.clear_square(Square::make_square(Rank::First, File::A)) .expect("Valid Position"); assert_eq!(new_board.pieces(Piece::Rook).count(), 3);
pub fn null_move(&self) -> Option<Board>
[src]
Switch the color of the player without actually making a move. Returns None if the current player is in check.
Note that this erases the en-passant information, so applying this function twice does not always give the same result back.
use chess::{Board, Color}; let board = Board::default(); assert_eq!(board.side_to_move(), Color::White); let new_board = board.null_move().expect("Valid Position"); assert_eq!(new_board.side_to_move(), Color::Black);
pub fn is_sane(&self) -> bool
[src]
Does this board "make sense"? Do all the pieces make sense, do the bitboards combine correctly, etc? This is for sanity checking.
use chess::{Board, Color, Piece, Square, Rank, File}; let board = Board::default(); assert_eq!(board.is_sane(), true); // Remove the king let bad_board = board.clear_square(Square::make_square(Rank::First, File::E)).expect("Valid Position"); assert_eq!(bad_board.is_sane(), false);
pub fn get_hash(&self) -> u64
[src]
Get a hash of the board.
pub fn get_pawn_hash(&self) -> u64
[src]
Get a pawn hash of the board (a hash that only changes on color change and pawn moves).
pub fn piece_on(&self, square: Square) -> Option<Piece>
[src]
What piece is on a particular Square
? Is there even one?
use chess::{Board, Piece, Square, Rank, File}; let board = Board::default(); let sq1 = Square::make_square(Rank::First, File::A); let sq2 = Square::make_square(Rank::Fourth, File::D); assert_eq!(board.piece_on(sq1), Some(Piece::Rook)); assert_eq!(board.piece_on(sq2), None);
pub fn color_on(&self, square: Square) -> Option<Color>
[src]
What color piece is on a particular square?
pub fn en_passant(self) -> Option<Square>
[src]
Give me the en_passant square, if it exists.
use chess::{Board, ChessMove, Square, Rank, File}; let move1 = ChessMove::new(Square::make_square(Rank::Second, File::D), Square::make_square(Rank::Fourth, File::D), None); let move2 = ChessMove::new(Square::make_square(Rank::Seventh, File::H), Square::make_square(Rank::Fifth, File::H), None); let move3 = ChessMove::new(Square::make_square(Rank::Fourth, File::D), Square::make_square(Rank::Fifth, File::D), None); let move4 = ChessMove::new(Square::make_square(Rank::Seventh, File::E), Square::make_square(Rank::Fifth, File::E), None); let board = Board::default().make_move_new(move1) .make_move_new(move2) .make_move_new(move3) .make_move_new(move4); assert_eq!(board.en_passant(), Some(Square::make_square(Rank::Fifth, File::E)));
pub fn legal(&self, m: ChessMove) -> bool
[src]
Is a particular move legal? This function is very slow, but will work on unsanitized input.
use chess::{Board, ChessMove, Square, Rank, File}; let move1 = ChessMove::new(Square::make_square(Rank::Second, File::E), Square::make_square(Rank::Fourth, File::E), None); let move2 = ChessMove::new(Square::make_square(Rank::Second, File::E), Square::make_square(Rank::Fifth, File::E), None); let board = Board::default(); assert_eq!(board.legal(move1), true); assert_eq!(board.legal(move2), false);
pub fn make_move_new(&self, m: ChessMove) -> Board
[src]
Make a chess move onto a new board.
panic!() if king is captured.
use chess::{Board, ChessMove, Square, Rank, File, Color}; let m = ChessMove::new(Square::make_square(Rank::Second, File::D), Square::make_square(Rank::Fourth, File::D), None); let board = Board::default(); assert_eq!(board.make_move_new(m).side_to_move(), Color::Black);
pub fn make_move(&self, m: ChessMove, result: &mut Board)
[src]
Make a chess move onto an already allocated Board
.
panic!() if king is captured.
use chess::{Board, ChessMove, Square, Rank, File, Color}; let m = ChessMove::new(Square::make_square(Rank::Second, File::D), Square::make_square(Rank::Fourth, File::D), None); let board = Board::default(); let mut result = Board::default(); board.make_move(m, &mut result); assert_eq!(result.side_to_move(), Color::Black);
ⓘImportant traits for BitBoardpub fn pinned(&self) -> &BitBoard
[src]
Give me the BitBoard
of my pinned pieces.
ⓘImportant traits for BitBoardpub fn checkers(&self) -> &BitBoard
[src]
Give me the Bitboard
of the pieces putting me in check.
Trait Implementations
impl Default for Board
[src]
Construct the initial position.
impl Clone for Board
[src]
fn clone(&self) -> Board
[src]
fn clone_from(&mut self, source: &Self)
1.0.0[src]
Performs copy-assignment from source
. Read more
impl Copy for Board
[src]
impl PartialEq<Board> for Board
[src]
impl Debug for Board
[src]
Auto Trait Implementations
Blanket Implementations
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
fn to_owned(&self) -> T
[src]
fn clone_into(&self, target: &mut T)
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,