add age

2026-01-26 20:00:50 +05:30
parent dc61d6d956
commit 280150b0b0
18 changed files with 779 additions and 325 deletions
@@ -1,5 +1,25 @@
 #[derive(Clone, Eq, Hash, Copy, Debug, PartialEq)]
-pub enum Piece {
+pub struct Piece {
+    pub kind: PieceKind,
+    pub moves_made: u32,
+    pub active: bool,
+}
+impl Piece {
+    pub fn new(kind: PieceKind) -> Self {
+        Self {
+            kind,
+            moves_made: 0,
+            active: true,
+        }
+    }
+
+    pub fn from_kind(kind: Option<PieceKind>) -> Option<Self> {
+        kind.map(|k| Piece::new(k))
+    }
+}
+
+#[derive(Clone, Eq, Hash, Copy, Debug, PartialEq)]
+pub enum PieceKind {
    King,
    Queen,
    Bishop,
@@ -8,15 +28,15 @@ pub enum Piece {
    Pawn,
 }

-impl Piece {
+impl PieceKind {
    pub fn parse(piece: &str) -> Option<Self> {
        match piece {
-            "K" => Some(Piece::King),
-            "Q" => Some(Piece::Queen),
-            "B" => Some(Piece::Bishop),
-            "N" => Some(Piece::Knight),
-            "R" => Some(Piece::Rook),
-            "P" => Some(Piece::Pawn),
+            "K" => Some(PieceKind::King),
+            "Q" => Some(PieceKind::Queen),
+            "B" => Some(PieceKind::Bishop),
+            "N" => Some(PieceKind::Knight),
+            "R" => Some(PieceKind::Rook),
+            "P" => Some(PieceKind::Pawn),
            "." => None,
            p => panic!("Invalid piece {}", p),
        }
@@ -24,12 +44,12 @@ impl Piece {

    pub fn notation(&self) -> String {
        let n = match self {
-            Piece::King => "K",
-            Piece::Queen => "Q",
-            Piece::Bishop => "B",
-            Piece::Knight => "N",
-            Piece::Rook => "R",
-            Piece::Pawn => "P",
+            PieceKind::King => "K",
+            PieceKind::Queen => "Q",
+            PieceKind::Bishop => "B",
+            PieceKind::Knight => "N",
+            PieceKind::Rook => "R",
+            PieceKind::Pawn => "P",
        };

        n.to_string()
@@ -37,12 +57,12 @@ impl Piece {

    pub fn pretty(&self) -> String {
        let n = match self {
-            Piece::King => "♔",
-            Piece::Queen => "♕",
-            Piece::Bishop => "♗",
-            Piece::Knight => "♘",
-            Piece::Rook => "♖",
-            Piece::Pawn => "♙",
+            PieceKind::King => "♔",
+            PieceKind::Queen => "♕",
+            PieceKind::Bishop => "♗",
+            PieceKind::Knight => "♘",
+            PieceKind::Rook => "♖",
+            PieceKind::Pawn => "♙",
        };

        n.to_string()
@@ -55,17 +75,17 @@ mod tests {

    macro_rules! p {
        ($piece:literal) => {
-            Piece::parse($piece)
+            PieceKind::parse($piece)
        };
    }

    #[test]
    fn test_piece_parse() {
-        assert_eq!(p!("K"), Some(Piece::King));
-        assert_eq!(p!("Q"), Some(Piece::Queen));
-        assert_eq!(p!("B"), Some(Piece::Bishop));
-        assert_eq!(p!("N"), Some(Piece::Knight));
-        assert_eq!(p!("R"), Some(Piece::Rook));
-        assert_eq!(p!("P"), Some(Piece::Pawn));
+        assert_eq!(p!("K"), Some(PieceKind::King));
+        assert_eq!(p!("Q"), Some(PieceKind::Queen));
+        assert_eq!(p!("B"), Some(PieceKind::Bishop));
+        assert_eq!(p!("N"), Some(PieceKind::Knight));
+        assert_eq!(p!("R"), Some(PieceKind::Rook));
+        assert_eq!(p!("P"), Some(PieceKind::Pawn));
    }
 }