format and optional color

cli/Cargo.toml

@@ -8,4 +8,5 @@ repository ="https://github.com/evanofslack/balatro-rs"
 
 [dependencies]
 text_io = "0.1.9"
-balatro-rs = {path = "../core/", version = "0.0.1"}
+colored = "2.2.0"
+balatro-rs = {path = "../core/", version = "0.0.1", features = ["colored"]}

core/Cargo.toml

@@ -18,6 +18,7 @@ itertools = "0.13.0"
 indexmap = "2.6.0"
 strum = { version = "0.26", features = ["derive"] }
 pyo3 = {version = "0.23.1", optional = true}
+colored = {version = "2.2.0", optional = true}
 
 [dev-dependencies]
 criterion = "0.3"
@@ -26,6 +27,7 @@ criterion = "0.3"
 default = ["serde", "python"]
 python = ["dep:pyo3"]
 serde = ["dep:serde", "dep:serde_json", "uuid?/serde"]
+colored = ["dep:colored"]
 
 [[bench]]
 name = "benchmark"

core/src/action.rs

@@ -44,7 +44,7 @@ impl fmt::Display for Action {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
             Self::SelectCard(card) => {
-                write!(f, "SelectCard: {:?}", card)
+                write!(f, "SelectCard: {}", card)
             }
             Self::Play() => {
                 write!(f, "Play")
@@ -53,10 +53,10 @@ impl fmt::Display for Action {
                 write!(f, "Discard")
             }
             Self::MoveCard(dir, card) => {
-                write!(f, "MoveCard: {:?} - {:}", card, dir)
+                write!(f, "MoveCard: {} - {}", card, dir)
             }
             Self::CashOut(reward) => {
-                write!(f, "CashOut: {:}", reward)
+                write!(f, "CashOut: {}", reward)
             }
             Self::BuyJoker(joker) => {
                 write!(f, "BuyJoker: {:?}", joker)
@@ -65,7 +65,7 @@ impl fmt::Display for Action {
                 write!(f, "NextRound")
             }
             Self::SelectBlind(blind) => {
-                write!(f, "SelectBlind: {:?}", blind)
+                write!(f, "SelectBlind: {}", blind)
             }
         }
     }

core/src/card.rs

@@ -1,3 +1,5 @@
+#[cfg(feature = "colored")]
+use colored::Colorize;
 use pyo3::pyclass;
 use std::{
     fmt,
@@ -88,6 +90,14 @@ impl Suit {
     pub const fn suits() -> [Self; 4] {
         SUITS
     }
+    pub fn unicode(&self) -> &str {
+        match self {
+            Self::Spade => "♤",
+            Self::Club => "♧",
+            Self::Heart => "♡",
+            Self::Diamond => "♢",
+        }
+    }
 }
 
 impl From<Suit> for char {
@@ -205,18 +215,31 @@ impl Card {
 
 impl fmt::Debug for Card {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(
-            f,
-            "Card({}{})",
-            char::from(self.value),
-            char::from(self.suit)
-        )
+        #[cfg(feature = "colored")]
+        let suit = match self.suit {
+            Suit::Spade => self.suit.unicode().black(),
+            Suit::Club => self.suit.unicode().green(),
+            Suit::Heart => self.suit.unicode().red(),
+            Suit::Diamond => self.suit.unicode().blue(),
+        };
+        #[cfg(not(feature = "colored"))]
+        let suit = self.suit.unicode();
+        write!(f, "Card({}{})", char::from(self.value), suit)
     }
 }
 
 impl fmt::Display for Card {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}{}", char::from(self.value), char::from(self.suit))
+        #[cfg(feature = "colored")]
+        let suit = match self.suit {
+            Suit::Spade => self.suit.unicode().black(),
+            Suit::Club => self.suit.unicode().green(),
+            Suit::Heart => self.suit.unicode().red(),
+            Suit::Diamond => self.suit.unicode().blue(),
+        };
+        #[cfg(not(feature = "colored"))]
+        let suit = self.suit.unicode();
+        write!(f, "{}{}", char::from(self.value), suit)
     }
 }
 

core/src/joker.rs

@@ -3,6 +3,7 @@ use crate::effect::Effects;
 use crate::game::Game;
 use crate::hand::MadeHand;
 use pyo3::pyclass;
+use std::fmt;
 use std::sync::{Arc, Mutex};
 use strum::{EnumIter, IntoEnumIterator};
 
@@ -33,6 +34,25 @@ pub enum Rarity {
     Legendary,
 }
 
+impl fmt::Display for Rarity {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Self::Common => {
+                write!(f, "Common")
+            }
+            Self::Uncommon => {
+                write!(f, "Uncommon")
+            }
+            Self::Rare => {
+                write!(f, "Rare")
+            }
+            Self::Legendary => {
+                write!(f, "Legendary")
+            }
+        }
+    }
+}
+
 // We could pass around `Box<dyn Joker>` but it doesn't work so nice with pyo3 and serde.
 // Since we know all variants (one for each joker), we define an enum that implements
 // our `Joker` trait. This macro just reduces the amount of boilerplate we have to copy
@@ -122,6 +142,19 @@ impl Jokers {
     }
 }
 
+impl fmt::Display for Jokers {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(
+            f,
+            "{} [${}, {}] - {}",
+            self.name(),
+            self.cost(),
+            self.rarity(),
+            self.desc()
+        )
+    }
+}
+
 #[derive(Debug, Clone, Default, Eq, PartialEq, Hash, serde::Serialize, serde::Deserialize)]
 #[cfg_attr(feature = "python", pyclass(eq))]
 pub struct TheJoker {}

core/src/stage.rs

@@ -1,4 +1,5 @@
 use pyo3::pyclass;
+use std::fmt;
 
 /// Types of blinds
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
@@ -29,6 +30,16 @@ impl Blind {
     }
 }
 
+impl fmt::Display for Blind {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Self::Small => write!(f, "Small Blind"),
+            Self::Big => write!(f, "Big Blind"),
+            Self::Boss => write!(f, "Boss Blind"),
+        }
+    }
+}
+
 /// Game ending
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "python", pyclass(eq))]