Enum GameTree

pub enum GameTree<S, M, U, O, const P: usize> {
    Turn {
        state: S,
        to_move: Vec<PlayerIndex<P>>,
        next: Arc<dyn NextGameTree<Vec<M>, S, M, U, O, P>>,
    },
    Chance {
        state: S,
        distribution: Distribution<M>,
        next: Arc<dyn NextGameTree<M, S, M, U, O, P>>,
    },
    End {
        state: S,
        outcome: O,
        utility_type: PhantomData<U>,
    },
}

A node in a game tree.

Variants

Turn

One or more players play a move simultaneously.

Fields

state: S

The game state at this node.

to_move: Vec<PlayerIndex<P>>

The players to move simultaneously.

next: Arc<dyn NextGameTree<Vec<M>, S, M, U, O, P>>

Compute the next node in the tree from the moves played by the players.

Chance

Make a move of chance according to the given distribution.

Fields

state: S

The game state at this node.

distribution: Distribution<M>

The distribution to draw a move from.

next: Arc<dyn NextGameTree<M, S, M, U, O, P>>

Compute the next node in the tree from the move drawn from the distribution.

End

End a game and return the outcome, which includes the game’s payoff.

Fields

state: S

The final game state.

outcome: O

The final outcome of the game.

utility_type: PhantomData<U>

Phantom data to specify the utility value type.

Implementations

impl<S: State, M: Move, U: Utility, O: Outcome<M, U, P>, const P: usize> GameTree<S, M, U, O, P>

pub fn player( state: S, to_move: PlayerIndex<P>, next: impl NextGameTree<M, S, M, U, O, P>, ) -> Self

Construct a game node where a single player must make a move and the next node is computed from the move they choose.

pub fn players( state: S, to_move: Vec<PlayerIndex<P>>, next: impl NextGameTree<Vec<M>, S, M, U, O, P>, ) -> Self

Construct a game node where several players must make a move simultaneously and the next node is computed from the moves they choose.

pub fn all_players( state: S, next: impl NextGameTree<Profile<M, P>, S, M, U, O, P>, ) -> Self

Construct a game node where all players must make a move simultaneously and the next node is computed from the moves they choose.

pub fn chance( state: S, distribution: Distribution<M>, next: impl NextGameTree<M, S, M, U, O, P>, ) -> Self

Construct a game node where a move is selected from a distribution and the next node is computed from the selected move.

pub fn end(state: S, outcome: O) -> Self

Construct a game node ending the game with the given outcome.

pub fn state(&self) -> &S

Get the game state at this node.

pub fn sequentialize(self, prioritize: Option<PlayerIndex<P>>) -> Self

Transform the game tree such that each GameTree::Turn node contains exactly one player. Each turn node where several players move simultaneously will be expanded into a sequence of single-player turn nodes.

A particular player may be prioritized in the transformation. The prioritized player will move first among all players in a simultaneous turn. This is useful, e.g. for focusing on the current player when traversing a game tree within a strategy.

Non-prioritized players will be ordered arbitrarily in the transformed tree.

Trait Implementations

impl<S: Clone, M: Clone, U: Clone, O: Clone, const P: usize> Clone for GameTree<S, M, U, O, P>

fn clone(&self) -> GameTree<S, M, U, O, P>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S: State, M: Move, U: Utility, O: Outcome<M, U, P>, const P: usize> Game<P> for GameTree<S, M, U, O, P>

type Move = M

The type of moves played by players in this game.

type Utility = U

The type of utility values awarded to each player at the end of the game.

type State = S

The type of intermediate game state used during the execution of the game.

type View = S

The type of the view of the intermediate game state presented to players.

fn state_view(&self, state: &Self::State, _player: PlayerIndex<P>) -> Self::View

Produce a view of the game state for the given player.

fn num_players(&self) -> usize

The number of players this game is for.

impl<S: State, M: Move, U: Utility, O: Outcome<M, U, P>, const P: usize> Playable<P> for GameTree<S, M, U, O, P>

type Outcome = O

The type of value produced by playing the game.

fn into_game_tree(self) -> GameTree<S, M, U, O, P>

Convert this game into the corresponding game tree.

fn game_tree( &self, ) -> GameTree<Self::State, Self::Move, Self::Utility, Self::Outcome, P>

Get the corresponding game tree for this game.

fn play( &self, matchup: &Matchup<Self, P>, ) -> PlayResult<Self::Outcome, Self::State, Self::Move, P>

Play this game with the given players by executing the game tree.