Struct board_game::games::max_length::MaxMovesBoard

pub struct MaxMovesBoard<B: Board> { /* private fields */ }

A wrapper around an existing board that has the same behaviour, except that the outcome is a draw after a fixed number of moves has been played.

Implementations

impl<B: Board> MaxMovesBoard<B>

pub fn new(inner: B, max_moves: u64) -> Self

pub fn inner(&self) -> &B

pub fn into_inner(self) -> B

Trait Implementations

impl<B: Board> Board for MaxMovesBoard<B>

type Move = <B as Board>::Move

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 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 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 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, B: Board> BoardMoves<'a, MaxMovesBoard<B>> for MaxMovesBoard<B>

type AllMovesIterator = <B as BoardMoves<'a, B>>::AllMovesIterator

type AvailableMovesIterator = <B as BoardMoves<'a, B>>::AvailableMovesIterator

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<B: Board> BoardSymmetry<MaxMovesBoard<B>> for MaxMovesBoard<B>

type Symmetry = <B as BoardSymmetry<B>>::Symmetry

The type used to represent symmetries.

type CanonicalKey = <B as BoardSymmetry<B>>::CanonicalKey

The type used by Self::canonical_key.

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

Map this board under the given symmetry.

fn map_move(&self, sym: Self::Symmetry, mv: B::Move) -> B::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<B: Clone + Board> Clone for MaxMovesBoard<B>

fn clone(&self) -> MaxMovesBoard<B>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<B: Debug + Board> Debug for MaxMovesBoard<B>

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

Formats the value using the given formatter.

impl<B: Board> Display for MaxMovesBoard<B>

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

Formats the value using the given formatter.

impl<B: Hash + Board> Hash for MaxMovesBoard<B>

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<B: PartialEq + Board> PartialEq<MaxMovesBoard<B>> for MaxMovesBoard<B>

fn eq(&self, other: &MaxMovesBoard<B>) -> 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<B: Eq + Board> Eq for MaxMovesBoard<B>

impl<B: Board> StructuralEq for MaxMovesBoard<B>

impl<B: Board> StructuralPartialEq for MaxMovesBoard<B>