style

Cargo.lock

@@ -14,12 +14,6 @@ version = "0.7.6"
 source = "sparse+https://git.aleshym.co/api/packages/Quaternions/cargo/"
 checksum = "813440870d646c57c222c1d713dc4e3ddcb2919c3801564d767d85d7bf2afee4"
 
-[[package]]
-name = "autocfg"
-version = "1.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"
-
 [[package]]
 name = "bitflags"
 version = "2.11.1"
@@ -28,11 +22,9 @@ checksum = "c4512299f36f043ab09a583e57bceb5a5aab7a73db1805848e8fef3c9e8c78b3"
 
 [[package]]
 name = "card_game"
-version = "0.4.1"
+version = "0.2.0"
 dependencies = [
  "arrayvec",
- "serde",
- "serde_derive",
 ]
 
 [[package]]
@@ -52,17 +44,6 @@ dependencies = [
  "rand_core",
 ]
 
-[[package]]
-name = "console"
-version = "0.16.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d64e8af5551369d19cf50138de61f1c42074ab970f74e99be916646777f8fc87"
-dependencies = [
- "encode_unicode",
- "libc",
- "windows-sys",
-]
-
 [[package]]
 name = "cpufeatures"
 version = "0.3.0"
@@ -72,34 +53,12 @@ dependencies = [
  "libc",
 ]
 
-[[package]]
-name = "encode_unicode"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34aa73646ffb006b8f5147f3dc182bd4bcb190227ce861fc4a4844bf8e3cb2c0"
-
 [[package]]
 name = "equivalent"
 version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
 
-[[package]]
-name = "errno"
-version = "0.3.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
-dependencies = [
- "libc",
- "windows-sys",
-]
-
-[[package]]
-name = "fastrand"
-version = "2.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9f1f227452a390804cdb637b74a86990f2a7d7ba4b7d5693aac9b4dd6defd8d6"
-
 [[package]]
 name = "foldhash"
 version = "0.1.5"
@@ -159,18 +118,6 @@ dependencies = [
  "serde_core",
 ]
 
-[[package]]
-name = "insta"
-version = "1.47.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b4a6248eb93a4401ed2f37dfe8ea592d3cf05b7cf4f8efa867b6895af7e094e"
-dependencies = [
- "console",
- "once_cell",
- "similar",
- "tempfile",
-]
-
 [[package]]
 name = "itoa"
 version = "1.0.18"
@@ -179,15 +126,10 @@ checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
 
 [[package]]
 name = "klondike"
-version = "0.4.0"
+version = "0.1.0"
 dependencies = [
  "card_game",
- "insta",
  "rand",
- "rmp-serde",
- "serde",
- "serde_derive",
- "serde_json",
 ]
 
 [[package]]
@@ -220,12 +162,6 @@ version = "0.2.186"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66"
 
-[[package]]
-name = "linux-raw-sys"
-version = "0.12.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53"
-
 [[package]]
 name = "log"
 version = "0.4.29"
@@ -238,21 +174,6 @@ version = "2.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
 
-[[package]]
-name = "num-traits"
-version = "0.2.19"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
-dependencies = [
- "autocfg",
-]
-
-[[package]]
-name = "once_cell"
-version = "1.21.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
-
 [[package]]
 name = "prettyplease"
 version = "0.2.37"
@@ -304,38 +225,6 @@ version = "0.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "63b8176103e19a2643978565ca18b50549f6101881c443590420e4dc998a3c69"
 
-[[package]]
-name = "rmp"
-version = "0.8.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ba8be72d372b2c9b35542551678538b562e7cf86c3315773cae48dfbfe7790c"
-dependencies = [
- "num-traits",
-]
-
-[[package]]
-name = "rmp-serde"
-version = "1.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72f81bee8c8ef9b577d1681a70ebbc962c232461e397b22c208c43c04b67a155"
-dependencies = [
- "rmp",
- "serde",
-]
-
-[[package]]
-name = "rustix"
-version = "1.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190"
-dependencies = [
- "bitflags",
- "errno",
- "libc",
- "linux-raw-sys",
- "windows-sys",
-]
-
 [[package]]
 name = "semver"
 version = "1.0.28"
@@ -384,12 +273,6 @@ dependencies = [
  "zmij",
 ]
 
-[[package]]
-name = "similar"
-version = "2.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbbb5d9659141646ae647b42fe094daf6c6192d1620870b449d9557f748b2daa"
-
 [[package]]
 name = "syn"
 version = "2.0.117"
@@ -401,19 +284,6 @@ dependencies = [
  "unicode-ident",
 ]
 
-[[package]]
-name = "tempfile"
-version = "3.27.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd"
-dependencies = [
- "fastrand",
- "getrandom",
- "once_cell",
- "rustix",
- "windows-sys",
-]
-
 [[package]]
 name = "unicode-ident"
 version = "1.0.24"
@@ -478,21 +348,6 @@ dependencies = [
  "semver",
 ]
 
-[[package]]
-name = "windows-link"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
-
-[[package]]
-name = "windows-sys"
-version = "0.61.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
-dependencies = [
- "windows-link",
-]
-
 [[package]]
 name = "wit-bindgen"
 version = "0.51.0"

Cargo.toml

