Enum shakmaty::uci::Uci

pub enum Uci {
    Normal {
        from: Square,
        to: Square,
        promotion: Option<Role>,
    },
    Put {
        role: Role,
        to: Square,
    },
    Null,
}

A move as represented in the UCI protocol.

Variants

Normal

A normal move, e.g. e2e4 or h2h1q.

Fields of Normal

from: Squareto: Squarepromotion: Option<Role>

Put

A piece drop, e.g. Q@f7.

Fields of Put

role: Roleto: Square

Null

A null move (0000).

Implementations

impl Uci

pub fn from_ascii(uci: &[u8]) -> Result<Uci, ParseUciError>

Parses a move in UCI notation.

Errors

Returns ParseUciError if uci is not syntactically valid.

Examples

use shakmaty::uci::Uci;
use shakmaty::Square;

let uci = Uci::from_ascii(b"e4e5")?;

assert_eq!(uci, Uci::Normal {
    from: Square::E4,
    to: Square::E5,
    promotion: None,
});

pub fn from_standard(m: &Move) -> Uci

Converts a move to UCI notation. Castling moves are represented as a move of the king to its new position.

Warning: Using standard notation for castling moves in Chess960 may create moves that are illegal or moves that can be confused with king moves.

Examples

use shakmaty::uci::Uci;
use shakmaty::{Move, Square};

let m = Move::Castle {
    king: Square::E8,
    rook: Square::H8,
};

let uci = Uci::from_standard(&m);
assert_eq!(uci.to_string(), "e8g8");

pub fn from_chess960(m: &Move) -> Uci

Converts a move to UCI notation. Castling moves are represented as a move of the king to the corresponding rook square, independently of the position.

Examples

use shakmaty::uci::Uci;
use shakmaty::{Move, Square};

let m = Move::Castle {
    king: Square::E8,
    rook: Square::H8,
};

let uci = Uci::from_chess960(&m);
assert_eq!(uci.to_string(), "e8h8");

pub fn from_move(m: &Move, mode: CastlingMode) -> Uci

See Uci::from_standard() or Uci::from_chess960().

pub fn to_move<P: Position>(&self, pos: &P) -> Result<Move, IllegalUciError>

Tries to convert the Uci to a legal Move in the context of a position.

Errors

Returns IllegalUciError if the move is not legal.

Trait Implementations

impl Clone for Uci

pub fn clone(&self) -> Uci

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Uci

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

Formats the value using the given formatter.

impl Display for Uci

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

Formats the value using the given formatter.

impl Eq for Uci

impl FromStr for Uci

type Err = ParseUciError

The associated error which can be returned from parsing.

pub fn from_str(uci: &str) -> Result<Uci, ParseUciError>

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

impl Hash for Uci

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

Feeds this value into the given Hasher.

pub fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl PartialEq<Uci> for Uci

pub fn eq(&self, other: &Uci) -> bool

This method tests for self and other values to be equal, and is used by ==.

pub fn ne(&self, other: &Uci) -> bool

This method tests for !=.

impl StructuralEq for Uci

impl StructuralPartialEq for Uci