Struct shogi_core::Position

pub struct Position { /* private fields */ }

Available on crate feature alloc only.

A position. It provides sufficient data for legality checking.

Implementations

impl Position

#[export_name = "Position_inner"]

pub extern "C" fn inner(&self) -> &PartialPosition

Returns the inner PartialPosition.

#[export_name = "Position_initial_position"]

pub extern "C" fn initial_position(&self) -> &PartialPosition

Returns the initial position of Position, i.e., the position before any moves given to it.

pub fn startpos() -> Self

Creates a Position with the starting position of shogi.

#[no_mangle]

pub extern "C" fn Position_startpos() -> *mut Self

C interface of Position::startpos.

#[no_mangle]

pub unsafe extern "C" fn Position_destruct(ptr: *mut Self)

Destructs a Position.

Safety

ptr must be the one created by a function in this type.

pub fn arbitrary_position(p: PartialPosition) -> Self

Creates a Position with its initial position p.

#[export_name = "Position_side_to_move"]

pub extern "C" fn side_to_move(&self) -> Color

Finds which player is to move.

Examples:

let mut pos = Position::startpos();
assert_eq!(pos.side_to_move(), Color::Black);
pos.make_move(Move::Normal { from: Square::SQ_7G, to: Square::SQ_7F, promote: false }).unwrap();
assert_eq!(pos.side_to_move(), Color::White);

#[export_name = "Position_hand_of_a_player"]

pub extern "C" fn hand_of_a_player(&self, color: Color) -> Hand

Returns the Hand of a player.

pub fn hand_of_a_player_mut(&mut self, color: Color) -> &mut Hand

👎 Deprecated since 0.1.2:

This function can create inconsistent states. It will be removed in 0.2.0.

Gives the reference to the hand of the specified player.

This function makes no guarantee about the consistency of the position. Users should have a good reason when using it. Exported for parsers.

pub fn hand(&self, piece: Piece) -> Option<u8>

Returns how many pieces of piece are in hand.

If piece is not a valid piece in hand, this method returns None.

#[export_name = "Position_ply"]

pub extern "C" fn ply(&self) -> u16

Finds how many moves were made.

pub fn piece_at(&self, square: Square) -> Option<Piece>

Returns the Piece on the designated Square.

Examples:

let pos = Position::startpos();
let black_rook = pos.piece_at(Square::SQ_2H);
assert_eq!(black_rook, Some(Piece::B_R));
let vacant = pos.piece_at(Square::SQ_3H);
assert_eq!(vacant, None);

#[no_mangle]

pub extern "C" fn Position_piece_at(
    &self,
    square: Square
) -> OptionPiece

C interface to Position::piece_at.

pub fn piece_set(&mut self, square: Square, piece: Option<Piece>)

👎 Deprecated since 0.1.2:

This function can create inconsistent states. It will be removed in 0.2.0.

Place a piece on a square.

This function makes no guarantee about the consistency of the position. Users should have a good reason when using it.

#[export_name = "Position_occupied_bitboard"]

pub extern "C" fn occupied_bitboard(&self) -> Bitboard

Finds the subset of squares with a piece.

Since: 0.1.4

#[export_name = "Position_vacant_bitboard"]

pub extern "C" fn vacant_bitboard(&self) -> Bitboard

Finds the subset of squares with no pieces.

#[export_name = "Position_player_bitboard"]

pub extern "C" fn player_bitboard(&self, color: Color) -> Bitboard

Finds the subset of squares where a piece of the specified player is placed.

#[export_name = "Position_piece_bitboard"]

pub extern "C" fn piece_bitboard(&self, piece: Piece) -> Bitboard

Finds the subset of squares where a piece is placed.

Examples:

let pos = Position::startpos();
let black_rook = pos.piece_bitboard(Piece::B_R);
assert_eq!(black_rook, Bitboard::single(Square::SQ_2H));
let white_rook = pos.piece_bitboard(Piece::W_R);
assert_eq!(white_rook, Bitboard::single(Square::SQ_8B));

pub fn last_move(&self) -> Option<Move>

Returns the last move, if it exists.

Examples:

use shogi_core::Position;
assert_eq!(Position::startpos().last_move(), None);

pub fn last_compact_move(&self) -> Option<CompactMove>

Returns the last move, if it exists.

Examples:

use shogi_core::Position;
assert_eq!(Position::startpos().last_compact_move(), None);

pub fn moves(&self) -> &[Move]

Returns all moves made so far.

Examples:

use shogi_core::Position;
assert_eq!(Position::startpos().moves(), []);

Since: 0.1.2

#[no_mangle]

pub extern "C" fn Position_last_compact_move(
    &self
) -> OptionCompactMove

C interface to Position::last_compact_move.

pub fn make_move(&mut self, mv: Move) -> Option<()>

Makes a move. Note that this function will never check legality.

Returns Some(()) if the given move makes sense, i.e., moves a piece to another square or drops a piece on a vacant square.

If it returns None, it is guaranteed that self is not modified.

#[export_name = "Position_make_compact_move"]

pub extern "C" fn make_compact_move(&mut self, mv: CompactMove) -> bool

Makes a move. This function is a C-compatible counterpart of make_move. Note that this function will never check legality.

Returns true if the given move makes sense, i.e., moves a piece to another square or drops a piece on a vacant square.

If it returns false, it is guaranteed that self is not modified.

pub fn to_sfen_owned(&self) -> String

Returns the SFEN representation of the current position.

Examples:

let pos = Position::startpos();
let s = pos.to_sfen_owned();
assert_eq!(
    s,
    "lnsgkgsnl/1r5b1/ppppppppp/9/9/9/PPPPPPPPP/1B5R1/LNSGKGSNL b - 1",
);

#[export_name = "Position_to_sfen_c"]

pub unsafe extern "C" fn to_sfen_c(&self, ptr: *mut u8)

C interface of to_sfen.

Safety

This function writes to ptr at most 139 (= 129 + 1 + 1 + 1 + 0 + 1 + 5 + 1) bytes. Caller should ensure that ptr has enough space for that.

Trait Implementations

impl Clone for Position

fn clone(&self) -> Position

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Position

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

Formats the value using the given formatter.

impl Default for Position

fn default() -> Position

Returns the “default value” for a type.

impl Hash for Position

Available on crate feature hash only.

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 Ord for Position

Available on crate feature ord only.

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self where
    Self: PartialOrd<Self>, 

Restrict a value to a certain interval.

impl PartialEq<Position> for Position

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

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

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

This method tests for !=.

impl PartialOrd<Position> for Position

Available on crate feature ord only.

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Eq for Position

impl StructuralEq for Position

impl StructuralPartialEq for Position