Struct AtaxxBoard

pub struct AtaxxBoard { /* private fields */ }

Implementations

impl AtaxxBoard

pub const MAX_SIZE: u8 = 8u8

pub fn from_parts( size: u8, tiles_a: BitBoard8, tiles_b: BitBoard8, gaps: BitBoard8, moves_since_last_copy: u8, next_player: Player, ) -> Self

pub fn diagonal(size: u8) -> Self

pub fn empty(size: u8) -> Self

pub fn valid_coord(&self, coord: Coord8) -> bool

pub fn full_mask(&self) -> BitBoard8

pub fn tile(&self, coord: Coord8) -> Option<Player>

pub fn moves_since_last_copy(&self) -> u8

pub fn size(&self) -> u8

pub fn tiles_a(&self) -> BitBoard8

pub fn tiles_b(&self) -> BitBoard8

pub fn gaps(&self) -> BitBoard8

pub fn free_tiles(&self) -> BitBoard8

pub fn must_pass(&self) -> bool

Returns whether the current played must pass. Returns false if the game is already done.

pub fn tiles_pov(&self) -> (BitBoard8, BitBoard8)

pub fn assert_valid(&self)

pub fn map_coord(&self, coord: Coord8, sym: D4Symmetry) -> Coord8

pub fn map_tiles(&self, tiles: BitBoard8, sym: D4Symmetry) -> BitBoard8

impl AtaxxBoard

pub fn from_fen(fen: &str) -> Result<AtaxxBoard, InvalidAtaxxFen>

pub fn to_fen(&self) -> String

Trait Implementations

impl Board for AtaxxBoard

type Move = 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> BoardMoves<'a, AtaxxBoard> for AtaxxBoard

type AllMovesIterator = AllMovesIterator<AtaxxBoard>

type AvailableMovesIterator = AvailableMovesIterator<'a, AtaxxBoard>

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<AtaxxBoard> for AtaxxBoard

type Symmetry = D4Symmetry

The type used to represent symmetries.

type CanonicalKey = (u64, u64, u64)

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: Move) -> 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 AtaxxBoard

fn clone(&self) -> AtaxxBoard

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AtaxxBoard

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

Formats the value using the given formatter.

impl Default for AtaxxBoard

fn default() -> Self

Returns the “default value” for a type.

impl Display for AtaxxBoard

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

Formats the value using the given formatter.

impl Hash for AtaxxBoard

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 Heuristic<AtaxxBoard> for AtaxxTileHeuristic

type V = i32

The type used to represent the heuristic value of a board.

fn value(&self, board: &AtaxxBoard, length: u32) -> Self::V

Return the heuristic value for the given board from the the next player POV. depth is the current depth, the number of moves played since the board the search was started on. Can be used to prefer faster wins or slower losses.

fn merge(old: Self::V, new: Self::V) -> (Self::V, Ordering)

Merge old and new into a new value, and compare their values. For standard minimax searches this can simply be implemented as: (max(old, new), new.cmp(old))

fn value_update( &self, board: &B, board_value: Self::V, board_length: u32, mv: B::Move, child: &B, ) -> Self::V

Return the value of child, given the previous board, its value and the move that was just played. This function can be overridden to improve performance.

impl PartialEq for AtaxxBoard

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Alternating for AtaxxBoard

impl Eq for AtaxxBoard

impl StructuralPartialEq for AtaxxBoard