Struct Game

pub struct Game {
    pub current: Position,
    /* private fields */
}

Game is an sequence of Positions.

A Game is created with a GameBuilder.

Fields

current: Position

The current position of this game

Implementations

impl Game

pub fn finished(&self) -> bool

Determine if this game is finished

pub fn options(&self) -> Vec<Bowl>

Determine which bowls are playable.

pub fn play(&mut self, bowl: Bowl) -> Result<(), FoulPlay>

Play a certain bowl.

Fails if the bowl does not contain any stones.

pub fn score(&self) -> Option<Score>

Determine the score of a game.

None if the game is not finished

Examples found in repository

examples/minmax.rs (line 16)

fn main() {
    let mut red_strategy = MinMax {};
    let mut blue_strategy = MinMax {};
    let mut bout = Bout::new(&mut red_strategy, &mut blue_strategy);

    for stones in 1..15 {
        let game = GameBuilder::new().bowls(2).stones(stones).build();
        let result = bout.start(game).expect("a finished game with score");
        let score = result
            .score()
            .map(|score| score * score_multiplier(result.current.active_player()));
        println!("{} {:?}", stones, score);
    }
}

examples/alphabeta.rs (line 16)

fn main() {
    let mut red_strategy = AlphaBeta::strategy().build();
    let mut blue_strategy = AlphaBeta::strategy().build();
    let mut bout = Bout::new(&mut red_strategy, &mut blue_strategy);

    for stones in 1..15 {
        let game = GameBuilder::new().bowls(2).stones(stones).build();
        let result = bout.start(game).expect("a finished game with score");
        let score = result
            .score()
            .map(|score| score * score_multiplier(result.current.active_player()));
        println!("{} {:?}", stones, score);
    }
}

pub fn turn(&self) -> Player

Return which players turn it is

Trait Implementations

impl Debug for Game

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

Formats the value using the given formatter.

impl PartialEq for Game

fn eq(&self, other: &Game) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Game