Struct DisjointImpartialNormalGame

pub struct DisjointImpartialNormalGame<L: Game + NormalImpartial, R: Game + NormalImpartial> { /* private fields */ }

Represents the disjoint sum of two impartial normal combinatorial games.

Since Game isn’t object safe, we use dyn Any internally with downcast safety.

We restrict games to being normal impartial to force implementation of the marker trait.

Trait Implementations

impl<L: Clone + Game + NormalImpartial, R: Clone + Game + NormalImpartial> Clone for DisjointImpartialNormalGame<L, R>

fn clone(&self) -> DisjointImpartialNormalGame<L, R>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<L: Game + Debug + NormalImpartial + 'static, R: Game + Debug + NormalImpartial + 'static> Game for DisjointImpartialNormalGame<L, R>

type Move = DisjointMove<L, R>

The type of move this game uses.

type Iter<'a> = Interleave<Map<<L as Game>::Iter<'a>, Box<dyn Fn(<L as Game>::Move) -> DisjointMove<L, R>>>, Map<<R as Game>::Iter<'a>, Box<dyn Fn(<R as Game>::Move) -> DisjointMove<L, R>>>> where L: 'a, R: 'a, L::Move: 'a, R::Move: 'a

The iterator type for possible moves.

type Player = ImpartialPlayer

type MoveError = DisjointMoveError<L, R>

fn move_count(&self) -> usize

Returns the amount of moves that have been played

fn max_moves(&self) -> Option<usize>

Get the max number of moves in a game, if any.

fn make_move(&mut self, m: &Self::Move) -> Result<(), Self::MoveError>

Makes a move.

fn possible_moves(&self) -> Self::Iter<'_>

Returns an iterator of all possible moves.

fn state(&self) -> GameState<Self::Player>

Returns the current state of the game. Used for verifying initialization and is commonly called.

fn player(&self) -> Self::Player

Returns the player whose turn it is. The implementation of this should be similar to either

fn find_immediately_resolvable_game( &self, ) -> Result<Option<Self>, Self::MoveError>

Returns a reachable game in one move.

impl<L: Game + Debug + NormalImpartial + 'static, R: Game + Debug + NormalImpartial + 'static> Normal for DisjointImpartialNormalGame<L, R>

fn state(&self) -> GameState<Self::Player>

impl<L: Game + Debug + NormalImpartial + 'static, R: Game + Debug + NormalImpartial + 'static> NormalImpartial for DisjointImpartialNormalGame<L, R>

fn split(&self) -> Option<Vec<Self>>

Splits a game into multiple separate games.