Struct shogai::board::Board

pub struct Board {
    pub turn: Color,
    pub rules: Rules,
    // some fields omitted
}

Fields

turn: Color

rules: Rules

Implementations

impl Board

pub fn empty() -> Self

return an empty shogiban

pub fn get_color(&self) -> Color

return the turn (as White-Black Color, easier to visualize than a boolean)

pub fn get_turn(&self) -> bool

return whether the current player is the first player (true) or the second (false)

pub fn value(&self) -> i32

return the value of the shogiban for the current player (sum of his pieces value minus sum of opponent's pieces)

pub fn game_over(&self) -> bool

return whether the current player is checkmated

pub fn contains(&self, pc: PieceType, color: Color) -> bool

return whether the board (not the reserve) contains a piece of given type and color there may be such a pieces in one's

pub fn play_move(&self, mv: &str) -> Board

Play a move (but check if it is legal beforehand, else panic with a nice error message) and return a new board containing pieces in their new position

pub fn play_move_unchecked(&self, mv: &str) -> Board

Play a move and return a new board, but do no check if the move is legal, or even syntaxically correct. If given a illegal/incorrect move, this function will probably panic

pub fn check_move<'a>(
    &'a self,
    mv: &'a str
) -> Result<&'a str, InvalidMoveError>

Check if a move is 100% valid

pub fn check_move_partial<'a>(
    &'a self,
    mv: &'a str
) -> Result<&'a str, InvalidMoveError>

Check move, but not whether the king is uncovered or if the king is checkmated by a pawn drop

pub fn is_occupied_by(&self, pos: Position) -> Option<Piece>

return Some(the_piece_in_that_position) or None if nothing was found there

pub fn add_piece(&mut self, piece: Piece)

add a piece to the board

pub fn flip(&mut self)

centrally rotate the board

pub fn set(&mut self, col: Color)

set the regular starting position for one player

pub fn new<'a>() -> Board

create new default board with the starting configuration

pub fn iter(&self) -> impl Iterator<Item = &Piece>

iter over all the pieces in the board (and reserve)

pub fn iter_pawns(&self, c: Color) -> impl Iterator<Item = &Piece>

iter over the pawns of the specified color

pub fn iter_pieces(&self, c: Color) -> impl Iterator<Item = &Piece>

iterate over the pieces (not pawns) of the specified color

pub fn iter_moves(&self) -> impl Iterator<Item = String>

iter over all possible moves

pub fn iter_moves_partial_check(&self) -> impl Iterator<Item = String>

iter over all possible moves without considering uncovering the king of pawn-drop ceckmate

pub fn iter_normal_moves_only(
    &self,
    complete_check: bool
) -> impl Iterator<Item = String>

iter only over the normal (not drops)

Trait Implementations

impl Clone for Board

fn clone(&self) -> Board

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Board

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

Formats the value using the given formatter.

impl Display for Board

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

Formats the value using the given formatter.

impl Eq for Board

impl Hash for Board

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, 

Feeds a slice of this type into the given [Hasher].

impl PartialEq<Board> for Board

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

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

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

This method tests for !=.

impl StructuralEq for Board

impl StructuralPartialEq for Board