ooh at 99% cap

This reverts commit 5a52f2ab7a.

Cargo.lock

@@ -11,8 +11,8 @@ checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c"
 [[package]]
 name = "arrayvec"
 version = "0.7.6"
-source = "sparse+https://git.aleshym.co/api/packages/Quaternions/cargo/"
+source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "813440870d646c57c222c1d713dc4e3ddcb2919c3801564d767d85d7bf2afee4"
+checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
 
 [[package]]
 name = "bitflags"
@@ -22,10 +22,9 @@ checksum = "c4512299f36f043ab09a583e57bceb5a5aab7a73db1805848e8fef3c9e8c78b3"
 
 [[package]]
 name = "card_game"
-version = "0.4.0"
+version = "0.2.0"
 dependencies = [
  "arrayvec",
- "serde",
 ]
 
 [[package]]
@@ -127,11 +126,10 @@ checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
 
 [[package]]
 name = "klondike"
-version = "0.3.0"
+version = "0.1.0"
 dependencies = [
  "card_game",
  "rand",
- "serde",
 ]
 
 [[package]]
@@ -240,7 +238,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
 dependencies = [
  "serde_core",
- "serde_derive",
 ]
 
 [[package]]

Cargo.toml

@@ -8,8 +8,8 @@ members = [
 resolver = "3"
 
 [workspace.dependencies]
-card_game = { version = "0.4.0", path = "card_game", registry = "Quaternions" }
+card_game = { version = "0.2.0", path = "card_game", registry = "Quaternions" }
-klondike = { version = "0.3.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.0"
+version = "0.2.0"
 edition = "2024"
 repository = "https://git.aleshym.co/Quaternions/card_game"
 license = "MIT OR Apache-2.0"
@@ -8,12 +8,8 @@ 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 }
+arrayvec = "0.7.6"
-serde = { version = "1", optional = true, default-features = false, features = ["derive"] }
 
 [lints]
 workspace = true

card_game/src/lib.rs

@@ -6,16 +6,11 @@ struct ReadmeDoctests;
 use core::ops::RangeBounds;
 
 // TODO: pub struct ValidInstruction<I>(I);
-pub trait Game: Clone {
+pub trait Game: Clone + core::fmt::Debug {
-	type Score: Clone + core::fmt::Debug;
 	type Stats: Clone + core::fmt::Debug;
 	type Config: Clone + core::fmt::Debug;
 	type Instruction: Clone + core::fmt::Debug;
-	fn score(&self, stats: &Self::Stats, config: &Self::Config) -> Self::Score;
+	fn possible_instructions(&self) -> impl Iterator<Item = Self::Instruction> + use<Self>;
-	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 process_instruction(
 		&mut self,
@@ -28,7 +23,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 +43,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 +72,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 +141,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::Serialize, serde::Deserialize))]
-#[cfg_attr(feature = "serde", serde(transparent))]
 pub struct Card(core::num::NonZeroU8);
 impl Card {
 	pub const fn new(deck: Deck, suit: Suit, rank: Rank) -> Self {
@@ -254,13 +244,10 @@ impl<const DN: usize, const UP: usize> Pile<DN, UP> {
 			face_up: Stack::new(),
 		}
 	}
-	/// Returns whether a card was flipped up.
+	pub fn flip_up(&mut self) {
-	pub fn flip_up(&mut self) -> bool {
 		if let Some(card) = self.face_down.pop() {
 			self.face_up.push(card);
-			return true;
 		}
-		false
 	}
 	pub fn is_empty(&self) -> bool {
 		self.face_down.is_empty() && self.face_up.is_empty()
@@ -268,31 +255,25 @@ impl<const DN: usize, const UP: usize> Pile<DN, UP> {
 	pub fn pop(&mut self) -> Option<Card> {
 		self.face_up.pop()
 	}
-	/// Returns the popped card and whether a card was flipped up.
+	pub fn pop_flip_up(&mut self) -> Option<Card> {
-	pub fn pop_flip_up(&mut self) -> (Option<Card>, bool) {
+		let card = self.face_up.pop()?;
-		let card = match self.face_up.pop() {
+		if self.face_up.is_empty() {
-			Some(card) => card,
+			self.flip_up();
-			None => return (None, false),
+		}
-		};
+		Some(card)
-		let did_flip_up = if self.face_up.is_empty() {
-			self.flip_up()
-		} else {
-			false
-		};
-		(Some(card), did_flip_up)
 	}
 	pub fn take_range<R: RangeBounds<usize>>(&mut self, range: R) -> Stack<UP> {
+		// if self.face_up.get(range).is_none() {
+		// 	return None;
+		// }
 		self.face_up.take_range(range)
 	}
-	/// Returns the card range and whether a card was flipped up.
+	pub fn take_range_flip_up<R: RangeBounds<usize>>(&mut self, range: R) -> Stack<UP> {
-	pub fn take_range_flip_up<R: RangeBounds<usize>>(&mut self, range: R) -> (Stack<UP>, bool) {
 		let cards = self.take_range(range);
-		let did_flip_up = if self.face_up.is_empty() {
+		if self.face_up.is_empty() {
-			self.flip_up()
+			self.flip_up();
-		} else {
+		}
-			false
+		cards
-		};
-		(cards, did_flip_up)
 	}
 	pub fn push(&mut self, card: Card) {
 		self.face_up.push(card);
@@ -317,59 +298,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,
@@ -378,47 +306,28 @@ pub enum SessionInstruction<I> {
 
 #[derive(Clone, Debug, Default)]
 pub struct SessionStats<S> {
-	inner: S,
+	inner_stats: S,
-	undos: u32,
+	undos: usize,
 }
 impl<S> SessionStats<S> {
 	pub const fn stats(&self) -> &S {
-		&self.inner
+		&self.inner_stats
 	}
 	const fn increment_undos(&mut self) {
 		self.undos += 1;
 	}
-	pub const fn undos(&self) -> u32 {
+	pub const fn undos(&self) -> usize {
 		self.undos
 	}
 }
-#[derive(Clone, Debug)]
+
-pub struct SessionConfig<C> {
+#[derive(Debug)]
-	pub inner: C,
+pub struct Oom;
-	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,
-		}
-	}
-}
-impl<C: Default> Default for SessionConfig<C> {
-	fn default() -> Self {
-		Self::new_default(C::default())
-	}
-}
 
 #[derive(Clone, Debug)]
 pub struct Session<G: Game> {
 	stats: SessionStats<G::Stats>,
-	config: SessionConfig<G::Config>,
+	config: G::Config,
 	state: SessionState<G>,
 }
 #[derive(Clone, Debug)]
@@ -447,18 +356,14 @@ impl<G: Game + Clone> SessionState<G> {
 		}
 	}
 }
-impl<G: Game> SessionState<G> {
+impl<G: Game> Session<G>
-	pub const fn state(&self) -> &G {
-		&self.state
-	}
-}
-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::Config: Clone,
+	G::Instruction: Clone + Eq + core::hash::Hash,
 {
-	pub fn new(state: G, config: SessionConfig<G::Config>) -> Self {
+	pub fn new(state: G, config: G::Config) -> Self {
 		Self {
 			stats: SessionStats::default(),
 			config,
@@ -474,10 +379,10 @@ where
 	pub const fn stats(&self) -> &SessionStats<G::Stats> {
 		&self.stats
 	}
-	pub const fn state(&self) -> &SessionState<G> {
+	pub const fn state(&self) -> &G {
-		&self.state
+		&self.state.state
 	}
-	pub const fn config(&self) -> &SessionConfig<G::Config> {
+	pub const fn config(&self) -> &G::Config {
 		&self.config
 	}
 	pub fn history(&self) -> &[StateSnapshot<G>] {
@@ -488,7 +393,7 @@ where
 			.process_instruction(&mut self.stats, &self.config, SessionInstruction::Undo)
 	}
 	pub fn possible_instructions(&self) -> impl Iterator<Item = G::Instruction> + use<G> {
-		self.state.state.possible_instructions(&self.config.inner)
+		self.state.state.possible_instructions()
 	}
 	pub fn process_instruction(&mut self, instruction: G::Instruction) {
 		self.state.process_instruction(
@@ -500,71 +405,81 @@ where
 	pub fn is_win(&self) -> bool {
 		self.state.is_win()
 	}
-	/// Attempt to produce a solution.
+	pub fn is_winnable(&self) -> Result<Option<Vec<StateSnapshot<G>>>, Oom> {
-	pub fn solve(&self) -> Result<Option<Solution<G>>, SolveError> {
+		const HUGE_CAP: usize = 1 << 25;
-		let mut state_moves = std::collections::HashMap::new();
+		let mut state_moves = std::collections::HashMap::with_capacity(HUGE_CAP);
-		let mut session = self.clone();
+		let mut state = self.clone();
-		let mut moves = 0;
+		while !state.is_win() {
-		while !session.is_win() {
+			// don't look for empty hash map buckets when the hash map is 99% full!
-			moves += 1;
+			if HUGE_CAP * 127 <= state_moves.len() * 128 {
-			if self.config.solve_moves_budget < moves {
+				return Err(Oom);
-				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())
+				.entry(state.state().clone())
-				.or_insert_with(|| {
+				.or_insert_with(|| state.state().possible_instructions());
-					session
-						.state()
-						.state()
-						.possible_instructions(&self.config().inner)
-				});
 
 			// Run one possible move
 			if let Some(instruction) = it.next() {
-				session.process_instruction(instruction);
+				state.process_instruction(instruction);
 				continue;
 			}
 
 			// No more moves. If we can't undo we're done
-			if session.history().is_empty() {
+			if state.history().is_empty() {
 				return Ok(None);
 			} else {
-				session.undo();
+				state.undo();
 			}
 		}
-		Ok(Some(Solution {
+
-			solution: session.state.history,
+		// history includes cycles
-		}))
+		let mut state_index: std::collections::HashMap<_, _> = state
+			.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) = state
+			.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())
+		{
+			state.state.history.drain(longest_range);
+			for (i, snapshot) in state.history().iter().enumerate() {
+				state_index.insert(snapshot.state().clone(), i);
+			}
+		}
+
+		Ok(Some(state.state.history))
 	}
 }
-impl<G: Game<Score = i32>> Game for SessionState<G>
+impl<G: Game> Game for SessionState<G>
 where
 	G::Stats: Default,
 {
-	type Score = G::Score;
 	type Stats = SessionStats<G::Stats>;
-	type Config = SessionConfig<G::Config>;
+	type Config = G::Config;
 	type Instruction = SessionInstruction<G::Instruction>;
-	fn score(&self, stats: &Self::Stats, config: &Self::Config) -> Self::Score {
+	fn possible_instructions(&self) -> impl Iterator<Item = Self::Instruction> + use<G> {
-		self.state.score(&stats.inner, &config.inner) + stats.undos as i32 * config.undo_penalty
-	}
-	fn possible_instructions(
-		&self,
-		config: &Self::Config,
-	) -> impl Iterator<Item = Self::Instruction> + use<G> {
 		self.state
-			.possible_instructions(&config.inner)
+			.possible_instructions()
 			.map(SessionInstruction::InnerInstruction)
 	}
 	fn is_instruction_valid(&self, config: &Self::Config, instruction: Self::Instruction) -> bool {
 		match instruction {
 			SessionInstruction::Undo => !self.history.is_empty(),
 			SessionInstruction::InnerInstruction(instruction) => {
-				self.state.is_instruction_valid(&config.inner, instruction)
+				self.state.is_instruction_valid(config, instruction)
 			}
 		}
 	}
@@ -587,7 +502,7 @@ where
 					instruction: instruction.clone(),
 				});
 				self.state
-					.process_instruction(&mut stats.inner, &config.inner, instruction);
+					.process_instruction(&mut stats.inner_stats, config, instruction);
 			}
 		}
 	}

klondike-bench/src/main.rs

@@ -1,5 +1,5 @@
 use card_game::Game;
-use klondike::{Klondike, KlondikeConfig, KlondikeStats, Rng, ScoringConfig};
+use klondike::{Klondike, KlondikeConfig, KlondikeStats, Rng};
 
 const MAX_MOVES: usize = 250;
 
@@ -9,15 +9,13 @@ fn play_to_win(rng: &mut Rng) -> Option<KlondikeStats> {
 	let mut stats = KlondikeStats::new();
 	const CONFIG: KlondikeConfig = KlondikeConfig {
 		draw_stock: klondike::DrawStockConfig::DrawOne,
-		move_from_foundation: klondike::MoveFromFoundationConfig::Allowed,
-		scoring: ScoringConfig::DEFAULT,
 	};
 	// play game a bit
-	while let Some(instruction) = game.get_auto_move(&CONFIG)
+	while let Some(instruction) = game.get_auto_move()
 		&& !game.is_win()
 	{
 		// quit before 250 moves
-		if (MAX_MOVES as u32) < stats.moves() + 1 {
+		if MAX_MOVES < stats.moves() + 1 {
 			return None;
 		}
 
@@ -36,9 +34,9 @@ fn main() {
 	for _ in 0..GAMES {
 		if let Some(stats) = play_to_win(&mut rng) {
 			wins += 1;
-			score_tally[(stats.score(&ScoringConfig::DEFAULT) / 5) as usize] += 1;
+			score_tally[stats.score() / 5] += 1;
-			recycle_tally[stats.recycle_count() as usize] += 1;
+			recycle_tally[stats.recycle_count()] += 1;
-			moves_tally[stats.moves() as usize] += 1;
+			moves_tally[stats.moves()] += 1;
 		}
 	}
 	println!("score_tally={score_tally:?}");

klondike-cli/src/main.rs

@@ -1,7 +1,7 @@
-use card_game::{Card, Game, Pile, Rank, Session, Suit};
+use card_game::{Card, Game, Pile, Rank, Session, SessionStats, Suit};
 use klondike::{
 	DstFoundation, DstTableau, Foundation, Klondike, KlondikeConfig, KlondikeInstruction,
-	KlondikePile, KlondikePileStack, SkipCards, Tableau, TableauStack,
+	KlondikePile, KlondikePileStack, KlondikeStats, SkipCards, Tableau, TableauStack,
 };
 
 #[cfg(test)]
@@ -13,11 +13,11 @@ struct Displayed<T>(T);
 impl Display for Displayed<&Card> {
 	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 		match self.0.rank() {
-			Rank::Ace => write!(f, " A"),
+			Rank::Ace => write!(f, "A"),
-			Rank::Jack => write!(f, " J"),
+			Rank::Jack => write!(f, "J"),
-			Rank::Queen => write!(f, " Q"),
+			Rank::Queen => write!(f, "Q"),
-			Rank::King => write!(f, " K"),
+			Rank::King => write!(f, "K"),
-			other => write!(f, "{:>2}", other as u8),
+			other => write!(f, "{}", other as u8),
 		}?;
 		match self.0.suit() {
 			Suit::Spades => write!(f, "♠"),
@@ -33,7 +33,7 @@ impl Display for OptionalCard<'_> {
 	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 		match self {
 			&OptionalCard(Some(card)) => write!(f, "{}", Displayed(card)),
-			OptionalCard(None) => write!(f, " []"),
+			OptionalCard(None) => write!(f, "None"),
 		}
 	}
 }
@@ -42,17 +42,16 @@ impl Display for Displayed<&Klondike> {
 	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 		// Stock
 		let stock_count = self.0.state().stock().face_down().len();
+		writeln!(f, "Stock: {stock_count}")?;
 
 		// Hand
 		let hand = self.0.state().stock().face_up().last();
+		writeln!(f, "Hand: {}", OptionalCard(hand))?;
 
 		// Foundations
-		writeln!(f, " STOCK       F1  F2  F3  F4")?;
 		write!(
 			f,
-			" {:>2} {}     {} {} {} {}",
+			"Foundations: {} {} {} {}",
-			stock_count,
-			OptionalCard(hand),
 			OptionalCard(self.0.state().foundation1().last()),
 			OptionalCard(self.0.state().foundation2().last()),
 			OptionalCard(self.0.state().foundation3().last()),
@@ -60,64 +59,42 @@ impl Display for Displayed<&Klondike> {
 		)?;
 		writeln!(f)?;
 
-		writeln!(f, " T1  T2  T3  T4  T5  T6  T7")?;
+		fn write_pile<const DN: usize, const UP: usize>(
-
-		fn write_pile_card<const DN: usize, const UP: usize>(
 			f: &mut std::fmt::Formatter<'_>,
 			pile: &Pile<DN, UP>,
-			row: usize,
+			pile_id: usize,
 		) -> std::fmt::Result {
-			if let Some(_card) = pile.face_down().get(row) {
+			write!(f, "T{} ", pile_id)?;
-				return write!(f, " ⎾⏋"); // └┘ ⨽⨼ ⫭⫬
+			for _ in pile.face_down() {
+				write!(f, "]")?;
 			}
-			let Some(row) = row.checked_sub(pile.face_down().len()) else {
+			for card in pile.face_up() {
-				return write!(f, "   ");
+				write!(f, "{}", Displayed(card))?;
-			};
-			if let Some(card) = pile.face_up().get(row) {
-				return write!(f, "{}", Displayed(card));
 			}
-			write!(f, "   ")
+			writeln!(f)?;
-		}
+			Ok(())
-
-		fn write_row(
-			f: &mut std::fmt::Formatter<'_>,
-			game: &Klondike,
-			row: usize,
-		) -> std::fmt::Result {
-			write_pile_card(f, game.state().tableau1(), row)?;
-			write!(f, " ")?;
-			write_pile_card(f, game.state().tableau2(), row)?;
-			write!(f, " ")?;
-			write_pile_card(f, game.state().tableau3(), row)?;
-			write!(f, " ")?;
-			write_pile_card(f, game.state().tableau4(), row)?;
-			write!(f, " ")?;
-			write_pile_card(f, game.state().tableau5(), row)?;
-			write!(f, " ")?;
-			write_pile_card(f, game.state().tableau6(), row)?;
-			write!(f, " ")?;
-			write_pile_card(f, game.state().tableau7(), row)?;
-			writeln!(f)
-		}
-
-		for row in 0..7 + 13 {
-			write_row(f, self.0, row)?;
 		}
+		write_pile(f, self.0.state().tableau1(), 1)?;
+		write_pile(f, self.0.state().tableau2(), 2)?;
+		write_pile(f, self.0.state().tableau3(), 3)?;
+		write_pile(f, self.0.state().tableau4(), 4)?;
+		write_pile(f, self.0.state().tableau5(), 5)?;
+		write_pile(f, self.0.state().tableau6(), 6)?;
+		write_pile(f, self.0.state().tableau7(), 7)?;
 
 		Ok(())
 	}
 }
 
-struct DisplayStats<'a>(&'a Session<Klondike>);
+impl Display for Displayed<&SessionStats<KlondikeStats>> {
-impl Display for DisplayStats<'_> {
 	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 		write!(
 			f,
 			"recycles: {} moves: {} undos: {} score:{}",
-			self.0.stats().stats().recycle_count(),
+			self.0.stats().recycle_count(),
-			self.0.stats().stats().moves(),
+			self.0.stats().moves(),
-			self.0.stats().undos(),
+			self.0.undos(),
-			self.0.state().score(self.0.stats(), self.0.config()),
+			self.0.stats().score() as isize - self.0.undos() as isize * 15,
 		)
 	}
 }
@@ -239,7 +216,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()
@@ -249,9 +226,9 @@ fn main() -> Result<(), std::io::Error> {
 	loop {
 		// display stats
 		println!("seed: {seed} ");
-		println!("{}", DisplayStats(&session));
+		println!("{}", Displayed(session.stats()));
 		// display game
-		println!("{}", Displayed(session.state().state()));
+		println!("{}", Displayed(session.state()));
 
 		// parse input
 		input.clear();
@@ -275,11 +252,7 @@ fn main() -> Result<(), std::io::Error> {
 				}
 			}
 			SessionInstruction::Auto => {
-				if let Some(instruction) = session
+				if let Some(instruction) = session.state().get_auto_move() {
-					.state()
-					.state()
-					.get_auto_move(&session.config().inner)
-				{
 					session.process_instruction(instruction);
 				} else {
 					println!("No valid moves!");
@@ -289,11 +262,9 @@ fn main() -> Result<(), std::io::Error> {
 				session.process_instruction(KlondikeInstruction::RotateStock)
 			}
 			SessionInstruction::Klondike(naive_instruction) => {
-				if let Some(instruction) = find_valid_instruction(
+				if let Some(instruction) =
-					&session.config().inner,
+					find_valid_instruction(session.config(), session.state(), naive_instruction)
-					session.state().state(),
+				{
-					naive_instruction,
-				) {
 					session.process_instruction(instruction);
 				} else {
 					println!("Invalid move!");

klondike-cli/src/test.rs

@@ -3,9 +3,8 @@ use klondike::Klondike;
 #[test]
 fn test_is_winnable() {
 	// is winnable
-	let solution_result = Session::new_default(Klondike::with_seed(124)).solve();
+	let is_winnable = Session::new_default(Klondike::with_seed(0)).is_winnable().unwrap();
-	if let Ok(Some(solution)) = solution_result {
+	if let Some(win_moves) = is_winnable {
-		let win_moves = solution.clean_solution();
 		// for (i, ins) in win_moves.into_iter().enumerate() {
 		// 	println!("{i} = {:?}", ins.instruction());
 		// }

klondike/Cargo.toml

@@ -1,15 +1,11 @@
 [package]
 name = "klondike"
-version = "0.3.0"
+version = "0.1.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/README.md

@@ -7,19 +7,18 @@ Klondike
 
 ```rust
 use card_game::Session;
-use klondike::{Klondike, KlondikeConfig};
+use klondike::Klondike;
 
 // create game session
 let game = Klondike::with_seed(123);
-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() {
 	session.process_instruction(instruction);
 
-	// quit after 200 moves or win
+	// quit after 1000 moves
-	if session.is_win() || 200 < session.stats().stats().moves() {
+	if 1000 < session.stats().stats().moves() {
 		break;
 	}
 }

klondike/src/lib.rs

@@ -7,110 +7,48 @@ use card_game::{Card, Game, Pile, Rank, Stack};
 #[cfg(doctest)]
 struct ReadmeDoctests;
 
-#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+#[derive(Clone, Copy, Debug, Default)]
 pub enum DrawStockConfig {
 	#[default]
 	DrawOne = 1,
 	DrawThree = 3,
 }
 
-#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
-pub enum MoveFromFoundationConfig {
-	#[default]
-	Allowed,
-	Disallowed,
-}
-
-#[derive(Clone, Copy, Debug)]
-pub struct ScoringConfig {
-	pub move_to_foundation: i32,
-	pub flip_up_bonus: i32,
-	pub move_to_tableau: i32,
-	pub move_from_foundation: i32,
-	pub recycle: i32,
-}
-impl ScoringConfig {
-	pub const DEFAULT: Self = Self {
-		move_to_foundation: 10,
-		flip_up_bonus: 5,
-		move_to_tableau: 5,
-		move_from_foundation: -15,
-		recycle: 0,
-	};
-}
-impl Default for ScoringConfig {
-	fn default() -> Self {
-		Self::DEFAULT
-	}
-}
-
 #[derive(Clone, Debug, Default)]
 pub struct KlondikeConfig {
 	pub draw_stock: DrawStockConfig,
-	pub move_from_foundation: MoveFromFoundationConfig,
-	pub scoring: ScoringConfig,
 }
 
 #[derive(Clone, Debug, Default)]
 pub struct KlondikeStats {
-	moves: u32,
+	score: usize,
-	move_to_foundation_count: u32,
+	recycle_count: usize,
-	flip_up_bonus_count: u32,
+	moves: usize,
-	move_to_tableau_count: u32,
-	move_from_foundation_count: u32,
-	recycle_count: u32,
 }
 impl KlondikeStats {
 	pub const fn new() -> Self {
 		KlondikeStats {
-			moves: 0,
+			score: 0,
-			move_to_foundation_count: 0,
-			flip_up_bonus_count: 0,
-			move_to_tableau_count: 0,
-			move_from_foundation_count: 0,
 			recycle_count: 0,
+			moves: 0,
 		}
 	}
-	pub const fn score(&self, config: &ScoringConfig) -> i32 {
+	pub const fn score(&self) -> usize {
-		self.move_to_foundation_count as i32 * config.move_to_foundation
+		self.score
-			+ self.flip_up_bonus_count as i32 * config.flip_up_bonus
-			+ self.move_to_tableau_count as i32 * config.move_to_tableau
-			+ self.move_from_foundation_count as i32 * config.move_from_foundation
-			+ self.recycle_count as i32 * config.recycle
 	}
-	pub const fn moves(&self) -> u32 {
+	pub const fn recycle_count(&self) -> usize {
-		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
 	}
-	/// A card was moved to a foundation.
+	pub const fn moves(&self) -> usize {
-	const fn increment_move_to_foundation(&mut self) {
+		self.moves
-		self.move_to_foundation_count += 1;
 	}
-	/// A card on the tableau was flipped up.
+	/// A card was moved to a foundation.
-	const fn increment_flip_up_bonus(&mut self) {
+	const fn increment_score_foundation(&mut self) {
-		self.flip_up_bonus_count += 1;
+		self.score += 10;
 	}
 	/// A card was moved from stock to tableau.
-	const fn increment_move_to_tableau(&mut self) {
+	const fn increment_score_tableau(&mut self) {
-		self.move_to_tableau_count += 1;
+		self.score += 5;
-	}
-	/// A card was moved from foundation to tableau.
-	const fn increment_move_from_foundation(&mut self) {
-		self.move_from_foundation_count += 1;
 	}
 	const fn increment_recycle_count(&mut self) {
 		self.recycle_count += 1;
@@ -121,7 +59,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 +85,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 +105,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,
@@ -202,8 +137,8 @@ impl From<Foundation> for KlondikePile {
 	}
 }
 
+#[repr(u8)]
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub enum SkipCards {
 	Skip0,
 	Skip1,
@@ -242,7 +177,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 +210,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 +233,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 +256,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 +279,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),
@@ -386,77 +316,65 @@ const fn sum(n: usize) -> usize {
 	n * (n + 1) / 2
 }
 const STOCK: usize = 52 - sum(TABLEAUS);
-const NUM_RANKS: usize = Rank::RANKS.len();
 
 #[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] {
+	pub fn is_tableau_face_down_empty(&self, tableau: Tableau) -> bool {
 		match tableau {
-			Tableau::Tableau1 => self.tableau1.face_down(),
+			Tableau::Tableau1 => self.tableau1.face_down().is_empty(),
-			Tableau::Tableau2 => self.tableau2.face_down(),
+			Tableau::Tableau2 => self.tableau2.face_down().is_empty(),
-			Tableau::Tableau3 => self.tableau3.face_down(),
+			Tableau::Tableau3 => self.tableau3.face_down().is_empty(),
-			Tableau::Tableau4 => self.tableau4.face_down(),
+			Tableau::Tableau4 => self.tableau4.face_down().is_empty(),
-			Tableau::Tableau5 => self.tableau5.face_down(),
+			Tableau::Tableau5 => self.tableau5.face_down().is_empty(),
-			Tableau::Tableau6 => self.tableau6.face_down(),
+			Tableau::Tableau6 => self.tableau6.face_down().is_empty(),
-			Tableau::Tableau7 => self.tableau7.face_down(),
+			Tableau::Tableau7 => self.tableau7.face_down().is_empty(),
-		}
-	}
-	pub fn tableau_face_up_cards(&self, tableau: Tableau) -> &[Card] {
-		match tableau {
-			Tableau::Tableau1 => self.tableau1.face_up(),
-			Tableau::Tableau2 => self.tableau2.face_up(),
-			Tableau::Tableau3 => self.tableau3.face_up(),
-			Tableau::Tableau4 => self.tableau4.face_up(),
-			Tableau::Tableau5 => self.tableau5.face_up(),
-			Tableau::Tableau6 => self.tableau6.face_up(),
-			Tableau::Tableau7 => self.tableau7.face_up(),
 		}
 	}
 	pub fn stack_bottom_card(&self, src: KlondikePileStack) -> Option<&Card> {
@@ -464,27 +382,37 @@ impl KlondikeState {
 			KlondikePileStack::Tableau(TableauStack {
 				tableau,
 				skip_cards,
-			}) => self.tableau_face_up_cards(tableau).get(skip_cards as usize),
+			}) => match tableau {
+				Tableau::Tableau1 => self.tableau1.face_up().get(skip_cards as usize),
+				Tableau::Tableau2 => self.tableau2.face_up().get(skip_cards as usize),
+				Tableau::Tableau3 => self.tableau3.face_up().get(skip_cards as usize),
+				Tableau::Tableau4 => self.tableau4.face_up().get(skip_cards as usize),
+				Tableau::Tableau5 => self.tableau5.face_up().get(skip_cards as usize),
+				Tableau::Tableau6 => self.tableau6.face_up().get(skip_cards as usize),
+				Tableau::Tableau7 => self.tableau7.face_up().get(skip_cards as usize),
+			},
 			KlondikePileStack::Foundation(foundation) => {
 				self.foundations[foundation as usize].last()
 			}
 			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) => match tableau {
-	pub fn foundation_top_card(&self, foundation: Foundation) -> Option<&Card> {
+				Tableau::Tableau1 => self.tableau1.face_up().last(),
-		self.foundations[foundation as usize].last()
+				Tableau::Tableau2 => self.tableau2.face_up().last(),
-	}
+				Tableau::Tableau3 => self.tableau3.face_up().last(),
-	pub fn top_card(&self, pile: KlondikePile) -> Option<&Card> {
+				Tableau::Tableau4 => self.tableau4.face_up().last(),
-		match pile {
+				Tableau::Tableau5 => self.tableau5.face_up().last(),
-			KlondikePile::Tableau(tableau) => self.tableau_top_card(tableau),
+				Tableau::Tableau6 => self.tableau6.face_up().last(),
-			KlondikePile::Foundation(foundation) => self.foundation_top_card(foundation),
+				Tableau::Tableau7 => self.tableau7.face_up().last(),
+			},
+			KlondikePile::Foundation(foundation) => self.foundations[foundation as usize].last(),
 			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> {
 		match src {
 			KlondikePileStack::Tableau(TableauStack {
 				tableau,
@@ -498,15 +426,14 @@ impl KlondikeState {
 				Tableau::Tableau6 => self.tableau6.take_range_flip_up(skip_cards as usize..),
 				Tableau::Tableau7 => self.tableau7.take_range_flip_up(skip_cards as usize..),
 			},
-			KlondikePileStack::Foundation(foundation) => (
+			KlondikePileStack::Foundation(foundation) => {
-				Stack::from_iter(self.foundations[foundation as usize].pop()),
+				Stack::from_iter(self.foundations[foundation as usize].pop())
-				false,
+			}
-			),
+			KlondikePileStack::Stock => Stack::from_iter(self.stock.pop()),
-			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> {
-		match pile {
+		match src.into() {
 			KlondikePile::Tableau(tableau) => match tableau {
 				Tableau::Tableau1 => self.tableau1.pop_flip_up(),
 				Tableau::Tableau2 => self.tableau2.pop_flip_up(),
@@ -516,10 +443,8 @@ impl KlondikeState {
 				Tableau::Tableau6 => self.tableau6.pop_flip_up(),
 				Tableau::Tableau7 => self.tableau7.pop_flip_up(),
 			},
-			KlondikePile::Foundation(foundation) => {
+			KlondikePile::Foundation(foundation) => self.foundations[foundation as usize].pop(),
-				(self.foundations[foundation as usize].pop(), false)
+			KlondikePile::Stock => self.stock.pop(),
-			}
-			KlondikePile::Stock => (self.stock.pop(), false),
 		}
 	}
 	fn extend_foundation<I: IntoIterator<Item = Card>>(
@@ -540,11 +465,7 @@ impl KlondikeState {
 			Tableau::Tableau7 => self.tableau7.extend(cards),
 		}
 	}
-	pub fn is_instruction_valid(
+	pub fn is_instruction_valid(&self, instruction: KlondikeInstruction) -> bool {
-		&self,
-		config: &KlondikeConfig,
-		instruction: KlondikeInstruction,
-	) -> bool {
 		match instruction {
 			// Stock -> Stock draws a card or resets the stock
 			KlondikeInstruction::RotateStock => {
@@ -556,7 +477,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?
@@ -573,14 +494,9 @@ impl KlondikeState {
 			}
 			// other = move to tableau
 			KlondikeInstruction::DstTableau(dst_tableau) => {
-				if config.move_from_foundation == MoveFromFoundationConfig::Disallowed
-					&& let KlondikePileStack::Foundation(_) = dst_tableau.src
-				{
-					return false;
-				}
 				// 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?
@@ -640,9 +556,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());
@@ -678,7 +592,7 @@ impl Klondike {
 	/// Check if the game should be auto-completed
 	pub fn is_win_trivial(&self) -> bool {
 		// all face down cards empty means win
-		self.state.stock.is_empty()
+		self.state.stock.face_down().is_empty()
 			&& self.state.tableau1.face_down().is_empty()
 			&& self.state.tableau2.face_down().is_empty()
 			&& self.state.tableau3.face_down().is_empty()
@@ -700,7 +614,7 @@ impl Klondike {
 				KlondikePileStack::Tableau(TableauStack {
 					tableau,
 					skip_cards: SkipCards::Skip0,
-				}) if !self.state().tableau_face_down_cards(tableau).is_empty()
+				}) if !self.state().is_tableau_face_down_empty(tableau)
 					|| self
 						.state()
 						.stack_bottom_card(dst_tableau.src)
@@ -716,15 +630,15 @@ impl Klondike {
 		}
 	}
 	/// A single move that usually makes progress towards a winning game
-	pub fn get_auto_move(&self, config: &KlondikeConfig) -> Option<KlondikeInstruction> {
+	pub fn get_auto_move(&self) -> Option<KlondikeInstruction> {
-		self.possible_instructions(config)
+		self.possible_instructions()
 			.filter(|ins| !ins.is_useless())
 			.min_by_key(|ins| self.instruction_priority(ins))
 	}
 	/// A list of possible moves with useless moves filtered out and sorted by a simple priority function
-	pub fn get_sorted_moves(&self, config: &KlondikeConfig) -> Vec<KlondikeInstruction> {
+	pub fn get_sorted_moves(&self) -> Vec<KlondikeInstruction> {
 		let mut useful_moves: Vec<_> = self
-			.possible_instructions(config)
+			.possible_instructions()
 			.filter(|ins| !ins.is_useless())
 			.collect();
 		useful_moves.sort_by_key(|ins| self.instruction_priority(ins));
@@ -733,24 +647,15 @@ impl Klondike {
 }
 
 impl Game for Klondike {
-	type Score = i32;
 	type Stats = KlondikeStats;
 	type Config = KlondikeConfig;
 	type Instruction = KlondikeInstruction;
-	fn score(&self, stats: &Self::Stats, config: &Self::Config) -> Self::Score {
+	fn possible_instructions(&self) -> impl Iterator<Item = Self::Instruction> + use<> {
-		stats.score(&config.scoring)
-	}
-	fn possible_instructions(
-		&self,
-		config: &Self::Config,
-	) -> impl Iterator<Item = Self::Instruction> + use<> {
 		let state = self.state.clone();
-		let config = config.clone();
+		KlondikeIter::new().filter(move |&instruction| state.is_instruction_valid(instruction))
-		KlondikeIter::new()
-			.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)
+		self.state.is_instruction_valid(instruction)
 	}
 	fn process_instruction(
 		&mut self,
@@ -773,24 +678,16 @@ impl Game for Klondike {
 			}
 			// Move a card from anywhere to a foundation
 			KlondikeInstruction::DstFoundation(DstFoundation { src, foundation }) => {
-				stats.increment_move_to_foundation();
+				stats.increment_score_foundation();
-				let (card, did_flip_up) = self.state.take_top_card_flip_up(src);
+				let card = self.state.take_top_card(src);
-				if did_flip_up {
-					stats.increment_flip_up_bonus();
-				}
 				self.state.extend_foundation(foundation, card);
 			}
 			// Move a stack of cards from anywhere to a tableau
 			KlondikeInstruction::DstTableau(DstTableau { src, tableau }) => {
-				match src {
+				if src == KlondikePileStack::Stock {
-					KlondikePileStack::Stock => stats.increment_move_to_tableau(),
+					stats.increment_score_tableau();
-					KlondikePileStack::Foundation(_) => stats.increment_move_from_foundation(),
-					KlondikePileStack::Tableau(_) => {}
-				}
-				let (cards, did_flip_up) = self.state.take_stack_flip_up(src);
-				if did_flip_up {
-					stats.increment_flip_up_bonus();
 				}
+				let cards = self.state.take_stack(src);
 				self.state.extend_tableau(tableau, cards);
 			}
 		}