Struct ggpf::game::meta::simulated::Simulated

pub struct Simulated<G> where
    G: Features,  { /* fields omitted */ }

Simulated game

Methods

impl<G> Simulated<G> where
    G: Features, 

pub fn new(
    turn: G::Player,
    repr_state: Array<f32, Ix3>,
    game_descriptor: G::Descriptor,
    initial_possible_moves: Vec<G::Move>,
    dynamics_evaluator: Sender<DynamicsEvaluatorChannel>,
    support_size: usize
) -> Self

Instanciate a new simulated game.

Params

• turn: starting player.
• repr_state: initial repr state.
• initial_possible_moves: available moves for the initial state.
• dynamics_evaluator: evaluator for the dynamics network.

Trait Implementations

impl<G> Base for Simulated<G> where
    G: Features + 'static, 

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 for Simulated<G> where
    G: Features, 

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<G> Debug for Simulated<G> where
    G: Features, 

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

Formats the value using the given formatter.

impl<G> Features for Simulated<G> where
    G: Features + 'static, 

type StateDim = Ix3

Type dimension of the game state feature space.

type ActionDim = G::ActionDim

Type dimension of the action feature space.

type Descriptor = (Ix3, 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_possible_moves(descr: &Self::Descriptor) -> Vec<Self::Move>

Returns action space

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 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 for Simulated<G> where
    G: Features + 'static, 

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> Playable for Simulated<G> where
    G: Features + 'static, 

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.