wag

Cargo.lock

@@ -26,6 +26,7 @@ version = "0.4.0"
 dependencies = [
  "arrayvec",
  "serde",
+ "serde_derive",
 ]
 
 [[package]]
@@ -131,7 +132,6 @@ version = "0.3.0"
 dependencies = [
  "card_game",
  "rand",
- "serde",
 ]
 
 [[package]]
@@ -240,7 +240,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
 dependencies = [
  "serde_core",
- "serde_derive",
 ]
 
 [[package]]

card_game/Cargo.toml

@@ -8,12 +8,14 @@ description = "Card game library."
 authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 keywords = ["card", "cards", "solitaire", "klondike"]
 
-[features]
-serde = ["dep:serde"]
-
 [dependencies]
 arrayvec = { version = "0.7.6", registry = "Quaternions", features = ["len_u8"], default-features = false }
-serde = { version = "1", optional = true, default-features = false, features = ["derive"] }
+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

@@ -28,7 +28,6 @@ pub trait Game: Clone {
 
 /// card_game supports up to 4 identifiably separate decks.
 #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub enum Deck {
 	Deck1 = 0b00,
 	Deck2 = 0b01,
@@ -49,7 +48,6 @@ impl Deck {
 }
 
 #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub enum Suit {
 	Spades = 0b00,
 	Hearts = 0b01,
@@ -79,7 +77,6 @@ impl Suit {
 }
 
 #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub enum Rank {
 	Ace = 1,
 	Two = 2,
@@ -149,8 +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::Serialize, serde::Deserialize))]
-#[cfg_attr(feature = "serde", serde(transparent))]
+#[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 {
@@ -234,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>,
@@ -377,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,
@@ -393,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,
@@ -416,12 +469,25 @@ impl<C: Default> Default for SessionConfig<C> {
 }
 
 #[derive(Clone, Debug)]
+#[cfg_attr(
+	feature = "serde",
+	derive(serde_derive::Deserialize, serde_derive::Serialize),
+	serde(bound = "
+		G: serde::Serialize + for <'a> serde::Deserialize<'a>,
+		G::Stats: serde::Serialize + for <'a> serde::Deserialize<'a>,
+		G::Config: serde::Serialize + for <'a> serde::Deserialize<'a>,
+	")
+)]
 pub struct Session<G: Game> {
 	stats: SessionStats<G::Stats>,
 	config: SessionConfig<G::Config>,
 	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,
@@ -595,3 +661,73 @@ where
 		self.state.is_win()
 	}
 }
+
+#[cfg(feature = "serde")]
+impl<'de, G: Game> serde::de::DeserializeSeed<'de> for Session<G>
+where
+	G: serde::Deserialize<'de>,
+	G::Instruction: serde::Deserialize<'de>,
+{
+	type Value = SessionState<G>;
+	fn deserialize<D>(deserializer: D) -> Result<Self::Value, D::Error>
+	where
+		D: serde::Deserializer<'de>,
+	{
+		struct SessionStateVisitor<G> {
+			state: G,
+		}
+		impl<'de, G: Game> serde::de::Visitor<'de> for SessionStateVisitor<G>
+		where
+			G: serde::Deserialize<'de>,
+			G::Instruction: serde::Deserialize<'de>,
+		{
+			type Value = SessionState<G>;
+			fn expecting(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+				write!(f, "State History")
+			}
+			fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+			where
+				A: serde::de::SeqAccess<'de>,
+			{
+				let mut state = self.state.clone();
+				let mut history = match seq.size_hint() {
+					Some(capacity) => Vec::with_capacity(capacity),
+					None => Vec::new(),
+				};
+				while let Some(instruction) = seq.next_element::<G::Instruction>()? {
+					history.push(StateSnapshot {
+						state: state.clone(),
+						instruction: instruction.clone(),
+					});
+					state.process_instruction(stats, config, instruction);
+				}
+				Ok(SessionState { state, history })
+			}
+		}
+		let state = G::deserialize(deserializer)?;
+		deserializer.deserialize_seq(SessionStateVisitor { state })
+	}
+}
+#[cfg(feature = "serde")]
+impl<G: Game> serde::Serialize for SessionState<G>
+where
+	G: serde::Serialize,
+	G::Instruction: serde::Serialize,
+{
+	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+	where
+		S: serde::Serializer,
+	{
+		if let Some(state) = self.history.first() {
+			state.serialize(serializer)?;
+		} else {
+			self.state.serialize(serializer)?;
+		}
+		use serde::ser::SerializeSeq;
+		let mut seq = serializer.serialize_seq(Some(self.history.len()))?;
+		for snapshot in &self.history {
+			seq.serialize_element(&snapshot.instruction)?;
+		}
+		seq.end()
+	}
+}

klondike/Cargo.toml

@@ -3,13 +3,9 @@ name = "klondike"
 version = "0.3.0"
 edition = "2024"
 
-[features]
-serde = ["dep:serde"]
-
 [dependencies]
 card_game.workspace = true
 rand = { version = "0.10.1", default-features = false, features = ["std_rng"] }
-serde = { version = "1", optional = true, default-features = false, features = ["derive"] }
 
 [lints]
 workspace = true

klondike/src/lib.rs

@@ -121,7 +121,6 @@ impl KlondikeStats {
 }
 
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub enum Tableau {
 	Tableau1,
 	Tableau2,
@@ -148,7 +147,6 @@ impl Tableau {
 }
 
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub enum Foundation {
 	Foundation1,
 	Foundation2,
@@ -169,7 +167,6 @@ impl Foundation {
 }
 
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub enum KlondikePile {
 	Tableau(Tableau),
 	Stock,
@@ -203,7 +200,6 @@ impl From<Foundation> for KlondikePile {
 }
 
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub enum SkipCards {
 	Skip0,
 	Skip1,
@@ -242,7 +238,6 @@ impl SkipCards {
 }
 
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct TableauStack {
 	pub tableau: Tableau,
 	pub skip_cards: SkipCards,
@@ -276,7 +271,6 @@ impl TableauStack {
 }
 
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub enum KlondikePileStack {
 	Tableau(TableauStack),
 	Stock,
@@ -300,7 +294,6 @@ impl KlondikePileStack {
 }
 
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct DstFoundation {
 	pub src: KlondikePile,
 	pub foundation: Foundation,
@@ -324,7 +317,6 @@ impl DstFoundation {
 }
 
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct DstTableau {
 	pub src: KlondikePileStack,
 	pub tableau: Tableau,
@@ -348,7 +340,6 @@ impl DstTableau {
 }
 
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub enum KlondikeInstruction {
 	DstFoundation(DstFoundation),
 	DstTableau(DstTableau),