Enum Piece

pub enum Piece {
    WP,
    WN,
    WB,
    WR,
    WQ,
    WK,
    BP,
    BN,
    BB,
    BR,
    BQ,
    BK,
}

Value type wrapping a single integer representing one of the 12 different pieces in a game of chess.

Variants

WP

WN

WB

WR

WQ

WK

BP

BN

BB

BR

BQ

BK

Implementations

impl Piece

pub fn all() -> impl Iterator<Item = Piece>

Create an iterator traversing over all pieces in order.

pub fn whites() -> impl Iterator<Item = Piece>

Create an iterator traversing over all white pieces in order.

pub fn blacks() -> impl Iterator<Item = Piece>

Create an iterator traversing over all black pieces in order.

pub fn king(side: Side) -> Piece

Returns the king which belongs to the given side.

pub fn queen(side: Side) -> Piece

Returns the queen which belongs to the given side.

pub fn rook(side: Side) -> Piece

Returns the rook belonging to the given side.

pub fn pawn(side: Side) -> Piece

Returns the pawn which belongs to the given side.

pub fn of(side: Side) -> impl Iterator<Item = Piece>

Returns a slice containing all pieces belonging to the given side.

pub fn side(self) -> Side

Returns the side that this piece belongs to.

pub fn is_pawn(self) -> bool

Checks whether this piece is either a white or black pawn.

pub fn is_knight(self) -> bool

Checks whether this piece is either a white or black knight.

pub fn control( self, loc: Square, whites: BitBoard, blacks: BitBoard, ) -> BitBoard

Computes the control set for this piece given it’s location and the locations of all the white and black pieces on the board.

pub fn empty_control(self, loc: Square) -> BitBoard

Computes the control set for this piece given it’s location on an empty board.

pub fn moves(self, loc: Square, whites: BitBoard, blacks: BitBoard) -> BitBoard

Computes the set of legal moves for this piece given it’s location and the locations of all the white and black pieces on the board. Note that this method does not take into account special restrictions for or due to the king, e.g. can’t move in such a way to put the king into check.

Trait Implementations

impl<O: Into<EnumSet<Piece>>> BitAnd<O> for Piece

type Output = EnumSet<Piece>

The resulting type after applying the & operator.

fn bitand(self, other: O) -> Self::Output

Performs the & operation.

impl<O: Into<EnumSet<Piece>>> BitOr<O> for Piece

type Output = EnumSet<Piece>

The resulting type after applying the | operator.

fn bitor(self, other: O) -> Self::Output

Performs the | operation.

impl<O: Into<EnumSet<Piece>>> BitXor<O> for Piece

type Output = EnumSet<Piece>

The resulting type after applying the ^ operator.

fn bitxor(self, other: O) -> Self::Output

Performs the ^ operation.

impl Clone for Piece

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Piece

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

Formats the value using the given formatter.

impl Display for Piece

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

Formats the value using the given formatter.

impl EnumSetTypePrivate for Piece

const CONST_HELPER_INSTANCE: __EnumSetConstHelper = __EnumSetConstHelper

The instance of the ConstHelper.

const ALL_BITS: Self::Repr = {transmute(0x0fff): <pieces::Piece as enumset::__internal::EnumSetTypePrivate>::Repr}

A mask of bits that are valid in the bitset.

const BIT_WIDTH: u32 = 12u32

The largest bit used in the bitset.

const VARIANT_COUNT: u32 = 12u32

The number of variants in the bitset.

type ConstHelper = __EnumSetConstHelper

A helper type used to implement the enum_set! macro among other things.

type Repr = u16

The underlying type used to store the bitset.

fn enum_into_u32(self) -> u32

Converts an enum of this type into its bit position.

unsafe fn enum_from_u32(val: u32) -> Self

Converts a bit position into an enum value.

impl FromStr for Piece

type Err = Error

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for Piece

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 Not for Piece

type Output = EnumSet<Piece>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl Ord for Piece

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

fn eq(&self, other: &EnumSet<Piece>) -> 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 PartialEq for Piece

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

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

We reflect a piece to it’s correspondent on the opposite side.

fn reflect(&self) -> Self

impl<O: Into<EnumSet<Piece>>> Sub<O> for Piece

type Output = EnumSet<Piece>

The resulting type after applying the - operator.

fn sub(self, other: O) -> Self::Output

Performs the - operation.

impl Copy for Piece

impl EnumSetType for Piece

impl Eq for Piece