transparent

Cargo.lock

@@ -25,6 +25,8 @@ name = "card_game"
 version = "0.4.0"
 dependencies = [
  "arrayvec",
+ "serde",
+ "serde_derive",
 ]
 
 [[package]]
@@ -130,6 +132,8 @@ version = "0.3.0"
 dependencies = [
  "card_game",
  "rand",
+ "serde",
+ "serde_derive",
 ]
 
 [[package]]
@@ -148,6 +152,8 @@ dependencies = [
  "card_game",
  "klondike",
  "rand",
+ "serde",
+ "serde_json",
 ]
 
 [[package]]

card_game/Cargo.toml

@@ -10,6 +10,12 @@ keywords = ["card", "cards", "solitaire", "klondike"]
 
 [dependencies]
 arrayvec = { version = "0.7.6", registry = "Quaternions", features = ["len_u8"], default-features = false }
+serde = { version = "1.0.228", default-features = false, optional = true }
+serde_derive = { version = "1.0.228", default-features = false, optional = true }
 
 [lints]
 workspace = true
+
+[features]
+default = ["serde"]
+serde = ["dep:serde", "dep:serde_derive"]

card_game/src/lib.rs

@@ -146,6 +146,11 @@ impl Rank {
 /// 2 bits for suit ID
 /// 4 bits for card Value
 #[derive(Clone, Debug, Eq, Hash, PartialEq)]
+#[cfg_attr(
+	feature = "serde",
+	derive(serde_derive::Deserialize, serde_derive::Serialize),
+	serde(transparent)
+)]
 pub struct Card(core::num::NonZeroU8);
 impl Card {
 	pub const fn new(deck: Deck, suit: Suit, rank: Rank) -> Self {
@@ -229,9 +234,54 @@ impl<const CAP: usize> IntoIterator for Stack<CAP> {
 		self.0.into_iter()
 	}
 }
+#[cfg(feature = "serde")]
+impl<'de, const CAP: usize> serde::Deserialize<'de> for Stack<CAP> {
+	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+	where
+		D: serde::Deserializer<'de>,
+	{
+		struct StackVisitor<const CAP: usize>;
+		impl<'de, const CAP: usize> serde::de::Visitor<'de> for StackVisitor<CAP> {
+			type Value = Stack<CAP>;
+			fn expecting(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+				write!(f, "Card Stack")
+			}
+			fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+			where
+				A: serde::de::SeqAccess<'de>,
+			{
+				let mut stack = Stack::new();
+				while let Some(card) = seq.next_element()? {
+					// TODO: Error
+					stack.try_push(card).unwrap();
+				}
+				Ok(stack)
+			}
+		}
+		deserializer.deserialize_seq(StackVisitor)
+	}
+}
+#[cfg(feature = "serde")]
+impl<const CAP: usize> serde::Serialize for Stack<CAP> {
+	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+	where
+		S: serde::Serializer,
+	{
+		use serde::ser::SerializeSeq;
+		let mut seq = serializer.serialize_seq(Some(self.len()))?;
+		for card in self.as_slice() {
+			seq.serialize_element(card)?;
+		}
+		seq.end()
+	}
+}
 
 /// A pile is a stack of face down cards and a stack of face up cards.
 #[derive(Clone, Debug, Default, Eq, Hash, PartialEq)]
+#[cfg_attr(
+	feature = "serde",
+	derive(serde_derive::Deserialize, serde_derive::Serialize)
+)]
 pub struct Pile<const DN: usize, const UP: usize> {
 	face_down: Stack<DN>,
 	face_up: Stack<UP>,
@@ -372,6 +422,10 @@ pub enum SessionInstruction<I> {
 }
 
 #[derive(Clone, Debug, Default)]
+#[cfg_attr(
+	feature = "serde",
+	derive(serde_derive::Deserialize, serde_derive::Serialize)
+)]
 pub struct SessionStats<S> {
 	inner: S,
 	undos: u32,
@@ -388,6 +442,10 @@ impl<S> SessionStats<S> {
 	}
 }
 #[derive(Clone, Debug)]
