chessfriend/core/src/shapes.rs

// Eryn Wells <eryn@erynwells.me>

use std::{array, fmt, slice, str::FromStr};
use thiserror::Error;

#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
pub enum Shape {
    Pawn = 0,
    Knight = 1,
    Bishop = 2,
    Rook = 3,
    Queen = 4,
    King = 5,
}

impl Shape {
    /// Number of piece shapes
    pub const NUM: usize = 6;

    /// A slice of all piece shapes
    pub const ALL: [Shape; Self::NUM] = [
        Shape::Pawn,
        Shape::Knight,
        Shape::Bishop,
        Shape::Rook,
        Shape::Queen,
        Shape::King,
    ];

    const PROMOTABLE_SHAPES: [Shape; 4] = [Shape::Queen, Shape::Rook, Shape::Bishop, Shape::Knight];

    pub fn iter() -> slice::Iter<'static, Self> {
        Shape::ALL.iter()
    }

    #[must_use]
    pub fn into_iter() -> array::IntoIter<Self, { Self::NUM }> {
        Shape::ALL.into_iter()
    }

    /// An iterator over the shapes that a pawn can promote to
    pub fn promotable() -> slice::Iter<'static, Shape> {
        Self::PROMOTABLE_SHAPES.iter()
    }

    #[must_use]
    pub const fn to_ascii(self) -> char {
        match self {
            Shape::Pawn => 'P',
            Shape::Knight => 'N',
            Shape::Bishop => 'B',
            Shape::Rook => 'R',
            Shape::Queen => 'Q',
            Shape::King => 'K',
        }
    }

    #[must_use]
    pub const fn name(self) -> &'static str {
        match self {
            Shape::Pawn => "pawn",
            Shape::Knight => "knight",
            Shape::Bishop => "bishop",
            Shape::Rook => "rook",
            Shape::Queen => "queen",
            Shape::King => "king",
        }
    }

    #[must_use]
    pub fn is_promotable(&self) -> bool {
        Self::PROMOTABLE_SHAPES.contains(self)
    }
}

#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
pub enum Slider {
    Bishop,
    Rook,
    Queen,
}

impl From<Slider> for Shape {
    fn from(value: Slider) -> Self {
        match value {
            Slider::Bishop => Shape::Bishop,
            Slider::Rook => Shape::Rook,
            Slider::Queen => Shape::Queen,
        }
    }
}

impl TryFrom<Shape> for Slider {
    type Error = ();

    fn try_from(value: Shape) -> Result<Self, Self::Error> {
        match value {
            Shape::Bishop => Ok(Slider::Bishop),
            Shape::Rook => Ok(Slider::Rook),
            Shape::Queen => Ok(Slider::Queen),
            _ => Err(()),
        }
    }
}

#[derive(Clone, Copy, Debug, Error, Eq, PartialEq)]
#[error("no matching piece shape for character '{0:?}'")]
pub struct ShapeFromCharError(char);

impl TryFrom<char> for Shape {
    type Error = ShapeFromCharError;

    fn try_from(value: char) -> Result<Self, Self::Error> {
        match value {
            'P' | 'p' => Ok(Shape::Pawn),
            'N' | 'n' => Ok(Shape::Knight),
            'B' | 'b' => Ok(Shape::Bishop),
            'R' | 'r' => Ok(Shape::Rook),
            'Q' | 'q' => Ok(Shape::Queen),
            'K' | 'k' => Ok(Shape::King),
            _ => Err(ShapeFromCharError(value)),
        }
    }
}

#[derive(Clone, Copy, Debug, Error, Eq, PartialEq)]
#[error("no matching piece shape for string")]
pub struct ParseShapeError;

impl FromStr for Shape {
    type Err = ParseShapeError;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s.to_lowercase().as_str() {
            "p" | "pawn" => Ok(Shape::Pawn),
            "n" | "knight" => Ok(Shape::Knight),
            "b" | "bishop" => Ok(Shape::Bishop),
            "r" | "rook" => Ok(Shape::Rook),
            "q" | "queen" => Ok(Shape::Queen),
            "k" | "king" => Ok(Shape::King),
            _ => Err(ParseShapeError),
        }
    }
}

impl From<&Shape> for char {
    fn from(shape: &Shape) -> char {
        char::from(*shape)
    }
}

impl From<Shape> for char {
    fn from(shape: Shape) -> char {
        shape.to_ascii()
    }
}

impl fmt::Display for Shape {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let self_char: char = self.into();
        write!(f, "{self_char}")
    }
}