Struct ggpf::game::breakthrough::Breakthrough

pub struct Breakthrough { /* fields omitted */ }

Breakthrough game state instance

Methods

impl Breakthrough

pub fn show(&self)

Prints a nice representation of the board.

Trait Implementations

impl Base for Breakthrough

type Move = 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 Clone for Breakthrough

fn clone(&self) -> Breakthrough

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Breakthrough

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

Formats the value using the given formatter.

impl Eq for Breakthrough

impl Features for Breakthrough

type StateDim = Ix3

Type dimension of the game state feature space.

type ActionDim = Ix3

Type dimension of the action feature space.

type Descriptor = usize

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(K: &Self::Descriptor) -> Self::StateDim

Deduce state shape from game descriptor.

fn action_dimension(K: &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(K: &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 Game for Breakthrough

type Player = Color

The type representing each player.

fn players() -> Vec<Color>

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) -> Color

Returns whose turn it is.

impl Hash for Breakthrough

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 PartialEq<Breakthrough> for Breakthrough

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 Playable for Breakthrough

fn play<'life0, 'life1, 'async_trait>(
    &'life0 mut self,
    m: &'life1 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 SingleWinner for Breakthrough

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

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

impl StructuralEq for Breakthrough