@@ -8,8 +8,8 @@ members = [
 resolver = "3"
 
 [workspace.dependencies]
-card_game = { version = "0.4.1", path = "card_game", registry = "Quaternions" }
+card_game = { version = "0.2.0", path = "card_game", registry = "Quaternions" }
-klondike = { version = "0.4.0", path = "klondike", registry = "Quaternions" }
+klondike = { version = "0.1.0", path = "klondike", registry = "Quaternions" }
 
 [workspace.lints.rust]
 # unsafe_code = "forbid"

README.md

@@ -1 +0,0 @@
-card_game/README.md

card_game/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "card_game"
-version = "0.4.1"
+version = "0.2.0"
 edition = "2024"
 repository = "https://git.aleshym.co/Quaternions/card_game"
 license = "MIT OR Apache-2.0"
@@ -10,12 +10,6 @@ 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

@@ -5,61 +5,25 @@ struct ReadmeDoctests;
 
 use core::ops::RangeBounds;
 
-pub trait Game: Clone {
+// TODO: pub struct ValidInstruction<I>(I);
-	type Score: Clone + core::fmt::Debug;
+pub trait Game {
-	type Stats: Clone + core::fmt::Debug;
+	type Score;
-	type Config: Clone + core::fmt::Debug;
+	type Stats;
-	type Instruction: Clone + core::fmt::Debug;
+	type Config;
+	type Instruction;
 	fn score(&self, stats: &Self::Stats, config: &Self::Config) -> Self::Score;
 	fn possible_instructions(
 		&self,
 		config: &Self::Config,
 	) -> impl Iterator<Item = Self::Instruction> + use<Self>;
-	fn is_instruction_valid(&self, config: &Self::Config, instruction: &Self::Instruction) -> bool;
+	fn is_instruction_valid(&self, config: &Self::Config, instruction: Self::Instruction) -> bool;
-	fn process_instruction(valid_instruction: StagedInstruction<'_, Self>);
+	fn process_instruction(
-	fn is_win(&self) -> bool;
+		&mut self,
-	/// Validate an instruction to prepare to run it.
+		stats: &mut Self::Stats,
-	fn stage_instruction<'a>(
+		config: &Self::Config,
-		&'a mut self,
-		stats: &'a mut Self::Stats,
-		config: &'a Self::Config,
 		instruction: Self::Instruction,
-	) -> Option<StagedInstruction<'a, Self>> {
+	);
-		self.is_instruction_valid(config, &instruction)
+	fn is_win(&self) -> bool;
-			.then_some(StagedInstruction {
-				game: self,
-				stats,
-				config,
-				instruction,
-			})
-	}
-}
-
-/// Call .commit() to run the staged instruction.
-/// Cannot be constructed other than by Game::stage_instruction.
-pub struct StagedInstruction<'a, G: Game> {
-	game: &'a mut G,
-	stats: &'a mut G::Stats,
-	config: &'a G::Config,
-	instruction: G::Instruction,
-}
-impl<'a, G: Game> StagedInstruction<'a, G> {
-	/// Consume the staged instruction.  Use this in your implementation of InstructionConsumer::process_instruction for your game.
-	pub fn consume(self) -> (&'a mut G, &'a mut G::Stats, &'a G::Config, G::Instruction) {
-		let StagedInstruction {
-			game,
-			stats,
-			config,
-			instruction,
-		} = self;
-		(game, stats, config, instruction)
-	}
-}
-impl<G: Game> StagedInstruction<'_, G> {
-	/// Process the staged instruction.
-	pub fn commit(self) {
-		G::process_instruction(self);
-	}
 }
 
 /// card_game supports up to 4 identifiably separate decks.
@@ -182,11 +146,6 @@ 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 {
@@ -271,54 +230,8 @@ impl<const CAP: usize> IntoIterator for Stack<CAP> {
 	}
 }
 
-#[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>,
-			{
-				use serde::de::Error;
-				let mut stack = Stack::new();
-				while let Some(card) = seq.next_element()? {
-					stack.try_push(card).map_err(A::Error::custom)?;
-				}
-				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>,
@@ -399,59 +312,6 @@ impl<const CAP: usize> Pile<CAP, CAP> {
 	}
 }
 
-#[derive(Clone, Debug)]
-pub enum SolveError {
-	MovesBudgetExceeded,
-	StatesBudgetExceeded,
-}
-impl core::fmt::Display for SolveError {
-	fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-		write!(f, "{self:?}")
-	}
-}
-impl core::error::Error for SolveError {}
-
-/// The solution tends to be very large with long chains of moves that go back to the same state.
-/// It is recommended to call .clean_solution() if the solution is actually going to be shown to a user.
-pub struct Solution<G: Game> {
-	solution: Vec<StateSnapshot<G>>,
-}
-impl<G: Game + Eq + core::hash::Hash> Solution<G> {
-	pub const fn raw_solution(&self) -> &[StateSnapshot<G>] {
-		self.solution.as_slice()
-	}
-	/// Repeatedly remove the largest range of moves that goes back into the same state.
-	/// This is a very expensive operation when the solution is very long!
-	pub fn clean_solution(self) -> Vec<StateSnapshot<G>> {
-		let mut history = self.solution;
-		// history includes cycles
-		let mut state_index: std::collections::HashMap<_, _> = history
-			.iter()
-			.enumerate()
-			.map(|(i, snapshot)| (snapshot.state().clone(), i))
-			.collect();
-
-		// find the longest range where the start and end are the same state
-		while let Some(longest_range) = history
-			.iter()
-			.enumerate()
-			.filter_map(|(index, snapshot)| {
-				let &last_index = state_index.get(snapshot.state())?;
-				let longness = last_index - index;
-				(longness != 0).then_some(index..last_index)
-			})
-			.max_by_key(|range| range.len())
-		{
-			history.drain(longest_range);
-			for (i, snapshot) in history.iter().enumerate() {
-				state_index.insert(snapshot.state().clone(), i);
-			}
-		}
-
-		history
-	}
-}
-
 #[derive(Clone, Debug)]
 pub enum SessionInstruction<I> {
 	Undo,
@@ -459,10 +319,6 @@ 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,
@@ -479,23 +335,15 @@ 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,
-	pub solve_moves_budget: u64,
-	pub solve_states_budget: u64,
 }
 impl<C> SessionConfig<C> {
 	fn new_default(inner: C) -> Self {
 		Self {
 			inner,
 			undo_penalty: -15,
-			solve_moves_budget: 100_000,
-			solve_states_budget: 100_000,
 		}
 	}
 }
