Struct board_game::games::dummy::DummyGame

pub struct DummyGame { /* private fields */ }

Trait Implementations

impl Board for DummyGame

type Move = usize

The type used to represent moves on this board.

fn next_player(&self) -> Player

Return the next player to make a move. If the board is done this is the player that did not play the last move for consistency.

fn is_available_move(&self, mv: Self::Move) -> Result<bool, BoardDone>

Return whether the given move is available.

fn play(&mut self, mv: Self::Move) -> Result<(), PlayError>

Play the move mv, modifying this board.

fn outcome(&self) -> Option<Outcome>

The outcome of this board, is None when this games is not done yet.

fn can_lose_after_move() -> bool

Whether the player who plays a move can lose by playing that move. Symbolically whether b.won_by() == Some(Winner::Player(b.next_player())) can ever be true. This may be pessimistic, returning true is always correct.

fn random_available_move( &self, rng: &mut impl Rng ) -> Result<Self::Move, BoardDone>

Pick a random move from the available_moves with a uniform distribution. Can be overridden for better performance.

fn clone_and_play(&self, mv: Self::Move) -> Result<Self, PlayError>

Clone this board, play mv on it and return the new board. Can be overridden for better performance.

fn is_done(&self) -> bool

Whether this games is done.

fn check_done(&self) -> Result<(), BoardDone>

Returns

fn check_can_play(&self, mv: Self::Move) -> Result<(), PlayError>

Returns

fn play_random_available_move( &mut self, rng: &mut impl Rng ) -> Result<(), BoardDone>

The same as self.play(self.random_available_move(rng)), but needs less error handling. Can be overridden for better performance by skipping the valid move check.

fn children(&self) -> Result<BoardChildrenIterator<'_, Self>, BoardDone>

The same as self.available_moves().map(|mv| self.clone_and_play(mv)), but needs less error handling. Can be overridden for better performance by skipping the valid move check.

impl<'a> BoardMoves<'a, DummyGame> for DummyGame

type AllMovesIterator = ClonableInternal<RangeFrom<usize>>

type AvailableMovesIterator = ClonableInternal<Range<usize>>

fn all_possible_moves() -> Self::AllMovesIterator

All theoretically possible moves, for any possible board. Moves returned by available_moves will always be a subset of these moves. The order of these moves does not need to match the order from available_moves.

fn available_moves(&'a self) -> Result<Self::AvailableMovesIterator, BoardDone>

Return an iterator over available moves, is always nonempty. No guarantees are made about the ordering except that it stays consistent when the board is not modified. Panics if this board is done.

impl BoardSymmetry<DummyGame> for DummyGame

type Symmetry = UnitSymmetry

The type used to represent symmetries.

type CanonicalKey = ()

The type used by Self::canonical_key.

fn map(&self, _: Self::Symmetry) -> Self

Map this board under the given symmetry.

fn map_move( &self, _: Self::Symmetry, mv: <DummyGame as Board>::Move ) -> <DummyGame as Board>::Move

Map a move under the given symmetry.

fn canonical_key(&self) -> Self::CanonicalKey

Extract all of the state from this board that can potentially change when calling Self::map. This is used by Self::canonicalize to determine which symmetry ends up as the canonical one for the given board.

fn canonicalize(&self) -> Self

Convert this board to a canonical version, by mapping it with the symmetry that results in the smallest Self::canonical_key.

impl Clone for DummyGame

fn clone(&self) -> DummyGame

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for DummyGame

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

Formats the value using the given formatter.

impl Display for DummyGame

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

Formats the value using the given formatter.

impl FromStr for DummyGame

type Err = Error<String>

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for DummyGame

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq<DummyGame> for DummyGame

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

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Alternating for DummyGame

impl Eq for DummyGame

impl StructuralEq for DummyGame

impl StructuralPartialEq for DummyGame