Struct GoBoard

pub struct GoBoard { /* private fields */ }

Implementations

impl GoBoard

pub fn new(size: u8, komi: Komi, rules: Rules) -> GoBoard

pub fn from_parts( rules: Rules, chains: Chains, next_player: Player, state: State, history: IntSet<Zobrist>, komi: Komi, ) -> GoBoard

pub fn size(&self) -> u8

pub fn area(&self) -> u16

pub fn rules(&self) -> Rules

pub fn komi(&self) -> Komi

pub fn chains(&self) -> &Chains

pub fn state(&self) -> State

pub fn history(&self) -> &IntSet<Zobrist>

pub fn replace_history(&mut self, history: IntSet<Zobrist>) -> IntSet<Zobrist>

pub fn clear_history(&mut self)

pub fn clone_without_history(&self) -> Self

pub fn stone_count(&self) -> u16

pub fn stone_count_from(&self, player: Player) -> u16

pub fn empty_count(&self) -> u16

pub fn stone_at(&self, tile: Tile) -> Option<Player>

pub fn empty_tiles(&self) -> impl ExactSizeIterator<Item = Tile> + '_

pub fn current_score(&self) -> Score

pub fn territory(&self) -> Vec<Territory>

The territory map computed using Tromp-Taylor rules. The returned vec can be indexed by [FlatTile::index].

pub fn zobrist(&self) -> Zobrist

Full zobrist, including:

• the tiles
• the next player
• the pass state

pub fn random_available_place_move( &self, rng: &mut impl Rng, ) -> Result<Option<Move>, BoardDone>

pub fn assert_valid(&self)

impl GoBoard

pub fn to_fen(&self) -> String

pub fn from_fen(fen: &str, rules: Rules) -> Result<GoBoard, InvalidFen>

The fen format: "tiles next pass [komi]"

Trait Implementations

impl Board for GoBoard

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 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, GoBoard> for GoBoard

type AllMovesIterator = AllMovesIterator<GoBoard>

type AvailableMovesIterator = AvailableMovesIterator<'a, GoBoard>

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

type Symmetry = D4Symmetry

The type used to represent symmetries.

type CanonicalKey = Zobrist

The type used by Self::canonical_key.

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

Map this board under the given symmetry.

fn map_move(&self, sym: D4Symmetry, mv: Move) -> Move

Map a move under the given symmetry.

fn canonical_key(&self) -> Zobrist

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 GoBoard

fn clone(&self) -> GoBoard

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GoBoard

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

Formats the value using the given formatter.

impl Display for GoBoard

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

Formats the value using the given formatter.

impl Hash for GoBoard

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

fn eq(&self, other: &GoBoard) -> 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 Eq for GoBoard

impl StructuralPartialEq for GoBoard