Enum stockfish_core::core::Square

#[repr(u8)]
pub enum Square {
    A1,
    B1,
    C1,
    D1,
    E1,
    F1,
    G1,
    H1,
    A2,
    B2,
    C2,
    D2,
    E2,
    F2,
    G2,
    H2,
    A3,
    B3,
    C3,
    D3,
    E3,
    F3,
    G3,
    H3,
    A4,
    B4,
    C4,
    D4,
    E4,
    F4,
    G4,
    H4,
    A5,
    B5,
    C5,
    D5,
    E5,
    F5,
    G5,
    H5,
    A6,
    B6,
    C6,
    D6,
    E6,
    F6,
    G6,
    H6,
    A7,
    B7,
    C7,
    D7,
    E7,
    F7,
    G7,
    H7,
    A8,
    B8,
    C8,
    D8,
    E8,
    F8,
    G8,
    H8,
}

A square on a chess board.

Variants

A1

B1

C1

D1

E1

F1

G1

H1

A2

B2

C2

D2

E2

F2

G2

H2

A3

B3

C3

D3

E3

F3

G3

H3

A4

B4

C4

D4

E4

F4

G4

H4

A5

B5

C5

D5

E5

F5

G5

H5

A6

B6

C6

D6

E6

F6

G6

H6

A7

B7

C7

D7

E7

F7

G7

H7

A8

B8

C8

D8

E8

F8

G8

H8

Implementations

impl Square

pub const COUNT: usize = 64usize

The total number of [$name]s.

pub const VARIANTS: [Square; 64] = _

All of the variants of [$name]s, indexable by their discriminant.

pub const NAMES: [&'static str; 64] = _

All of the variant names of [$name], indexable by their discriminant.

pub fn iter() -> IntoIter<Self, { _ }>

Returns an iterator through all [$type] variants.

pub fn name(self) -> &'static str

Returns the name of the variant as a string.

impl Square

pub const fn new(file: File, rank: Rank) -> Self

Creates a new square of the provided file and rank.

pub const fn file(self) -> File

Returns the file the square is on.

pub const fn rank(self) -> Rank

Returns the rank the square is on.

pub const fn is_dark(self) -> bool

Returns true if this is a dark-colored square.

pub const fn is_light(self) -> bool

Returns true if this is a light-colored square.

pub const fn flip_file(self) -> Self

Returns this square from the perspective of flipping the board left-to-right.

pub const fn flip_rank(self) -> Self

Returns this square from the perspective of flipping the board top-to-bottom.

pub const fn from_perspective(self, color: Color) -> Self

If color is Color::White, returns the original square. If color is Color::Black, returns the square on the same file but whose rank is from the black player’s perspective.

Examples

assert_eq!(Square::B3, Square::B3.from_perspective(Color::White));
assert_eq!(Square::B6, Square::B3.from_perspective(Color::Black));
assert_eq!(Square::C1, Square::C8.from_perspective(Color::Black));

pub const fn distance_files(self, other: Self) -> u8

The number of steps a king would have to move in order to be on the file of the other square.

pub const fn distance_ranks(self, other: Self) -> u8

The number of steps a king would have to move in order to be on the rank of the other square.

pub const fn distance(self, other: Self) -> u8

The number of steps a king would have to move in order to wind up on the other square.

pub fn wrapping_add(self, dir: Direction) -> Self

Performs wrapping addition of a Direction to a Square. Note that this wraps around files and ranks.

Examples:

assert_eq!(Square::C4, Square::A3.wrapping_add(Direction::ENE));
assert_eq!(Square::A5, Square::H5.wrapping_add(Direction::E));
assert_eq!(Square::D2, Square::D8.wrapping_add(Direction::NN));
assert_eq!(Square::H8, Square::A2.wrapping_add(Direction::SSW));

pub fn wrapping_sub(self, dir: Direction) -> Self

Performs wrapping addition of a Direction from a Square. Note that this wraps around files and ranks.

Trait Implementations

impl Add<Direction> for Square

type Output = Option<Square>

The resulting type after applying the + operator.

const fn add(self, rhs: Direction) -> Self::Output

Performs the + operation.

impl BitAnd<Square> for Bitboard

type Output = Bitboard

The resulting type after applying the & operator.

const fn bitand(self, rhs: Square) -> Self::Output

Performs the & operation.

impl BitAnd<Square> for Square

type Output = Bitboard

The resulting type after applying the & operator.

const fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl BitAndAssign<Square> for Bitboard

const fn bitand_assign(&mut self, rhs: Square)

Performs the &= operation.

impl BitOr<Square> for Bitboard

type Output = Bitboard

The resulting type after applying the | operator.

const fn bitor(self, rhs: Square) -> Self::Output

Performs the | operation.

impl BitOr<Square> for Square

type Output = Bitboard

The resulting type after applying the | operator.

const fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl BitOrAssign<Square> for Bitboard

const fn bitor_assign(&mut self, rhs: Square)

Performs the |= operation.

impl BitXor<Square> for Bitboard

type Output = Bitboard

The resulting type after applying the ^ operator.

const fn bitxor(self, rhs: Square) -> Self::Output

Performs the ^ operation.

impl BitXorAssign<Square> for Bitboard

const fn bitxor_assign(&mut self, rhs: Square)

Performs the ^= operation.

impl Clone for Square

const fn clone(&self) -> Square

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Square

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

Formats the value using the given formatter.

impl From<Square> for Bitboard

const fn from(s: Square) -> Self

Converts to this type from the input type.

impl From<Square> for File

const fn from(s: Square) -> Self

Converts to this type from the input type.

impl From<Square> for Rank

const fn from(s: Square) -> Self

Converts to this type from the input type.

impl From<Square> for u8

const fn from(this: Square) -> Self

Converts to this type from the input type.

impl From<Square> for usize

const fn from(this: Square) -> Self

Converts to this type from the input type.

impl<T> Index<Square> for [T; 64]

type Output = T

The returned type after indexing.

const fn index(&self, val: Square) -> &Self::Output

Performs the indexing (container[index]) operation.

impl Index<Square> for Board

type Output = Option<Piece>

The returned type after indexing.

const fn index(&self, index: Square) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T> IndexMut<Square> for [T; 64]

fn index_mut(&mut self, val: Square) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl IndexMut<Square> for Board

const fn index_mut(&mut self, index: Square) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl Not for Square

type Output = Bitboard

The resulting type after applying the ! operator.

const fn not(self) -> Self::Output

Performs the unary ! operation.

impl PartialEq<Square> for Square

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Square

impl Eq for Square

impl StructuralEq for Square

impl StructuralPartialEq for Square