+#[cfg_attr(
+	feature = "serde",
+	derive(serde_derive::Deserialize, serde_derive::Serialize)
+)]
 pub struct SessionConfig<C> {
 	pub inner: C,
 	pub undo_penalty: i32,
@@ -417,6 +475,10 @@ pub struct Session<G: Game> {
 	state: SessionState<G>,
 }
 #[derive(Clone, Debug)]
+#[cfg_attr(
+	feature = "serde",
+	derive(serde_derive::Deserialize, serde_derive::Serialize)
+)]
 pub struct StateSnapshot<G: Game> {
 	state: G,
 	instruction: G::Instruction,
@@ -590,3 +652,86 @@ where
 		self.state.is_win()
 	}
 }
+
+#[cfg_attr(
+	feature = "serde",
+	derive(serde_derive::Deserialize),
+	serde(bound(deserialize = "
+		G: serde::Deserialize<'de>,
+		SessionConfig<G::Config>: serde::Deserialize<'de>,
+		Vec<G::Instruction>: serde::Deserialize<'de>,
+	"))
+)]
+struct SerializedSession<G: Game> {
+	config: SessionConfig<G::Config>,
+	state: G,
+	history: Vec<G::Instruction>,
+}
+#[cfg(feature = "serde")]
+impl<'de, G: Game<Score = i32>> serde::de::Deserialize<'de> for Session<G>
+where
+	G: serde::Deserialize<'de> + Clone + Eq + core::hash::Hash,
+	G::Stats: Default,
+	G::Instruction: serde::Deserialize<'de> + Eq + core::hash::Hash,
+	SessionConfig<G::Config>: serde::Deserialize<'de>,
+	Vec<G::Instruction>: serde::Deserialize<'de>,
+{
+	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+	where
+		D: serde::Deserializer<'de>,
+	{
+		let serialized = SerializedSession::deserialize(deserializer)?;
+		let mut session = Session::new(serialized.state, serialized.config);
+		for instruction in serialized.history {
+			session.process_instruction(instruction);
+		}
+		Ok(session)
+	}
+}
+#[cfg(feature = "serde")]
+impl<G: Game> serde::Serialize for Session<G>
+where
+	G: serde::Serialize,
+	G::Config: serde::Serialize,
+	G::Instruction: serde::Serialize,
+{
+	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+	where
+		S: serde::Serializer,
+	{
+		struct History<'a, G: Game>(&'a [StateSnapshot<G>]);
+		impl<G: Game> serde::Serialize for History<'_, G>
+		where
+			G: serde::Serialize,
+			G::Instruction: serde::Serialize,
+		{
+			fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+			where
+				S: serde::Serializer,
+			{
+				let &History(history) = self;
+				use serde::ser::SerializeSeq;
+				let mut seq = serializer.serialize_seq(Some(history.len()))?;
+				for snapshot in history {
+					seq.serialize_element(&snapshot.instruction)?;
+				}
+				seq.end()
+			}
+		}
+
+		use serde::ser::SerializeMap;
+		let mut map = serializer.serialize_map(Some(2))?;
+		// serialize the initial state of the game.
+		// if there is history, it is the first snapshot's state,
+		// otherwise it is the current game state since there are no moves.
+		let state = if let Some(snapshot) = self.state.history.first() {
+			snapshot.state()
+		} else {
+			&self.state.state
+		};
+		map.serialize_entry("config", &self.config)?;
+		map.serialize_entry("state", state)?;
+		map.serialize_entry("history", &History(&self.state.history))?;
+		map.end()
+	}
+}

klondike-cli/Cargo.toml

@@ -8,5 +8,9 @@ card_game.workspace = true
 klondike.workspace = true
 rand = { version = "0.10.1", default-features = false, features = ["thread_rng"] }
 
+[dev-dependencies]
+serde = { version = "1.0.228", default-features = false }
+serde_json = "1.0.149"
+
 [lints]
 workspace = true

klondike-cli/src/test.rs

@@ -14,3 +14,19 @@ fn test_is_winnable() {
 		println!("Game is not winnable");
 	}
 }
