Struct Position 

pub struct Position {
    pub col: u8,
    pub row: u8,
}

Represents a position on the board. The position is represented by a column and a row.

Examples

use chess_lab::core::Position;

let pos = Position::new(0, 0).unwrap();

assert_eq!(pos.to_string(), "a1");

let pos = Position::from_string("a1").unwrap();

assert_eq!(pos.col, 0);
assert_eq!(pos.row, 0);

Fields

col: u8

The column of the position (between 0 and 7)

row: u8

The row of the position (between 0 and 7)

Implementations

impl Position

pub fn new(col: u8, row: u8) -> Result<Position, PositionOutOfRangeError>

Creates a new position

Arguments

• col: The column of the position (between 0 and 7)
• row: The row of the position (between 0 and 7)

Returns

• Ok(Position): The new position
• Err(PositionOutOfRangeError): If the position is out of range

Examples

use chess_lab::core::Position;

let pos = Position::new(0, 0).unwrap();

assert_eq!(pos.col, 0);
assert_eq!(pos.row, 0);

pub fn from_string(s: &str) -> Result<Position, PositionInvalidError>

Creates a new position from a string

Arguments

• s: The string representation of the position

Returns

• Ok(Position): The new position
• Err(PositionInvalidError): If the string is invalid

Examples

use chess_lab::core::Position;

let pos = Position::from_string("a1").unwrap();

assert_eq!(pos.col, 0);
assert_eq!(pos.row, 0);

pub fn to_bitboard(&self) -> u64

Converts the position to a string

Returns

The string representation of the position

Examples

use chess_lab::core::Position;

let pos = Position::new(0, 0).unwrap();

assert_eq!(pos.to_bitboard(), 0x0000000000000001);

pub fn from_bitboard(bitboard: u64) -> Vec<Position>

Converts a bitboard to a list of positions

Arguments

• bitboard: The bitboard to convert

Returns

A list of positions

Examples

use chess_lab::core::Position;

let positions = Position::from_bitboard(0x0000000000000001);

assert_eq!(positions.len(), 1);
assert_eq!(positions[0].to_string(), "a1");

pub fn direction(&self, other: &Position) -> (i8, i8)

Gets the direction between two positions

Arguments

• other: The other position

Returns

The direction between the two positions

Examples

use chess_lab::core::Position;

let pos1 = Position::new(0, 0).unwrap();
let pos2 = Position::new(1, 1).unwrap();

let direction = pos1.direction(&pos2);

assert_eq!(direction, (1, 1));

Trait Implementations

impl Add<(i8, i8)> for &Position

fn add(self, other: (i8, i8)) -> Position

Adds a certain offset to the position

Arguments

• other: The offset to add

Returns

The new position

Examples

use chess_lab::core::Position;

let pos = Position::new(0, 0).unwrap();
let new_pos = &pos + (1, 1);

assert_eq!(new_pos.col, 1);
assert_eq!(new_pos.row, 1);

type Output = Position

The resulting type after applying the + operator.

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

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

Formats the value using the given formatter.

impl Display for Position

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

Formats the value using the given formatter.

impl PartialEq for Position

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

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

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 Sub<&Position> for &Position

fn sub(self, other: &Position) -> (i8, i8)

Gets the offset between two positions

Arguments

• other: The other position

Returns

The offset between the two positions

Examples

use chess_lab::core::Position;

let pos1 = Position::new(0, 0).unwrap();
let pos2 = Position::new(1, 1).unwrap();

let offset = &pos1 - &pos2;

assert_eq!(offset, (-1, -1));

type Output = (i8, i8)

The resulting type after applying the - operator.

impl Sub<(i8, i8)> for &Position

fn sub(self, other: (i8, i8)) -> Position

Subtracts a certain offset from the position

Arguments

• other: The offset to subtract

Returns

The new position

Examples

use chess_lab::core::Position;

let pos = Position::new(1, 1).unwrap();
let new_pos = &pos - (1, 1);

assert_eq!(new_pos.col, 0);
assert_eq!(new_pos.row, 0);

type Output = Position

The resulting type after applying the - operator.

impl Copy for Position

impl Eq for Position

impl StructuralPartialEq for Position