pub struct Game { /* private fields */ }
Expand description
For UI/UCI Servers, store a game object which allows you to determine draw by 3 fold repitition, draw offers, resignations, and moves.
This structure is slow compared to using Board
directly, so it is
not recommended for engines.
Implementations§
source§impl Game
impl Game
sourcepub fn new() -> Game
pub fn new() -> Game
Create a new Game
with the initial position.
use candidate::{Game, Board};
let game = Game::new();
assert_eq!(game.current_position(), Board::default());
pub fn get_boards(&self) -> &Vec<Board>
sourcepub fn new_with_board(board: Board) -> Game
pub fn new_with_board(board: Board) -> Game
Create a new Game
with a specific starting position.
use candidate::{Game, Board};
let game = Game::new_with_board(Board::default());
assert_eq!(game.current_position(), Board::default());
sourcepub fn actions(&self) -> &Vec<Action>
pub fn actions(&self) -> &Vec<Action>
Get all actions made in this game (moves, draw offers, resignations, etc.)
use candidate::{Game, MoveGen, Color};
let mut game = Game::new();
let mut movegen = MoveGen::new_legal(&game.current_position());
game.make_move(movegen.next().expect("At least one valid move"));
game.resign(Color::Black);
assert_eq!(game.actions().len(), 2);
sourcepub fn result(&self) -> Option<GameResult>
pub fn result(&self) -> Option<GameResult>
What is the status of this game?
use candidate::Game;
let game = Game::new();
assert!(game.result().is_none());
sourcepub fn new_from_fen(fen: &str) -> Option<Game>
👎Deprecated since 3.1.0: Please use Game::from_str(fen)? instead.
pub fn new_from_fen(fen: &str) -> Option<Game>
Create a new Game
object from an FEN string.
use candidate::{Game, Board};
// This is the better way:
use std::str::FromStr;
let game: Game = Game::from_str("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1").expect("Valid FEN");
let game2: Result<Game, _> = Game::from_str("Invalid FEN");
assert!(game2.is_err());
// This still works
let game = Game::new_from_fen("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1").expect("Valid FEN");
let game2 = Game::new_from_fen("Invalid FEN");
assert!(game2.is_none());
sourcepub fn current_position(&self) -> Board
pub fn current_position(&self) -> Board
Get the current position on the board from the Game
object.
use candidate::{Game, Board};
let game = Game::new();
assert_eq!(game.current_position(), Board::default());
sourcepub fn can_declare_draw(&self) -> bool
pub fn can_declare_draw(&self) -> bool
Determine if a player can legally declare a draw by 3-fold repetition or 50-move rule.
use candidate::{Game, Square, ChessMove};
let b1c3 = ChessMove::new(Square::B1, Square::C3, None);
let c3b1 = ChessMove::new(Square::C3, Square::B1, None);
let b8c6 = ChessMove::new(Square::B8, Square::C6, None);
let c6b8 = ChessMove::new(Square::C6, Square::B8, None);
let mut game = Game::new();
assert_eq!(game.can_declare_draw(), false);
game.make_move(b1c3);
game.make_move(b8c6);
game.make_move(c3b1);
game.make_move(c6b8);
assert_eq!(game.can_declare_draw(), false); // position has shown up twice
game.make_move(b1c3);
game.make_move(b8c6);
game.make_move(c3b1);
game.make_move(c6b8);
assert_eq!(game.can_declare_draw(), true); // position has shown up three times
sourcepub fn declare_draw(&mut self) -> bool
pub fn declare_draw(&mut self) -> bool
Declare a draw by 3-fold repitition or 50-move rule.
use candidate::{Game, Square, ChessMove};
let b1c3 = ChessMove::new(Square::B1, Square::C3, None);
let c3b1 = ChessMove::new(Square::C3, Square::B1, None);
let b8c6 = ChessMove::new(Square::B8, Square::C6, None);
let c6b8 = ChessMove::new(Square::C6, Square::B8, None);
let mut game = Game::new();
assert_eq!(game.can_declare_draw(), false);
game.make_move(b1c3);
game.make_move(b8c6);
game.make_move(c3b1);
game.make_move(c6b8);
assert_eq!(game.can_declare_draw(), false); // position has shown up twice
game.make_move(b1c3);
game.make_move(b8c6);
game.make_move(c3b1);
game.make_move(c6b8);
assert_eq!(game.can_declare_draw(), true); // position has shown up three times
game.declare_draw();
sourcepub fn make_move(&mut self, chess_move: ChessMove) -> Option<String>
pub fn make_move(&mut self, chess_move: ChessMove) -> Option<String>
Make a chess move on the board
use candidate::{Game, MoveGen};
let mut game = Game::new();
let mut movegen = MoveGen::new_legal(&game.current_position());
game.make_move(movegen.next().expect("At least one legal move"));
sourcepub fn side_to_move(&self) -> Color
pub fn side_to_move(&self) -> Color
Who’s turn is it to move?
use candidate::{Game, Color};
let game = Game::new();
assert_eq!(game.side_to_move(), Color::White);
sourcepub fn offer_draw(&mut self, color: Color) -> bool
pub fn offer_draw(&mut self, color: Color) -> bool
Offer a draw to my opponent. color
is the player who offered the draw. The draw must be
accepted before my opponent moves.
use candidate::{Game, Color};
let mut game = Game::new();
game.offer_draw(Color::White);
sourcepub fn accept_draw(&mut self) -> bool
pub fn accept_draw(&mut self) -> bool
Accept a draw offer from my opponent.
use candidate::{Game, MoveGen, Color};
let mut game = Game::new();
game.offer_draw(Color::Black);
assert_eq!(game.accept_draw(), true);
let mut game2 = Game::new();
let mut movegen = MoveGen::new_legal(&game2.current_position());
game2.offer_draw(Color::Black);
game2.make_move(movegen.next().expect("At least one legal move"));
assert_eq!(game2.accept_draw(), false);