Struct Match 

pub struct Match { /* private fields */ }

Backgammon Match

A match is a series of games played until a player reaches the predefined number of points.

Recommended Use for AI Agents

When implementing an agent, always call Match::get_board() to retrieve the board state, but commit moves back through the Match interface to ensure the doubling cube and score are updated.

AI Agent Setup: Always define the match context first

use backgammon::prelude::*;

fn setup_agent_environment() -> Match {
let mut m = Match::new();
m.set_points(13).unwrap();
m.set_crawford(true).unwrap();
m
}

Implementations

impl Match

Implements methods for the Match struct

pub fn new() -> Self

Start a new match:

use backgammon::Match;

let m = Match::new();

pub fn offer_double(&mut self, player: Player) -> Result<(), Error>

Offer the cube to the other player.

pub fn accept_double(&mut self, player: Player) -> Result<(), Error>

After a double has been offered, the other player can accept it.

pub fn reject_double(&mut self, player: Player) -> Result<(), Error>

After a double has been offered, the other player can reject it.

pub fn get_match_state(&self) -> Result<&MatchState, Error>

Return the current state of the match.

pub fn get_game_state(&self) -> Result<&GameState, Error>

Return the current state of the actual match’s game.

pub fn get_player(&self) -> Result<Player, Error>

Return the current player, i.e. the player who needs to perform an action.

pub fn get_score(&self) -> Result<(u64, u64), Error>

Return the current score of the match (player 0, player 1).

pub fn get_cube_value(&self) -> Result<u64, Error>

Return the current cube value.

pub fn get_cube_owner(&self) -> Result<Player, Error>

Return the current cube owner.

Trait Implementations

impl Clone for Match

fn clone(&self) -> Match

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Match

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

Formats the value using the given formatter.

impl Default for Match

fn default() -> Match

Returns the “default value” for a type.

impl MatchRules for Match

fn set_points(&mut self, points: u64) -> Result<(), Error>

Set the number of points required to win the match.

fn get_points(&self) -> Result<u64, Error>

Get the number of points required to win the match.

fn set_cube_play(&mut self, cube: bool) -> Result<(), Error>

Set the cube status.

fn get_cube_play(&self) -> Result<bool, Error>

Get the cube status.

fn set_crawford(&mut self, state: bool) -> Result<(), Error>

Apply the Crawford rule: if the first player reaches a score of points - 1, no doubling is allowed for the following game.

fn get_crawford(&self) -> Result<bool, Error>

Get the Crawford rule status.

fn set_beaver(&mut self, state: bool) -> Result<(), Error>

Apply the Beaver rule: if offered the cube, allow to re-double but keep it.

fn get_beaver(&self) -> Result<bool, Error>

Get the Beaver rule status.

fn set_raccoon(&mut self, state: bool) -> Result<(), Error>

Apply the Raccoon rule: if a player beavered the offered cube, the other may double again, letting the player keep the cube. This requires the Crawford rule to be enabled.

fn get_raccoon(&self) -> Result<bool, Error>

Get the Raccoon rule status.

fn set_murphy(&mut self, state: bool, limit: u8) -> Result<(), Error>

Apply the Murphy rule: if both players roll the same opening number, the cube is doubled, remaining in the middle of the board. The limit parameter defines how often to apply the automatic doubling rule in a Murphy game. 0 means always on.

fn get_murphy(&self) -> Result<(bool, u8), Error>

Get the Murphy rule status and the limit setting. A limit of 0 means that the Murphy rule is always on, given the rule is enabled.

fn set_jacobi(&mut self, state: bool) -> Result<(), Error>

Apply the Jacobi rule: Gammon and Backgammon only count for double or triple values if the cube has already been offered.

fn get_jacobi(&self) -> Result<bool, Error>

Get the Jacobi rule status.

fn set_holland(&mut self, state: bool) -> Result<(), Error>

Apply the Holland rule: Permits to double after the Crawford game only if both players have rolled at least twice. Requires the Crawford rule to be enabled.

fn get_holland(&self) -> Result<bool, Error>

Get the Holland rule status.

impl Move for Match

fn get_board(&self) -> BoardDisplay

Get the current board in a human-readable format.

fn move_checkers( &mut self, player: Player, moves: Vec<(Position, Position)>, ) -> Result<(), Error>

Move a sequence of checkers from a given position to another position.

fn set_checkers( &mut self, player: Player, to: Position, amount: i8, ) -> Result<(), Error>

Set a number of checkers at a given position. This method can be used to prepare a board.

fn empty_board(&mut self) -> Result<(), Error>

Empty the board.

fn available_moves( &self, player: Player, ) -> Result<Vec<Vec<(Position, Position)>>, Error>

Return all available checker moves for a given player and a given set of available (not already used) dice.

impl Roll for Match

fn roll(&mut self, player: Player) -> Result<(), Error>

Roll the two dice.

fn get_dice(&self) -> (u8, u8)

Get the current values of the dice.

fn set_dice(&mut self, player: Player, v: (u8, u8)) -> Result<(), Error>

Set the values of the dice.

fn dice_available(&self) -> &Vec<u8>

Returns the available dice values. These are the dice not yet consumed by a move.

fn dice_consumed(&self) -> bool

Return true if all dice have been consumed and no die is available for playing.