@@ -505,37 +353,21 @@ impl<C: Default> Default for SessionConfig<C> {
 	}
 }
 
-#[derive(Clone, Debug)]
 pub struct Session<G: Game> {
 	stats: SessionStats<G::Stats>,
 	config: SessionConfig<G::Config>,
 	state: SessionState<G>,
 }
-#[derive(Clone, Debug)]
+#[derive(Clone, Eq, Hash, PartialEq)]
-#[cfg_attr(
-	feature = "serde",
-	derive(serde_derive::Deserialize, serde_derive::Serialize)
-)]
-pub struct StateSnapshot<G: Game> {
-	state: G,
-	instruction: G::Instruction,
-}
-impl<G: Game> StateSnapshot<G> {
-	pub const fn state(&self) -> &G {
-		&self.state
-	}
-	pub const fn instruction(&self) -> &G::Instruction {
-		&self.instruction
-	}
-}
-#[derive(Clone, Debug)]
 pub struct SessionState<G: Game> {
+	seed: G,
 	state: G,
-	history: Vec<StateSnapshot<G>>,
+	history: Vec<G::Instruction>,
 }
 impl<G: Game + Clone> SessionState<G> {
 	fn new(state: G) -> Self {
 		Self {
+			seed: state.clone(),
 			state,
 			history: Vec::new(),
 		}
@@ -548,9 +380,9 @@ impl<G: Game> SessionState<G> {
 }
 impl<G: Game<Score = i32>> Session<G>
 where
-	G: Eq + core::hash::Hash,
+	G: Clone + Eq + core::hash::Hash,
-	G::Stats: Default,
+	G::Stats: Clone + Default,
-	G::Instruction: Eq + core::hash::Hash,
+	G::Instruction: Clone + Eq + core::hash::Hash,
 {
 	pub fn new(state: G, config: SessionConfig<G::Config>) -> Self {
 		Self {
@@ -574,25 +406,18 @@ where
 	pub const fn config(&self) -> &SessionConfig<G::Config> {
 		&self.config
 	}
-	pub fn history(&self) -> &[StateSnapshot<G>] {
+	pub fn history(&self) -> &[G::Instruction] {
 		&self.state.history
 	}
 	pub fn undo(&mut self) {
-		if let Some(staged) =
+		self.state
-			self.state
+			.process_instruction(&mut self.stats, &self.config, SessionInstruction::Undo)
-				.stage_instruction(&mut self.stats, &self.config, SessionInstruction::Undo)
-		{
-			staged.commit();
-		}
 	}
 	pub fn possible_instructions(&self) -> impl Iterator<Item = G::Instruction> + use<G> {
 		self.state.state.possible_instructions(&self.config.inner)
 	}
-	pub fn stage_instruction(
+	pub fn process_instruction(&mut self, instruction: G::Instruction) {
-		&mut self,
+		self.state.process_instruction(
-		instruction: G::Instruction,
-	) -> Option<StagedInstruction<'_, SessionState<G>>> {
-		self.state.stage_instruction(
 			&mut self.stats,
 			&self.config,
 			SessionInstruction::InnerInstruction(instruction),
@@ -601,53 +426,14 @@ where
 	pub fn is_win(&self) -> bool {
 		self.state.is_win()
 	}
-	/// Attempt to produce a solution.
-	pub fn solve(&self) -> Result<Option<Solution<G>>, SolveError> {
-		let mut state_moves = std::collections::HashMap::new();
-		let mut session = self.clone();
-		let mut moves = 0;
-		while !session.is_win() {
-			moves += 1;
-			if self.config.solve_moves_budget < moves {
-				return Err(SolveError::MovesBudgetExceeded);
-			}
-			if self.config.solve_states_budget < state_moves.len() as u64 {
-				return Err(SolveError::StatesBudgetExceeded);
-			}
-			// Continue existing iterator if it exists
-			let it = state_moves
-				.entry(session.state().state().clone())
-				.or_insert_with(|| {
-					session
-						.state()
-						.state()
-						.possible_instructions(&self.config().inner)
-				});
-
-			// Run one possible move
-			if let Some(instruction) = it.next() {
-				// TODO: no unwrap
-				session.stage_instruction(instruction).unwrap().commit();
-				continue;
-			}
-
-			// No more moves. If we can't undo we're done
-			if session.history().is_empty() {
-				return Ok(None);
-			} else {
-				session.undo();
-			}
-		}
-		Ok(Some(Solution {
-			solution: session.state.history,
-		}))
-	}
 }
 impl<G: Game<Score = i32>> Game for SessionState<G>
 where
+	G: Clone,
 	G::Stats: Default,
+	G::Instruction: Clone,
 {
-	type Score = G::Score;
+	type Score = i32;
 	type Stats = SessionStats<G::Stats>;
 	type Config = SessionConfig<G::Config>;
 	type Instruction = SessionInstruction<G::Instruction>;
@@ -662,7 +448,7 @@ where
 			.possible_instructions(&config.inner)
 			.map(SessionInstruction::InnerInstruction)
 	}
-	fn is_instruction_valid(&self, config: &Self::Config, instruction: &Self::Instruction) -> bool {
+	fn is_instruction_valid(&self, config: &Self::Config, instruction: Self::Instruction) -> bool {
 		match instruction {
 			SessionInstruction::Undo => !self.history.is_empty(),
 			SessionInstruction::InnerInstruction(instruction) => {
@@ -670,27 +456,29 @@ where
 			}
 		}
 	}
-	fn process_instruction(valid_instruction: StagedInstruction<'_, Self>) {
+	fn process_instruction(
-		let (game, stats, config, instruction) = valid_instruction.consume();
+		&mut self,
+		stats: &mut Self::Stats,
+		config: &Self::Config,
+		instruction: Self::Instruction,
+	) {
 		match instruction {
 			SessionInstruction::Undo => {
-				if let Some(snapshot) = game.history.pop() {
+				// replay the entire history of the game except one move
-					game.state = snapshot.state;
+				self.history.pop();
-					stats.increment_undos();
+				let mut inner_stats = G::Stats::default();
+				let mut state = self.seed.clone();
+				for instruction in &self.history {
+					state.process_instruction(&mut inner_stats, &config.inner, instruction.clone());
 				}
+				self.state = state;
+				stats.inner = inner_stats;
+				stats.increment_undos();
 			}
 			SessionInstruction::InnerInstruction(instruction) => {
-				game.history.push(StateSnapshot {
+				self.history.push(instruction.clone());
-					state: game.state.clone(),
+				self.state
-					instruction: instruction.clone(),
+					.process_instruction(&mut stats.inner, &config.inner, instruction);
-				});
-				// This might be considered cheaing a bit, we're pre-approving the instruction here by accessing the inner fields.
-				G::process_instruction(StagedInstruction {
-					game: &mut game.state,
-					stats: &mut stats.inner,
-					config: &config.inner,
-					instruction,
-				});
 			}
 		}
 	}
@@ -698,96 +486,3 @@ where
 		self.state.is_win()
 	}
 }
-
-#[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>,
-	{
-		#[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>,
-			initial_state: G,
-			instructions: Vec<G::Instruction>,
-		}
-		let serialized = SerializedSession::deserialize(deserializer)?;
-		let mut session = Session::new(serialized.initial_state, serialized.config);
-		for instruction in serialized.instructions {
-			// TODO: no unwrap
-			session.stage_instruction(instruction).unwrap().commit();
-		}
-		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()
-			}
-		}
-
-		#[derive(serde_derive::Serialize)]
-		#[serde(bound(serialize = "
-			G: serde::Serialize,
-			SessionConfig<G::Config>: serde::Serialize,
-			G::Instruction: serde::Serialize,
-		"))]
-		struct SerializedSession<'a, G: Game> {
-			config: &'a SessionConfig<G::Config>,
-			initial_state: &'a G,
-			instructions: History<'a, G>,
-		}
-
-		// 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 initial_state = if let Some(snapshot) = self.state.history.first() {
-			snapshot.state()
-		} else {
-			&self.state.state
-		};
-		let session = SerializedSession {
-			config: &self.config,
-			initial_state,
-			instructions: History(&self.state.history),
-		};
-		session.serialize(serializer)
-	}
-}

klondike-bench/src/main.rs

@@ -21,9 +21,7 @@ fn play_to_win(rng: &mut Rng) -> Option<KlondikeStats> {
 			return None;
 		}
 
-		game.stage_instruction(&mut stats, &CONFIG, instruction)
+		game.process_instruction(&mut stats, &CONFIG, instruction);
-			.unwrap()
-			.commit();
 	}
 	game.is_win().then_some(stats)
 }

klondike-cli/src/main.rs

@@ -4,6 +4,9 @@ use klondike::{
 	KlondikePile, KlondikePileStack, SkipCards, Tableau, TableauStack,
 };
 
+// #[cfg(test)]
+// mod test;
+
 use std::fmt::Display;
 struct Displayed<T>(T);
 
@@ -114,7 +117,7 @@ impl Display for DisplayStats<'_> {
 			self.0.stats().stats().recycle_count(),
 			self.0.stats().stats().moves(),
 			self.0.stats().undos(),
-			self.0.state().score(self.0.stats(), self.0.config()),
+			self.0.state().score(self.0.stats(), &self.0.config()),
 		)
 	}
 }
