Enum Piece

pub enum Piece {
    King(Color, Position),
    Queen(Color, Position),
    Rook(Color, Position),
    Bishop(Color, Position),
    Knight(Color, Position),
    Pawn(Color, Position),
}

A piece on a board.

Every piece has both a color and a position. These, combined with the type of piece it is, determine things like

1. The validity of legal moves
2. The validity of legal attacks
3. Move generation
4. Material and positional value

Variants

King(Color, Position)

Queen(Color, Position)

Rook(Color, Position)

Bishop(Color, Position)

Knight(Color, Position)

Pawn(Color, Position)

Implementations

impl Piece

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

Get the name of the piece such as "pawn" or "king". All names are lowercase.

Examples found in repository

examples/terminal.rs (line 30)

fn get_cpu_move(b: &Board, best: bool) -> Move {
    let (m, count, _) = if best {
        b.get_best_next_move(4)
    } else {
        b.get_worst_next_move(4)
    };

    print!("CPU evaluated {} moves before choosing to ", count);
    match m {
        Move::Piece(from, to) => match (b.get_piece(from), b.get_piece(to)) {
            (Some(piece), Some(takes)) => println!(
                "take {}({}) with {}({})",
                takes.get_name(),
                to,
                piece.get_name(),
                from
            ),
            (Some(piece), None) => {
                println!("move {}({}) to {}", piece.get_name(), from, to)
            }
            _ => println!("move {} to {}", from, to),
        },
        Move::KingSideCastle => {
            println!("castle kingside")
        }
        Move::QueenSideCastle => {
            println!("castle queenside")
        }
        Move::Resign => println!("resign"),
    }

    m
}

pub fn get_material_value(&self) -> i32

Get the material value for a piece.

Name	Value
King	99999
Queen	9
Rook	5
Bishop	3
Knight	3
Pawn	1

pub fn get_weighted_value(&self) -> f64

Get the weighted value of a piece. This simply factors in position to the pieces value. For example, a knight that is in the center is more favorable than a knight on the side of the board. Similarly, a king in the center of the board is highly unfavorable compared to a king its respective side.

Additionally, the weighted value of the piece is 10 times greater than its material value, plus or minus a weight ranging between 5.0 and -5.0.

pub fn with_color(&self, color: Color) -> Self

Get the color of a given piece.

pub fn get_color(&self) -> Color

Get the color of a given piece.

pub fn get_pos(&self) -> Position

Get the position of a piece.

pub fn is_king(&self) -> bool

Is this piece a king?

pub fn is_queen(&self) -> bool

Is this piece a queen?

pub fn is_rook(&self) -> bool

Is this piece a rook?

pub fn is_bishop(&self) -> bool

Is this piece a bishop?

pub fn is_knight(&self) -> bool

Is this piece a knight?

pub fn is_pawn(&self) -> bool

Is this piece a pawn?

pub fn is_starting_pawn(&self) -> bool

Is this piece a starting pawn?

A starting pawn is a pawn that has not been pushed yet whatsoever.

pub fn is_queenside_rook(&self) -> bool

Is this piece in the starting position for the queenside rook?

This method will only return true for rooks that are in the position of the queenside rook, not for any particular rook.

pub fn is_kingside_rook(&self) -> bool

Is this piece in the starting position for the kingside rook?

This method will only return true for rooks that are in the position of the kingside rook, not for any particular rook.

pub fn move_to(&self, new_pos: Position) -> Self

Change the position of this piece to a new position.

For example, Pawn(Color::White, E4).move_to(E5) will result in Pawn(Color::White, E5). This does not check for move legality, it merely creates a new piece with the same color and type, but with a new position.

Trait Implementations

impl Clone for Piece

fn clone(&self) -> Piece

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<(), Error>

Formats the value using the given formatter.

impl From<Piece> for Square

fn from(piece: Piece) -> Self

Converts to this type from the input type.

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

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

impl Eq for Piece

impl StructuralPartialEq for Piece