Enum PieceKind

#[repr(u8)]
pub enum PieceKind {
    Pawn = 0,
    Knight = 1,
    Bishop = 2,
    Rook = 3,
    Queen = 4,
    King = 5,
}

Represents the kind (or “role”) that a chess piece can be.

These have no Color associated with them. See Piece.

Variants

Pawn = 0

Knight = 1

Bishop = 2

Rook = 3

Queen = 4

King = 5

Implementations

impl PieceKind

pub const COUNT: usize = 6usize

Number of piece variants.

pub const fn all() -> [PieceKind; 6]

An array of all 6 PieceKinds.

In the order: Pawn, Knight, Bishop, Rook, Queen, King.

pub const fn all_except_king() -> [PieceKind; 5]

An array of 5 non-King PieceKinds.

In the order: Pawn, Knight, Bishop, Rook, Queen.

pub fn iter() -> impl Iterator<Item = PieceKind>

An iterator over all PieceKinds, starting with Pawn.

pub fn from_bits(bits: u8) -> Result<PieceKind, Error>

Creates a new PieceKind from a set of bits.

bits must be [0,5].

Panics

If bits is greater than 5.

Example

let queen = PieceKind::from_bits(4);
assert!(queen.is_ok());
assert_eq!(queen.unwrap(), PieceKind::Queen);

let err = PieceKind::from_bits(42);
assert!(err.is_err());

pub const fn from_bits_unchecked(bits: u8) -> PieceKind

Creates a new PieceKind from a set of bits, ignoring safety checks.

bits must be [0,5].

Panics

If bits is greater than 5 when debug assertions are enabled.

Example

let queen = PieceKind::from_bits_unchecked(4);
assert_eq!(queen, PieceKind::Queen);

pub const fn bits(&self) -> u8

Fetches the internal bit value of this PieceKind.

Will always be [0,5].

Example

let bits = PieceKind::Queen.bits();
assert_eq!(bits, 4);

pub const fn index(&self) -> usize

Returns this PieceKind as a usize.

Useful for indexing into lists.

Will always be [0,5].

Example

let index = PieceKind::Queen.index();
assert_eq!(index, 4);

pub fn from_uci(kind: char) -> Result<PieceKind, Error>

Creates a new PieceKind from a character, according to the Universal Chess Interface notation.

Will return a anyhow::Error if kind is not a valid character.

Example

let queen = PieceKind::from_uci('Q');
assert!(queen.is_ok());
assert_eq!(queen.unwrap(), PieceKind::Queen);

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

Fetches a human-readable name for this PieceKind.

Example

let queen = PieceKind::Queen;
assert_eq!(queen.name(), "queen");

pub const fn to_uci(&self) -> char

Converts this PieceKind to a character, according to the Universal Chess Interface notation.

Will always be a lowercase letter.

Example

let queen = PieceKind::Queen;
assert_eq!(queen.to_uci(), 'q');

pub const fn char(&self) -> char

Alias for PieceKind::to_uci.

pub const fn as_str(&self) -> &'static str

Converts this PieceKind to a str, according to the Universal Chess Interface notation.

Will always be a lowercase letter.

Example

let queen = PieceKind::Queen;
assert_eq!(queen.as_str(), "q");

Trait Implementations

impl AsRef<str> for PieceKind

fn as_ref(&self) -> &str

Alias for Self::as_str.

impl Clone for PieceKind

fn clone(&self) -> PieceKind

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for PieceKind

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

Debug formatting displays a $type as its human-readable name and index value.

impl Display for PieceKind

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

By default, a $type displays as a lowercase char.

impl FromStr for PieceKind

fn from_str(s: &str) -> Result<PieceKind, <PieceKind as FromStr>::Err>

Does the same as Self::from_uci, but only if s is one character in length.

type Err = Error

The associated error which can be returned from parsing.

impl Hash for PieceKind

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

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 Index<PieceKind> for Board

type Output = Bitboard

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl IndexMut<PieceKind> for Board

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

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

impl Ord for PieceKind

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

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

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

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for PieceKind

fn eq(&self, other: &PieceKind) -> 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 PartialOrd for PieceKind

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl Copy for PieceKind

impl Eq for PieceKind

impl StructuralPartialEq for PieceKind