Struct bughouse::Game

pub struct Game { /* fields omitted */ }

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

impl Game

pub fn new() -> Game

Create a new Game with the initial position.

use chess::{Game, Board};

let game = Game::new();
assert_eq!(game.current_position(), Board::default());

pub fn new_with_board(board: Board) -> Game

Create a new Game with a specific starting position.

use chess::{Game, Board};

let game = Game::new_with_board(Board::default());
assert_eq!(game.current_position(), Board::default());

pub fn actions(&self) -> &Vec<Action, Global>

Get all actions made in this game (moves, draw offers, resignations, etc.)

use chess::{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);

pub fn result(&self) -> Option<GameResult>

What is the status of this game?

use chess::Game;

let game = Game::new();
assert!(game.result().is_none());

pub fn new_from_fen(fen: &str) -> Option<Game>

👎 Deprecated since 3.1.0:

Please use Game::from_str(fen)? instead.

Create a new Game object from an FEN string.

use chess::{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());

pub fn current_position(&self) -> Board

Get the current position on the board from the Game object.

use chess::{Game, Board};

let game = Game::new();
assert_eq!(game.current_position(), Board::default());

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 chess::{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

pub fn declare_draw(&mut self) -> bool

Declare a draw by 3-fold repitition or 50-move rule.

use chess::{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();

pub fn make_move(&mut self, chess_move: ChessMove) -> bool

Make a chess move on the board

use chess::{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"));

pub fn side_to_move(&self) -> Color

Who’s turn is it to move?

use chess::{Game, Color};

let game = Game::new();
assert_eq!(game.side_to_move(), Color::White);

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 chess::{Game, Color};

let mut game = Game::new();
game.offer_draw(Color::White);

pub fn accept_draw(&mut self) -> bool

Accept a draw offer from my opponent.

use chess::{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);

pub fn resign(&mut self, color: Color) -> bool

color resigns the game

use chess::{Game, Color};

let mut game = Game::new();
game.resign(Color::White);

Trait Implementations

impl Clone for Game

pub fn clone(&self) -> Game

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Game

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

Formats the value using the given formatter.

impl FromStr for Game

type Err = Error

The associated error which can be returned from parsing.

pub fn from_str(fen: &str) -> Result<Game, <Game as FromStr>::Err>

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