Struct Position 

pub struct Position { /* private fields */ }

Piece occupancy for all 64 squares.

The internal array uses canonical A1-to-H8 indexing. Use Position::piece_at and Position::set_piece when the square is known by file and rank.

Realtime board updates carry positions through BoardEvent::PositionChanged.

Examples

use chessnut_move::protocol::{
    Color, File, Piece, PieceKind, Position, Rank, SQUARE_COUNT, Square,
};

let mut position = Position::new([None; SQUARE_COUNT]);
let e4 = Square::new(File::E, Rank::Four);
position.set_piece(
    e4,
    Some(Piece {
        color: Color::White,
        kind: PieceKind::Pawn,
    }),
);
assert!(position.piece_at(e4).is_some());

Implementations

impl Position

pub fn new(squares: [Option<Piece>; 64]) -> Self

Creates a position from squares in canonical A1-to-H8 order.

Index zero represents A1 and index 63 represents H8.

Examples

use chessnut_move::protocol::{
    Color, File, Piece, PieceKind, Position, Rank, SQUARE_COUNT, Square,
};

let white_king = Piece {
    color: Color::White,
    kind: PieceKind::King,
};
let e1 = Square::new(File::E, Rank::One);
let mut squares = [None; SQUARE_COUNT];
squares[e1.index()] = Some(white_king);

let position = Position::new(squares);
assert_eq!(position.piece_at(e1), Some(white_king));

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

Returns the piece occupying a square, or None when it is empty.

Examples

use chessnut_move::protocol::{
    BoardEvent, File, PieceKind, Rank, Square,
};

fn pawn_reached_e4(event: BoardEvent) -> bool {
    let BoardEvent::PositionChanged(position) = event else {
        return false;
    };

    position
        .piece_at(Square::new(File::E, Rank::Four))
        .is_some_and(|piece| piece.kind == PieceKind::Pawn)
}

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

Replaces the piece occupying a square.

Pass None to empty the square.

Examples

use chessnut_move::protocol::{
    AutoMoveMode, Command, File, Position, Rank, Square,
};

fn move_e2_to_e4(mut observed: Position) -> Command {
    let e2 = Square::new(File::E, Rank::Two);
    let e4 = Square::new(File::E, Rank::Four);
    let pawn = observed.piece_at(e2);

    observed.set_piece(e2, None);
    observed.set_piece(e4, pawn);
    Command::auto_move(observed, AutoMoveMode::Normal)
}

Trait Implementations

impl Clone for Position

fn clone(&self) -> Position

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Position

impl Debug for Position

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

Formats the value using the given formatter.

impl Eq for Position

impl Hash for Position

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 Position

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Position