@@ -210,7 +213,7 @@ fn find_valid_instruction(
 						});
 						let instruction =
 							KlondikeInstruction::DstTableau(DstTableau { tableau, src });
-						if state.is_instruction_valid(config, &instruction) {
+						if state.is_instruction_valid(config, instruction) {
 							return Some(instruction);
 						}
 					}
@@ -228,7 +231,7 @@ fn find_valid_instruction(
 		_ => return None,
 	};
 	state
-		.is_instruction_valid(config, &instruction)
+		.is_instruction_valid(config, instruction)
 		.then_some(instruction)
 }
 
@@ -236,7 +239,7 @@ fn main() -> Result<(), std::io::Error> {
 	use rand::RngExt;
 	let mut rng = rand::rng();
 	// seed from cli argument
-	let mut seed = if let Some(seed) = std::env::args().nth(1) {
+	let mut seed = if let Some(seed) = std::env::args().skip(1).next() {
 		seed.parse().expect("Invalid u64 seed")
 	} else {
 		rng.random()
@@ -277,16 +280,13 @@ fn main() -> Result<(), std::io::Error> {
 					.state()
 					.get_auto_move(&session.config().inner)
 				{
-					session.stage_instruction(instruction).unwrap().commit();
+					session.process_instruction(instruction);
 				} else {
 					println!("No valid moves!");
 				}
 			}
 			SessionInstruction::Stock => {
-				session
+				session.process_instruction(KlondikeInstruction::RotateStock)
-					.stage_instruction(KlondikeInstruction::RotateStock)
-					.unwrap()
-					.commit();
 			}
 			SessionInstruction::Klondike(naive_instruction) => {
 				if let Some(instruction) = find_valid_instruction(
@@ -294,7 +294,7 @@ fn main() -> Result<(), std::io::Error> {
 					session.state().state(),
 					naive_instruction,
 				) {
-					session.stage_instruction(instruction).unwrap().commit();
+					session.process_instruction(instruction);
 				} else {
 					println!("Invalid move!");
 				}

klondike-cli/src/test.rs

@@ -0,0 +1,33 @@
+use klondike::Klondike;
+use card_game::Session;
+#[test]
+fn test_is_winnable() {
+	// is winnable
+	let is_winnable = Session::new_default(Klondike::with_seed(123)).is_winnable();
+	println!("is_winnable = {is_winnable:?}");
+}
+#[test]
+fn test_klondike() {
+	// create game session
+	let game = Klondike::with_seed(123);
+	let mut session = Session::new_default(game);
+
+	// is winnable
+	let is_winnable = session.is_winnable();
+	println!("is_winnable = {is_winnable:?}");
+
+	// play game
+	while let Some(instruction) = session.possible_instructions().next() {
+		session.process_instruction(instruction);
+	}
+
+	// did win
+	let is_win = session.is_win();
+
+	// print session history
+	for (i, instruction) in session.history().iter().enumerate() {
+		println!("move {i} = {instruction:?}");
+	}
+
+	println!("is_win = {is_win}");
+}

klondike/Cargo.toml

@@ -1,23 +1,11 @@
 [package]
 name = "klondike"
-version = "0.4.0"
+version = "0.1.0"
 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 }
-
-[dev-dependencies]
-insta = "1.47.2"
-rmp-serde = "1.3.1"
-serde = { version = "1.0.228", default-features = false }
-serde_json = "1.0.149"
 
 [lints]
 workspace = true
-
-[features]
-default = ["serde"]
-serde = ["dep:serde", "dep:serde_derive", "card_game/serde"]

klondike/README.md

@@ -15,8 +15,8 @@ let config = KlondikeConfig::default();
 let mut session = Session::new_default(game);
 
 // play game a bit
-while let Some(instruction) = session.state().state().get_auto_move(&config) {
+while let Some(instruction) = session.state().get_auto_move(&config) {
-	session.stage_instruction(instruction).unwrap().commit();
+	session.process_instruction(instruction);
 
 	// quit after 200 moves or win
 	if session.is_win() || 200 < session.stats().stats().moves() {

klondike/src/lib.rs

@@ -1,19 +1,12 @@
 pub type Rng = rand::rngs::StdRng;
 
-use card_game::{Card, Game, Pile, Rank, Stack, StagedInstruction};
+use card_game::{Card, Game, Pile, Rank, Stack};
-
-#[cfg(test)]
-mod test;
 
 // test readme
 #[doc = include_str!("../README.md")]
 #[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]
@@ -21,10 +14,6 @@ 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]
@@ -32,10 +21,6 @@ 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,
@@ -59,10 +44,6 @@ 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,
@@ -97,24 +78,12 @@ impl KlondikeStats {
 			+ self.move_from_foundation_count as i32 * config.move_from_foundation
 			+ self.recycle_count as i32 * config.recycle
 	}
-	pub const fn moves(&self) -> u32 {
-		self.moves
-	}
-	pub const fn move_to_foundation_count(&self) -> u32 {
-		self.move_to_foundation_count
-	}
-	pub const fn flip_up_bonus_count(&self) -> u32 {
-		self.flip_up_bonus_count
-	}
-	pub const fn move_to_tableau_count(&self) -> u32 {
-		self.move_to_tableau_count
-	}
-	pub const fn move_from_foundation_count(&self) -> u32 {
-		self.move_from_foundation_count
-	}
 	pub const fn recycle_count(&self) -> u32 {
 		self.recycle_count
 	}
+	pub const fn moves(&self) -> u32 {
+		self.moves
+	}
 	/// A card was moved to a foundation.
 	const fn increment_move_to_foundation(&mut self) {
 		self.move_to_foundation_count += 1;
@@ -164,38 +133,6 @@ impl Tableau {
 		})
 	}
 }
-pub struct TableauIter {
-	tableau: Option<Tableau>,
-}
-impl TableauIter {
-	pub const fn new() -> Self {
-		Self {
-			tableau: Some(Tableau::ITER_BEGIN),
-		}
-	}
-}
-impl Default for TableauIter {
-	fn default() -> Self {
-		Self::new()
-	}
-}
-impl Iterator for TableauIter {
-	type Item = Tableau;
-	fn next(&mut self) -> Option<Self::Item> {
-		let tableau = self.tableau?;
-		self.tableau = tableau.next();
-		Some(tableau)
-	}
-}
-impl IntoIterator for Tableau {
-	type Item = Self;
-	type IntoIter = TableauIter;
-	fn into_iter(self) -> Self::IntoIter {
-		TableauIter {
-			tableau: Some(self),
-		}
-	}
-}
 
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
 pub enum Foundation {
@@ -216,38 +153,6 @@ impl Foundation {
 		})
 	}
 }
-pub struct FoundationIter {
-	foundation: Option<Foundation>,
-}
-impl FoundationIter {
-	pub const fn new() -> Self {
-		Self {
-			foundation: Some(Foundation::ITER_BEGIN),
-		}
-	}
-}
-impl Default for FoundationIter {
-	fn default() -> Self {
-		Self::new()
-	}
-}
-impl Iterator for FoundationIter {
-	type Item = Foundation;
-	fn next(&mut self) -> Option<Self::Item> {
-		let foundation = self.foundation?;
-		self.foundation = foundation.next();
-		Some(foundation)
-	}
-}
-impl IntoIterator for Foundation {
-	type Item = Self;
-	type IntoIter = FoundationIter;
-	fn into_iter(self) -> Self::IntoIter {
-		FoundationIter {
-			foundation: Some(self),
-		}
-	}
-}
 
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
 pub enum KlondikePile {
@@ -460,59 +365,54 @@ const fn sum(n: usize) -> usize {
 	n * (n + 1) / 2
 }
 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>,
-	foundations: [Stack<NUM_RANKS>; 4],
+	foundations: [Stack<13>; 4],
-	tableau1: Pile<0, NUM_RANKS>,
+	tableau1: Pile<0, 13>,
-	tableau2: Pile<1, NUM_RANKS>,
+	tableau2: Pile<1, 13>,
-	tableau3: Pile<2, NUM_RANKS>,
+	tableau3: Pile<2, 13>,
-	tableau4: Pile<3, NUM_RANKS>,
+	tableau4: Pile<3, 13>,
-	tableau5: Pile<4, NUM_RANKS>,
+	tableau5: Pile<4, 13>,
-	tableau6: Pile<5, NUM_RANKS>,
+	tableau6: Pile<5, 13>,
-	tableau7: Pile<6, NUM_RANKS>,
+	tableau7: Pile<6, 13>,
 }
 impl KlondikeState {
 	pub const fn stock(&self) -> &Pile<STOCK, STOCK> {
 		&self.stock
 	}
-	pub const fn foundation1(&self) -> &Stack<NUM_RANKS> {
+	pub const fn foundation1(&self) -> &Stack<13> {
 		&self.foundations[Foundation::Foundation1 as usize]
 	}
-	pub const fn foundation2(&self) -> &Stack<NUM_RANKS> {
+	pub const fn foundation2(&self) -> &Stack<13> {
 		&self.foundations[Foundation::Foundation2 as usize]
 	}
-	pub const fn foundation3(&self) -> &Stack<NUM_RANKS> {
+	pub const fn foundation3(&self) -> &Stack<13> {
 		&self.foundations[Foundation::Foundation3 as usize]
 	}
-	pub const fn foundation4(&self) -> &Stack<NUM_RANKS> {
+	pub const fn foundation4(&self) -> &Stack<13> {
 		&self.foundations[Foundation::Foundation4 as usize]
 	}
-	pub const fn tableau1(&self) -> &Pile<0, NUM_RANKS> {
+	pub const fn tableau1(&self) -> &Pile<0, 13> {
 		&self.tableau1
 	}
-	pub const fn tableau2(&self) -> &Pile<1, NUM_RANKS> {
+	pub const fn tableau2(&self) -> &Pile<1, 13> {
 		&self.tableau2
 	}
-	pub const fn tableau3(&self) -> &Pile<2, NUM_RANKS> {
+	pub const fn tableau3(&self) -> &Pile<2, 13> {
 		&self.tableau3
 	}
-	pub const fn tableau4(&self) -> &Pile<3, NUM_RANKS> {
+	pub const fn tableau4(&self) -> &Pile<3, 13> {
 		&self.tableau4
 	}
-	pub const fn tableau5(&self) -> &Pile<4, NUM_RANKS> {
+	pub const fn tableau5(&self) -> &Pile<4, 13> {
 		&self.tableau5
 	}
-	pub const fn tableau6(&self) -> &Pile<5, NUM_RANKS> {
+	pub const fn tableau6(&self) -> &Pile<5, 13> {
 		&self.tableau6
 	}
-	pub const fn tableau7(&self) -> &Pile<6, NUM_RANKS> {
+	pub const fn tableau7(&self) -> &Pile<6, 13> {
 		&self.tableau7
 	}
 	pub fn tableau_face_down_cards(&self, tableau: Tableau) -> &[Card] {
@@ -549,20 +449,14 @@ impl KlondikeState {
 			KlondikePileStack::Stock => self.stock.face_up().last(),
 		}
 	}
-	pub fn tableau_top_card(&self, tableau: Tableau) -> Option<&Card> {
+	pub fn top_card<S: Into<KlondikePile>>(&self, src: S) -> Option<&Card> {
-		self.tableau_face_up_cards(tableau).last()
+		match src.into() {
-	}
+			KlondikePile::Tableau(tableau) => self.tableau_face_up_cards(tableau).last(),
-	pub fn foundation_top_card(&self, foundation: Foundation) -> Option<&Card> {
+			KlondikePile::Foundation(foundation) => self.foundations[foundation as usize].last(),
-		self.foundations[foundation as usize].last()
-	}
-	pub fn top_card(&self, pile: KlondikePile) -> Option<&Card> {
-		match pile {
-			KlondikePile::Tableau(tableau) => self.tableau_top_card(tableau),
-			KlondikePile::Foundation(foundation) => self.foundation_top_card(foundation),
 			KlondikePile::Stock => self.stock.face_up().last(),
 		}
 	}
-	fn take_stack_flip_up(&mut self, src: KlondikePileStack) -> (Stack<NUM_RANKS>, bool) {
+	fn take_stack(&mut self, src: KlondikePileStack) -> (Stack<13>, bool) {
 		match src {
 			KlondikePileStack::Tableau(TableauStack {
 				tableau,
@@ -583,8 +477,8 @@ impl KlondikeState {
 			KlondikePileStack::Stock => (Stack::from_iter(self.stock.pop()), false),
 		}
 	}
-	fn take_top_card_flip_up(&mut self, pile: KlondikePile) -> (Option<Card>, bool) {
+	fn take_top_card<S: Into<KlondikePile>>(&mut self, src: S) -> (Option<Card>, bool) {
-		match pile {
+		match src.into() {
 			KlondikePile::Tableau(tableau) => match tableau {
 				Tableau::Tableau1 => self.tableau1.pop_flip_up(),
 				Tableau::Tableau2 => self.tableau2.pop_flip_up(),
@@ -621,7 +515,7 @@ impl KlondikeState {
 	pub fn is_instruction_valid(
 		&self,
 		config: &KlondikeConfig,
-		instruction: &KlondikeInstruction,
+		instruction: KlondikeInstruction,
 	) -> bool {
 		match instruction {
 			// Stock -> Stock draws a card or resets the stock
@@ -634,7 +528,7 @@ impl KlondikeState {
 			KlondikeInstruction::DstFoundation(dst_foundation) => {
 				// get the top cards
 				if let Some(src_card) = self.top_card(dst_foundation.src) {
-					match self.foundation_top_card(dst_foundation.foundation) {
+					match self.top_card(dst_foundation.foundation) {
 						// destination card exists
 						Some(dst_card) => {
 							// suit matches?
@@ -658,7 +552,7 @@ impl KlondikeState {
 				}
 				// get the cards
 				if let Some(src_card) = self.stack_bottom_card(dst_tableau.src) {
-					match self.tableau_top_card(dst_tableau.tableau) {
+					match self.top_card(dst_tableau.tableau) {
 						// destination card exists
 						Some(dst_card) => {
 							// red-ness is opposite?
@@ -695,16 +589,7 @@ impl Iterator for KlondikeIter {
 		instruction
 	}
 }
-#[test]
-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,
@@ -723,9 +608,7 @@ impl Klondike {
 		let mut deck = deck.into_iter();
 
 		// generate tableaus
-		fn pile<const DN: usize>(
+		fn pile<const DN: usize>(deck: &mut <Stack<52> as IntoIterator>::IntoIter) -> Pile<DN, 13> {
-			deck: &mut <Stack<52> as IntoIterator>::IntoIter,
-		) -> Pile<DN, NUM_RANKS> {
 			let stack = Stack::from_iter(deck.take(DN));
 			let mut pile = Pile::new_face_down(stack);
 			pile.push(deck.next().unwrap());
@@ -830,47 +713,51 @@ impl Game for Klondike {
 		let state = self.state.clone();
 		let config = config.clone();
 		KlondikeIter::new()
-			.filter(move |instruction| state.is_instruction_valid(&config, instruction))
+			.filter(move |&instruction| state.is_instruction_valid(&config, instruction))
 	}
-	fn is_instruction_valid(&self, config: &Self::Config, instruction: &Self::Instruction) -> bool {
+	fn is_instruction_valid(&self, config: &Self::Config, instruction: Self::Instruction) -> bool {
 		self.state.is_instruction_valid(config, instruction)
 	}
-	fn process_instruction(valid_instruction: StagedInstruction<'_, Self>) {
+	fn process_instruction(
-		let (game, stats, config, instruction) = valid_instruction.consume();
+		&mut self,
+		stats: &mut Self::Stats,
+		config: &Self::Config,
+		instruction: Self::Instruction,
+	) {
 		stats.increment_moves();
 		match instruction {
 			// Reset the stock if it's empty
 			KlondikeInstruction::RotateStock => {
-				if game.state.stock.face_down().is_empty() {
+				if self.state.stock.face_down().is_empty() {
-					game.state.stock.flip_it_and_reverse_it();
+					self.state.stock.flip_it_and_reverse_it();
 					stats.increment_recycle_count();
 				} else {
 					for _ in 0..config.draw_stock as usize {
-						game.state.stock.flip_up();
+						self.state.stock.flip_up();
 					}
 				}
 			}
 			// Move a card from anywhere to a foundation
 			KlondikeInstruction::DstFoundation(DstFoundation { src, foundation }) => {
 				stats.increment_move_to_foundation();
-				let (card, did_flip_up) = game.state.take_top_card_flip_up(src);
+				let (card, did_flip_up) = self.state.take_top_card(src);
 				if did_flip_up {
 					stats.increment_flip_up_bonus();
 				}
-				game.state.extend_foundation(foundation, card);
+				self.state.extend_foundation(foundation, card);
 			}
 			// Move a stack of cards from anywhere to a tableau
 			KlondikeInstruction::DstTableau(DstTableau { src, tableau }) => {
 				match src {
 					KlondikePileStack::Stock => stats.increment_move_to_tableau(),
 					KlondikePileStack::Foundation(_) => stats.increment_move_from_foundation(),
-					KlondikePileStack::Tableau(_) => {}
+					_ => {}
 				}
-				let (cards, did_flip_up) = game.state.take_stack_flip_up(src);
+				let (cards, did_flip_up) = self.state.take_stack(src);
 				if did_flip_up {
 					stats.increment_flip_up_bonus();
 				}
-				game.state.extend_tableau(tableau, cards);
+				self.state.extend_tableau(tableau, cards);
 			}
 		}
 	}
@@ -885,28 +772,3 @@ 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)
-	}
-}

klondike/src/snapshots/klondike__test__json.snap

@@ -1,5 +0,0 @@
----
-source: klondike/src/test.rs
-expression: serialized
----
-{"config":{"inner":{"draw_stock":"DrawOne","move_from_foundation":"Allowed","scoring":{"move_to_foundation":10,"flip_up_bonus":5,"move_to_tableau":5,"move_from_foundation":-15,"recycle":0}},"undo_penalty":-15,"solve_moves_budget":100000,"solve_states_budget":100000},"initial_state":{"stock":{"face_down":[52,51,21,59,36,45,49,50,22,3,58,39,41,61,13,57,34,56,28,1,19,12,17,5],"face_up":[]},"foundations":[[],[],[],[]],"tableau1":{"face_down":[],"face_up":[40]},"tableau2":{"face_down":[9],"face_up":[4]},"tableau3":{"face_down":[35,8],"face_up":[60]},"tableau4":{"face_down":[11,27,44],"face_up":[25]},"tableau5":{"face_down":[6,7,23,18],"face_up":[29]},"tableau6":{"face_down":[2,55,10,42,24],"face_up":[54]},"tableau7":{"face_down":[26,43,38,53,37,33],"face_up":[20]}},"instructions":[336,100,720,619,606,6,720,19,16,388,497,580,388,720,139,720,19,720,17,31,720,720,720,7,720,720,523,458,720,720,720,720,720,720,720,720,43,43,720,720,720,139,720,19,720,43,720,43,720,720,720,720,720,720,720,720,720,623,619,720,720,720,720,720,720,720,720,720,720,693,281,333,253,209,113,87,720,720,720,720,720,720,720,720,75,223,619,533,74,2,720,116,331,279,279,305,305,29,25,24,12,37,25,222,24,42,126,471,720,720,720,362,292,331,253,720,19,720,183,151,12,67,336,61,93,235,720,7,2,0,7,38,26,14,27,15,26,36,0,7,3,6,18,43,36,24,12,0,1,19,38,26,39,27,15,38,26,36]}

klondike/src/snapshots/klondike__test__save_rmp.snap

@@ -1,6 +0,0 @@
----
-source: klondike/src/test.rs
-expression: serialized
-extension: bin
-snapshot_kind: binary
----

klondike/src/test.rs

@@ -1,61 +0,0 @@
-use crate::Klondike;
-use card_game::Session;
-
-#[test]
-fn test_is_winnable() {
-	// is winnable
-	let solution_result = Session::new_default(Klondike::with_seed(124)).solve();
-	if let Ok(Some(solution)) = solution_result {
-		let win_moves = solution.clean_solution();
-		// for (i, ins) in win_moves.into_iter().enumerate() {
-		// 	println!("{i} = {:?}", ins.instruction());
-		// }
-		println!("Game is winnable with {} moves", win_moves.len());
-	} else {
-		println!("Game is not winnable");
-	}
-}
-
-#[cfg(feature = "serde")]
-#[test]
-fn test_json() {
-	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
-				.stage_instruction(snapshot.instruction().clone())
-				.unwrap()
-				.commit();
-		}
-	}
-	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);
-
-	insta::assert_snapshot!(serialized);
-}
-
-#[cfg(feature = "serde")]
-#[test]
-fn test_rmp() {
-	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
-				.stage_instruction(snapshot.instruction().clone())
-				.unwrap()
-				.commit();
-		}
-	}
-	let serialized = rmp_serde::to_vec(&session).unwrap();
-	println!("serialized.len() = {}", serialized.len());
-	let round_trip_session: Session<Klondike> = rmp_serde::from_slice(&serialized).unwrap();
-	let serialized2 = rmp_serde::to_vec(&round_trip_session).unwrap();
-	assert_eq!(serialized, serialized2);
-
-	insta::assert_binary_snapshot!("save_rmp.bin", serialized);
-}