+
+#[test]
+fn test_serde() {
+	let mut session = Session::new_default(Klondike::with_seed(124));
+	let solution_result = session.solve();
+	if let Ok(Some(solution)) = solution_result {
+		for snapshot in solution.clean_solution() {
+			session.process_instruction(snapshot.instruction().clone());
+		}
+	}
+	let serialized = serde_json::to_string(&session).unwrap();
+	println!("serialized = {serialized}");
+	let round_trip_session: Session<Klondike> = serde_json::from_str(&serialized).unwrap();
+	let serialized2 = serde_json::to_string(&round_trip_session).unwrap();
+	assert_eq!(serialized, serialized2);
+}

klondike/Cargo.toml

@@ -6,6 +6,12 @@ edition = "2024"
 [dependencies]
 card_game.workspace = true
 rand = { version = "0.10.1", default-features = false, features = ["std_rng"] }
+serde = { version = "1.0.228", default-features = false, optional = true }
+serde_derive = { version = "1.0.228", default-features = false, optional = true }
 
 [lints]
 workspace = true
+
+[features]
+default = ["serde"]
+serde = ["dep:serde", "dep:serde_derive"]

klondike/src/lib.rs

@@ -7,6 +7,10 @@ use card_game::{Card, Game, Pile, Rank, Stack};
 #[cfg(doctest)]
 struct ReadmeDoctests;
 
+#[cfg_attr(
+	feature = "serde",
+	derive(serde_derive::Deserialize, serde_derive::Serialize)
+)]
 #[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
 pub enum DrawStockConfig {
 	#[default]
@@ -14,6 +18,10 @@ pub enum DrawStockConfig {
 	DrawThree = 3,
 }
 
+#[cfg_attr(
+	feature = "serde",
+	derive(serde_derive::Deserialize, serde_derive::Serialize)
+)]
 #[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
 pub enum MoveFromFoundationConfig {
 	#[default]
@@ -21,6 +29,10 @@ pub enum MoveFromFoundationConfig {
 	Disallowed,
 }
 
+#[cfg_attr(
+	feature = "serde",
+	derive(serde_derive::Deserialize, serde_derive::Serialize)
+)]
 #[derive(Clone, Copy, Debug)]
 pub struct ScoringConfig {
 	pub move_to_foundation: i32,
@@ -44,6 +56,10 @@ impl Default for ScoringConfig {
 	}
 }
 
+#[cfg_attr(
+	feature = "serde",
+	derive(serde_derive::Deserialize, serde_derive::Serialize)
+)]
 #[derive(Clone, Debug, Default)]
 pub struct KlondikeConfig {
 	pub draw_stock: DrawStockConfig,
@@ -379,6 +395,10 @@ const fn sum(n: usize) -> usize {
 const STOCK: usize = 52 - sum(TABLEAUS);
 const NUM_RANKS: usize = Rank::RANKS.len();
 
+#[cfg_attr(
+	feature = "serde",
+	derive(serde_derive::Deserialize, serde_derive::Serialize)
+)]
 #[derive(Clone, Debug, Eq, Hash, PartialEq)]
 pub struct KlondikeState {
 	stock: Pile<STOCK, STOCK>,
@@ -613,6 +633,11 @@ fn test_klondike_iter() {
 	assert_eq!(KlondikeIter::new().count(), 721);
 }
 
+#[cfg_attr(
+	feature = "serde",
+	derive(serde_derive::Deserialize, serde_derive::Serialize),
+	serde(transparent)
+)]
 #[derive(Clone, Debug, Eq, Hash, PartialEq)]
 pub struct Klondike {
 	state: KlondikeState,
@@ -797,3 +822,28 @@ impl Game for Klondike {
 		})
 	}
 }
+
+#[cfg(feature = "serde")]
+impl serde::Serialize for KlondikeInstruction {
+	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+	where
+		S: serde::Serializer,
+	{
+		// There is 721 klondike instructions
+		let instruction_id = KlondikeIter::new()
+			.position(|instruction| &instruction == self)
+			.unwrap();
+		serializer.serialize_u16(instruction_id as u16)
+	}
+}
+#[cfg(feature = "serde")]
+impl<'de> serde::Deserialize<'de> for KlondikeInstruction {
+	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+	where
+		D: serde::Deserializer<'de>,
+	{
+		let instruction_id = u16::deserialize(deserializer)?;
+		let instruction = KlondikeIter::new().nth(instruction_id as usize).unwrap();
+		Ok(instruction)
+	}
+}