Struct Move 

pub struct Move {
    pub piece: Piece,
    pub from: Position,
    pub to: Position,
    pub move_type: MoveType,
    pub captured_piece: Option<PieceType>,
    pub rook_from: Option<Position>,
    pub ambiguity: (bool, bool),
    pub check: bool,
    pub checkmate: bool,
}

Represents a move in a chess game

Fields

piece: Piece

The Piece that is moving

from: Position

The Position the piece is moving from

to: Position

The Position the piece is moving to

move_type: MoveType

The type of the move

captured_piece: Option<PieceType>

The type of the piece that is captured, if any

rook_from: Option<Position>

The position of the rook, if the move is a castle

ambiguity: (bool, bool)

A tuple of booleans representing the ambiguity of the move

check: bool

Whether the move puts the opponent in check

checkmate: bool

Whether the move puts the opponent in checkmate

Implementations

impl Move

pub fn new( piece: Piece, from: Position, to: Position, move_type: MoveType, captured_piece: Option<PieceType>, rook_from: Option<Position>, ambiguity: (bool, bool), check: bool, checkmate: bool, ) -> Result<Move, MoveInfoError>

Creates a new Move

Arguments

• piece: The Piece that is moving
• from: The Position the piece is moving from
• to: The Position the piece is moving to
• move_type: The type of the move
• captured_piece: The Piece that is captured, if any
• rook_from: The Position of the rook, if the move is a castle
• ambiguity: A tuple of booleans representing the ambiguity of the move
• check: Whether the move puts the opponent in check
• checkmate: Whether the move puts the opponent in checkmate

Returns

A Result<Move, MoveInfoError>

• Ok(Move): The move if it is valid
• Err(MoveInfoError): The error if the move is invalid

Example

use chess_lab::core::{Color, PieceType, Piece, Position, Move, MoveType};

let piece = Piece::new(Color::White, PieceType::Pawn);
let from = Position::new(4, 1).unwrap();
let to = Position::new(4, 3).unwrap();
let move_type = MoveType::Normal {
    capture: false,
    promotion: None,
};
let captured_piece = None;
let rook_from = None;
let ambiguity = (false, false);
let mv = Move::new(
    piece,
    from,
    to,
    move_type,
    captured_piece,
    rook_from,
    ambiguity,
    false,
    false
).unwrap();

assert_eq!(mv.to_string(), "e4");

Trait Implementations

impl Clone for Move

fn clone(&self) -> Move

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Move

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

Formats the value using the given formatter.

impl Display for Move

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

Formats the value using the given formatter.

impl PartialEq for Move

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