Struct gameai::game::connectfour::ConnectFour

pub struct ConnectFour { /* fields omitted */ }

Trait Implementations

impl Hash for ConnectFour

fn hash<__H: Hasher>(&self, __arg_0: &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 Clone for ConnectFour

fn clone(&self) -> ConnectFour

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ConnectFour

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

Formats the value using the given formatter.

impl PartialEq for ConnectFour

fn eq(&self, __arg_0: &ConnectFour) -> bool

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

fn ne(&self, __arg_0: &ConnectFour) -> bool

This method tests for !=.

impl Eq for ConnectFour

impl Display for ConnectFour

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

Formats the value using the given formatter.

impl ParseGame for ConnectFour

fn parse_move(&self, input: &str) -> Option<Self::Move>

impl RandGame for ConnectFour

fn random_move<R: Rng>(&mut self, rng: &mut R) -> Option<ValidMoveMut<Self>>

fn random_outcome<R: Rng>(self, rng: &mut R) -> Option<Self::Agent>

fn monte_carlo<R: Rng>(self, rng: &mut R, trials: u32) -> u32

impl Game for ConnectFour

type Move = (usize, Self::Agent)

type Agent = Color

fn agent_id(&self, a: &Self::Agent) -> u32

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

fn ref_player(&self) -> Self::Agent

fn move_valid(&self, m: &Self::Move) -> bool

fn new(start: &Self::Agent) -> Self

fn to_act(&self) -> Self::Agent

fn player_weight(&self, p: &Self::Agent) -> Score

fn possible_moves(&self) -> Vec<ValidMove<Self>>

fn apply(&mut self, m: Self::Move)

fn has_won(&self, color: &Color) -> bool

fn try_move_mut(&mut self, m: Self::Move) -> bool

fn verify_move_mut(&mut self, m: Self::Move) -> Option<ValidMoveMut<Self>>

fn verify_move(self, m: Self::Move) -> Option<ValidMove<Self>>

fn has_winner(&self) -> bool

fn try_move(&mut self, m: Self::Move) -> bool

fn try_moves<I>(&mut self, moves: I) -> Vec<bool> where
    I: Iterator<Item = Self::Move>,