Struct ggpf::game::meta::with_history::WithHistory

pub struct WithHistory<G: Base> {
    pub state: G,
    // some fields omitted
}

A game with its history.

Fields

state: G

Current game state.

Trait Implementations

impl<G: Base + Clone> Base for WithHistory<G>

type Move = G::Move

The type for a Move.

fn possible_moves(&self) -> Vec<Self::Move>

Given the game state and turn, list possible actions to the current player. If the game has ended, no action should be available.

fn is_finished(&self) -> bool

Returns if the game has ended or not.

impl<G: Clone + Base> Clone for WithHistory<G>

fn clone(&self) -> WithHistory<G>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<G: Debug + Base> Debug for WithHistory<G>

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

Formats the value using the given formatter.

impl<G: Base + Eq> Eq for WithHistory<G>

impl<G: Features + Clone + Sync + Send> Features for WithHistory<G>

type StateDim = <G::StateDim as Dimension>::Larger

Type dimension of the game state feature space.

type ActionDim = G::ActionDim

Type dimension of the action feature space.

type Descriptor = (<G::StateDim as Dimension>::Larger, G::Descriptor)

Game features descriptor, that can be used to retrieve dimensions without having access to a game instance.

fn get_features(&self) -> Self::Descriptor

Obtain game descriptor.

fn state_dimension(descr: &Self::Descriptor) -> Self::StateDim

Deduce state shape from game descriptor.

fn action_dimension(descr: &Self::Descriptor) -> Self::ActionDim

Deduce action shape from game descriptor.

fn state_to_feature(&self, pov: Self::Player) -> Array<f32, Self::StateDim>

Converts the game state to features (multi-dimensional array).

fn moves_to_feature(
    descr: &Self::Descriptor,
    moves: &HashMap<Self::Move, f32>
) -> Array<f32, Self::ActionDim>

Converts an action probability distribution to the action features.

fn feature_to_moves(
    &self,
    features: &Array<f32, Self::ActionDim>
) -> HashMap<Self::Move, f32>

Converts a move distribution feature to the corresponding set of move probabilities, relative to the game state.

fn all_feature_to_moves(
    descr: &Self::Descriptor,
    features: &Array<f32, Self::ActionDim>
) -> HashMap<Self::Move, f32>

Converts a move distribution feature to the corresponding set of move probabilities, independently from the game state.

fn all_possible_moves(descr: &Self::Descriptor) -> Vec<Self::Move>

Returns action space

fn move_to_feature(
    descr: &Self::Descriptor,
    action: Self::Move
) -> Array<f32, Self::ActionDim>

Converts a single move to a one-hot feature encoding of the move.

impl<G: Game + Clone + Sync + Send> Game for WithHistory<G>

type Player = G::Player

The type representing each player.

fn players() -> Vec<Self::Player>

Returns the list of players for the game.

fn player_after(player: Self::Player) -> Self::Player

Assuming a static player order, returns who should play after given player.

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

Returns whose turn it is.

impl<G: Base + Hash> Hash for WithHistory<G>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl<G: Base + PartialEq> PartialEq<WithHistory<G>> for WithHistory<G>

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<G: Playable + Clone + Sync + Send> Playable for WithHistory<G>

fn play<'life0, 'life1, 'async_trait>(
    &'life0 mut self,
    action: &'life1 Self::Move
) -> Pin<Box<dyn Future<Output = f32> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Mutates game state playing the given action. Yields a reward to the player.

#[must_use]fn random_move<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = (Self::Move, f32)> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: Send + 'async_trait, 

Plays a random move. Yields a reward.

impl<G: SingleWinner + Clone + Sync + Send> SingleWinner for WithHistory<G>

fn winner(&self) -> Option<G::Player>

Returns the winner of the game, or None if no one has won yet.