96 lines
3 KiB
Rust
96 lines
3 KiB
Rust
//! UCI notation.
|
|
//!
|
|
//! Move notation as defined by the Universal Chess Interface standard used for most chess engines
|
|
//! and chess servers.
|
|
//!
|
|
//! A move is described by its origin and target squares. Castling is described as the move done by
|
|
//! the king. For promotion, a lowercase letter is added at the end of the move.
|
|
//!
|
|
//! Examples: *`e2e4`*, *`d1d8`*, *`e1g1`* (short castling), *`h7h8q`* (promotion)
|
|
|
|
use crate::board::*;
|
|
use crate::moves::*;
|
|
use crate::position::*;
|
|
|
|
/// **The UCI notation of a move.**
|
|
///
|
|
/// UCI notation can be obtained from a legal move using the [`Move::to_uci`] method.
|
|
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
pub struct UciMove {
|
|
pub from: Square,
|
|
pub to: Square,
|
|
pub promotion: Option<Role>,
|
|
}
|
|
|
|
impl core::fmt::Display for UciMove {
|
|
#[inline]
|
|
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
|
|
write!(f, "{}{}", self.from, self.to)?;
|
|
if let Some(promotion) = self.promotion {
|
|
write!(f, "{}", promotion.to_char_lowercase())?;
|
|
}
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl core::fmt::Debug for UciMove {
|
|
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> Result<(), core::fmt::Error> {
|
|
write!(f, "UciMove(\"{self}\")")
|
|
}
|
|
}
|
|
|
|
impl core::str::FromStr for UciMove {
|
|
type Err = ParseUciMoveError;
|
|
#[inline]
|
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
Self::from_ascii(s.as_bytes()).ok_or(ParseUciMoveError)
|
|
}
|
|
}
|
|
|
|
/// A syntax error when parsing a [`UciMove`].
|
|
#[derive(Debug)]
|
|
pub struct ParseUciMoveError;
|
|
impl core::fmt::Display for ParseUciMoveError {
|
|
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
|
|
f.write_str("invalid UCI notation")
|
|
}
|
|
}
|
|
impl core::error::Error for ParseUciMoveError {}
|
|
|
|
/// An error when converting [`UciMove`] notation to a playable [`Move`].
|
|
#[derive(Debug)]
|
|
pub enum InvalidUciMove {
|
|
/// The is no move on the position that matches the UCI notation.
|
|
Illegal,
|
|
}
|
|
impl core::fmt::Display for InvalidUciMove {
|
|
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
|
|
f.write_str("illegal UCI move")
|
|
}
|
|
}
|
|
impl core::error::Error for InvalidUciMove {}
|
|
|
|
impl UciMove {
|
|
/// Tries to convert UCI notation to a playable move.
|
|
#[inline]
|
|
pub fn to_move<'l>(&self, position: &'l Position) -> Result<Move<'l>, InvalidUciMove> {
|
|
position.move_from_uci(*self)
|
|
}
|
|
|
|
/// Tries to read UCI notation from ascii text.
|
|
#[inline]
|
|
pub fn from_ascii(s: &[u8]) -> Option<Self> {
|
|
match s {
|
|
[a, b, c, d, s @ ..] => Some(Self {
|
|
from: Square::from_coords(File::from_ascii(*a)?, Rank::from_ascii(*b)?),
|
|
to: Square::from_coords(File::from_ascii(*c)?, Rank::from_ascii(*d)?),
|
|
promotion: match s {
|
|
[] => None,
|
|
[c] => Some(Role::from_ascii(*c)?),
|
|
_ => return None,
|
|
},
|
|
}),
|
|
_ => None,
|
|
}
|
|
}
|
|
}
|