Enum Color 

#[repr(u8)]
pub enum Color {
    White = 0,
    Black = 1,
}

Represents the color of a player, piece, square, etc. within a chess board.

In Western chess, White traditionally moves first, and therefore Color defaults to Color::White.

Variants

White = 0

Black = 1

Implementations

impl Color

pub const COUNT: usize = 2usize

Number of color variants.

pub const fn all() -> [Color; 2]

An array of both colors, starting with White.

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

An iterator over both colors, starting with White.

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

Creates a new Color from a set of bits.

bits must be [0,1].

Panics

If bits is greater than 1.

Example

let white = Color::from_bits(0);
assert!(white.is_ok());
assert_eq!(white.unwrap(), Color::White);

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

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

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

bits must be [0,1].

Panics

If bits is greater than 1 and debug assertions are enabled.

Example

let white = Color::from_bits(0);
assert!(white.is_ok());
assert_eq!(white.unwrap(), Color::White);

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

pub const fn from_bool(color: bool) -> Color

Creates a new Color from a bool, where false = White.

Example

let white = Color::from_bool(false);
assert_eq!(white, Color::White);

let black = Color::from_bool(true);
assert_eq!(black, Color::Black);

pub const fn is_white(&self) -> bool

Returns true if this Color is White.

pub const fn is_black(&self) -> bool

Returns true if this Color is Black.

pub const fn negation_multiplier(&self) -> i8

Returns a multiplier for negating numbers relative to this color.

Example

assert_eq!(Color::White.negation_multiplier(), 1);
assert_eq!(Color::Black.negation_multiplier(), -1);

pub const fn opponent(&self) -> Color

Returns this Color’s opposite / inverse / enemy.

Example

assert_eq!(Color::White.opponent(), Color::Black);
assert_eq!(Color::Black.opponent(), Color::White);

pub const fn index(&self) -> usize

Returns this Color as a usize.

Will be 0 for White, 1 for Black.

Useful for indexing into lists.

Example

assert_eq!(Color::White.index(), 0);
assert_eq!(Color::Black.index(), 1);

pub const fn bits(&self) -> u8

Returns this Color as a u8.

Will be 0 for White, 1 for Black.

Useful for bit twiddling.

Example

assert_eq!(Color::White.bits(), 0);
assert_eq!(Color::Black.bits(), 1);

pub fn from_uci(color: char) -> Result<Color, Error>

Creates a Color from a char, according to the Universal Chess Interface notation.

Example

let white = Color::from_uci('w');
assert!(white.is_ok());
assert_eq!(white.unwrap(), Color::White);

let err = Color::from_uci('x');
assert!(err.is_err());

pub const fn from_case(c: char) -> Color

Creates a Color based on the ASCII case of the provided character, with uppercase being White and lowercase being Black.

Note this is intended to follow the Universal Chess Interface notation, but can be used in odd ways, such as trying to find the color of the char 'z' (Black).

Example

assert_eq!(Color::from_case('k'), Color::Black);

pub const fn to_uci(&self) -> char

Converts this Color to a char, according to the Universal Chess Interface notation.

Example

assert_eq!(Color::White.to_uci(), 'w');

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

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

Example

assert_eq!(Color::White.as_str(), "w");

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

Fetches a human-readable name for this Color.

Example

let white = Color::White;
assert_eq!(white.name(), "white");

Trait Implementations

impl AsRef<str> for Color

fn as_ref(&self) -> &str

Alias for Self::as_str.

impl Clone for Color

fn clone(&self) -> Color

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Color

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

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

impl Default for Color

fn default() -> Color

Returns the “default value” for a type.

impl Display for Color

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

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

impl FromStr for Color

fn from_str(s: &str) -> Result<Color, <Color 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 Color

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<Color> for Board

type Output = Bitboard

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl IndexMut<Color> for Board

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

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

impl Neg for Color

fn neg(self) -> <Color as Neg>::Output

Negating Color::White yields Color::Black and vice versa.

type Output = Color

The resulting type after applying the - operator.

impl Ord for Color

fn cmp(&self, other: &Color) -> 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 Color

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

fn partial_cmp(&self, other: &Color) -> 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 Color

impl Eq for Color

impl StructuralPartialEq for Color