separate klondike

Cargo.lock

@@ -22,9 +22,10 @@ checksum = "c4512299f36f043ab09a583e57bceb5a5aab7a73db1805848e8fef3c9e8c78b3"
 
 [[package]]
 name = "card_game"
-version = "0.2.0"
+version = "0.1.0"
 dependencies = [
  "arrayvec",
+ "rand",
 ]
 
 [[package]]
@@ -132,22 +133,12 @@ dependencies = [
  "rand",
 ]
 
-[[package]]
-name = "klondike-bench"
-version = "0.1.0"
-dependencies = [
- "card_game",
- "klondike",
- "rand",
-]
-
 [[package]]
 name = "klondike-cli"
 version = "0.1.0"
 dependencies = [
  "card_game",
  "klondike",
- "rand",
 ]
 
 [[package]]

Cargo.toml

@@ -2,22 +2,6 @@
 members = [
 	"card_game",
 	"klondike",
-	"klondike-bench",
 	"klondike-cli",
 ]
 resolver = "3"
-
-[workspace.dependencies]
-card_game = { version = "0.2.0", path = "card_game", registry = "Quaternions" }
-klondike = { version = "0.1.0", path = "klondike", registry = "Quaternions" }
-
-[workspace.lints.rust]
-# unsafe_code = "forbid"
-# missing_docs = "warn"
-# missing_debug_implementations = "warn"
-single_use_lifetimes = "warn"
-trivial_casts = "warn"
-unused_lifetimes = "warn"
-unused_qualifications = "warn"
-# variant_size_differences = "warn"
-unexpected_cfgs = "warn"

card_game/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "card_game"
-version = "0.2.0"
+version = "0.1.0"
 edition = "2024"
 repository = "https://git.aleshym.co/Quaternions/card_game"
 license = "MIT OR Apache-2.0"
@@ -10,6 +10,4 @@ keywords = ["card", "cards", "solitaire", "klondike"]
 
 [dependencies]
 arrayvec = "0.7.6"
-
-[lints]
-workspace = true
+rand = { version = "0.10.1", default-features = false, features = ["thread_rng"] }

card_game/README.md

@@ -1,19 +1,37 @@
 Card Game
 =========
 
-`card_game` is a collection of algorithms, structs, and enums which are useful to implement card games.
+`card_game` is a library to implement card games.  Mainly interesting for the `Game` trait and the `Session` type.  Contains klondike as the reference implementation.
 
 ## Example
 
 ```rust
-use card_game::{Card, Deck, Rank, Stack, Suit};
+use card_game::Rng;
+use card_game::card_game::{Session, Game};
+use card_game::klondike::Klondike;
 
-// create a full deck (unshuffled)
-let mut deck = Stack::full_deck(Deck::Deck1);
+// create game session
+let game = Klondike::new_random_default();
+let mut session = Session::new(game);
 
-// inspect the top card
-let card = deck.pop().unwrap();
-assert_eq!(card, Card::new(Deck::Deck1, Suit::Diamonds, Rank::King));
+// is winnable
+let is_winnable = session.is_winnable().is_some();
+
+// 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_winnable = {is_winnable}");
+println!("is_win = {is_win}");
 ```
 
 #### License

card_game/src/card_game.rs

@@ -0,0 +1,314 @@
+use core::ops::RangeBounds;
+
+// TODO: pub struct ValidInstruction<I>(I);
+pub trait Game {
+	type Instruction;
+	fn possible_instructions(&self) -> impl Iterator<Item = Self::Instruction> + use<Self>;
+	fn is_instruction_valid(&self, instruction: Self::Instruction) -> bool;
+	fn process_instruction(&mut self, instruction: Self::Instruction);
+	fn is_win(&self) -> bool;
+}
+
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub enum Suit {
+	Spades = 0b00,
+	Hearts = 0b01,
+	Clubs = 0b10,
+	Diamonds = 0b11,
+}
+impl Suit {
+	pub const SUITS: [Self; 4] = [Self::Spades, Self::Hearts, Self::Clubs, Self::Diamonds];
+	/// Is the suit red.
+	pub fn is_red(self) -> bool {
+		self as u8 & 0b01 != 0
+	}
+	/// Is the suit shape spikey.  (Bouba/kiki)
+	pub fn is_kiki(self) -> bool {
+		self as u8 & 0b10 != 0
+	}
+}
+
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct CardValue(u8);
+impl CardValue {
+	pub const ACE: Self = CardValue(1);
+	pub const TWO: Self = CardValue(2);
+	pub const THREE: Self = CardValue(3);
+	pub const FOUR: Self = CardValue(4);
+	pub const FIVE: Self = CardValue(5);
+	pub const SIX: Self = CardValue(6);
+	pub const SEVEN: Self = CardValue(7);
+	pub const EIGHT: Self = CardValue(8);
+	pub const NINE: Self = CardValue(9);
+	pub const TEN: Self = CardValue(10);
+	pub const JACK: Self = CardValue(11);
+	pub const QUEEN: Self = CardValue(12);
+	pub const KING: Self = CardValue(13);
+	pub fn get(self) -> u8 {
+		self.0
+	}
+	pub fn checked_add(self, offset: u8) -> Option<CardValue> {
+		let new_value = self.0.checked_add(offset)?;
+		if 13 < new_value {
+			None
+		} else {
+			Some(CardValue(new_value))
+		}
+	}
+	pub fn checked_sub(self, offset: u8) -> Option<CardValue> {
+		let new_value = self.0.checked_sub(offset)?;
+		if new_value < 1 {
+			None
+		} else {
+			Some(CardValue(new_value))
+		}
+	}
+}
+/// An identifier which specifies the deck id, suit, and card value.
+/// 2 bits for deck ID
+/// 2 bits for suit ID
+/// 4 bits for card Value
+/// TODO: better encoding for slightly more decks
+#[derive(Clone, Debug, Eq, Hash, PartialEq)]
+pub struct Card(u8);
+impl Card {
+	pub fn new(deck: u8, suit: Suit, CardValue(value): CardValue) -> Self {
+		Self(deck << 6 | (suit as u8) << 4 | value)
+	}
+	pub fn value(&self) -> CardValue {
+		let masked = self.0 & 0b1111;
+		CardValue(masked)
+	}
+	pub fn suit(&self) -> Suit {
+		let red = self.is_red();
+		let kiki = self.is_kiki();
+		match (kiki, red) {
+			(false, false) => Suit::Spades,
+			(false, true) => Suit::Hearts,
+			(true, false) => Suit::Clubs,
+			(true, true) => Suit::Diamonds,
+		}
+	}
+	/// Is the suit red.
+	pub fn is_red(&self) -> bool {
+		self.0 & 0b010000 != 0
+	}
+	/// Is the suit shape spikey.  (Bouba/kiki)
+	pub fn is_kiki(&self) -> bool {
+		self.0 & 0b100000 != 0
+	}
+	pub fn deck(&self) -> u8 {
+		self.0 >> 6
+	}
+}
+
+#[derive(Clone, Debug, Eq, Hash, PartialEq)]
+pub struct Stack<const CAP: usize>(arrayvec::ArrayVec<Card, CAP>);
+impl<const CAP: usize> Stack<CAP> {
+	pub const fn new() -> Self {
+		Self(arrayvec::ArrayVec::new_const())
+	}
+	pub fn take_range<R: RangeBounds<usize>>(&mut self, range: R) -> Self {
+		Stack::from_iter(self.drain(range))
+	}
+}
+impl Stack<52> {
+	/// Generate a full deck of cards with the specified deck id.
+	pub fn full_deck(deck: u8) -> Self {
+		let mut stack = arrayvec::ArrayVec::new();
+		for suit in Suit::SUITS {
+			for value in 1..=13 {
+				stack.push(Card::new(deck, suit, CardValue(value)));
+			}
+		}
+		Stack(stack)
+	}
+}
+impl<const CAP: usize> From<arrayvec::ArrayVec<Card, CAP>> for Stack<CAP> {
+	fn from(value: arrayvec::ArrayVec<Card, CAP>) -> Self {
+		Self(value)
+	}
+}
+impl<const CAP: usize> FromIterator<Card> for Stack<CAP> {
+	fn from_iter<T: IntoIterator<Item = Card>>(iter: T) -> Self {
+		Self(arrayvec::ArrayVec::from_iter(iter))
+	}
+}
+impl<const CAP: usize> core::ops::Deref for Stack<CAP> {
+	type Target = arrayvec::ArrayVec<Card, CAP>;
+	fn deref(&self) -> &Self::Target {
+		&self.0
+	}
+}
+impl<const CAP: usize> core::ops::DerefMut for Stack<CAP> {
+	fn deref_mut(&mut self) -> &mut Self::Target {
+		&mut self.0
+	}
+}
+impl<const CAP: usize> IntoIterator for Stack<CAP> {
+	type Item = Card;
+	type IntoIter = arrayvec::IntoIter<Card, CAP>;
+	fn into_iter(self) -> Self::IntoIter {
+		self.0.into_iter()
+	}
+}
+
+#[derive(Clone, Debug, Eq, Hash, PartialEq)]
+pub struct Pile<const DN: usize, const UP: usize> {
+	face_down: Stack<DN>,
+	face_up: Stack<UP>,
+}
+impl<const DN: usize, const UP: usize> Pile<DN, UP> {
+	pub fn new() -> Self {
+		Self {
+			face_down: Stack::new(),
+			face_up: Stack::new(),
+		}
+	}
+	pub fn new_face_down(stack: Stack<DN>) -> Self {
+		Self {
+			face_down: stack,
+			face_up: Stack::new(),
+		}
+	}
+	pub fn flip_up(&mut self) {
+		if let Some(card) = self.face_down.pop() {
+			self.face_up.push(card);
+		}
+	}
+	pub fn is_empty(&self) -> bool {
+		self.face_down.is_empty() && self.face_up.is_empty()
+	}
+	pub fn pop(&mut self) -> Option<Card> {
+		self.face_up.pop()
+	}
+	pub fn pop_flip_up(&mut self) -> Option<Card> {
+		let card = self.face_up.pop()?;
+		if self.face_up.is_empty() {
+			self.flip_up();
+		}
+		Some(card)
+	}
+	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)
+	}
+	pub fn take_range_flip_up<R: RangeBounds<usize>>(&mut self, range: R) -> Stack<UP> {
+		let cards = self.take_range(range);
+		if self.face_up.is_empty() {
+			self.flip_up();
+		}
+		cards
+	}
+	pub fn push(&mut self, card: Card) {
+		self.face_up.push(card);
+	}
+	pub fn extend<I: IntoIterator<Item = Card>>(&mut self, cards: I) {
+		self.face_up.extend(cards);
+	}
+	pub fn face_up(&self) -> &[Card] {
+		&self.face_up
+	}
+	pub fn face_down(&self) -> &[Card] {
+		&self.face_down
+	}
+}
+impl<const CAP: usize> Pile<CAP, CAP> {
+	pub fn flip_it_and_reverse_it(&mut self) {
+		self.swap_up_down();
+		self.face_down.reverse();
+	}
+	pub fn swap_up_down(&mut self) {
+		core::mem::swap(&mut self.face_up, &mut self.face_down);
+	}
+}
+
+#[derive(Clone, Debug, Eq, Hash, PartialEq)]
+pub struct Session<G: Game> {
+	seed: G,
+	state: G,
+	history: Vec<G::Instruction>,
+}
+impl<G: Game + Clone + Eq + core::hash::Hash> Session<G>
+where
+	G::Instruction: Clone + Eq + core::hash::Hash,
+{
+	pub fn new(state: G) -> Self {
+		Self {
+			seed: state.clone(),
+			state,
+			history: Vec::new(),
+		}
+	}
+	pub fn state(&self) -> &G {
+		&self.state
+	}
+	pub fn history(&self) -> &[G::Instruction] {
+		&self.history
+	}
+	pub fn is_winnable(&self) -> Option<Vec<G::Instruction>> {
+		let mut observed = std::collections::HashSet::new();
+		struct StateMachine<G, P, I> {
+			state: G,
+			possible_instructions_iter: P,
+			instruction: I,
+		}
+		let mut state = self.state.clone();
+		let mut it = state.possible_instructions();
+		let mut path = Vec::new();
+		'outer: while !state.is_win() {
+			observed.insert(state.clone());
+			for instruction in &mut it {
+				let mut next_state = state.clone();
+				next_state.process_instruction(instruction.clone());
+				if !observed.contains(&next_state) {
+					let possible_instructions_iter =
+						core::mem::replace(&mut it, next_state.possible_instructions());
+					let state = core::mem::replace(&mut state, next_state);
+					path.push(StateMachine {
+						state,
+						possible_instructions_iter,
+						instruction,
+					});
+					continue 'outer;
+				}
+			}
+			let Some(last_state) = path.pop() else {
+				return None;
+			};
+			state = last_state.state;
+			it = last_state.possible_instructions_iter;
+		}
+		Some(path.into_iter().map(|state| state.instruction).collect())
+	}
+	pub fn undo(&mut self) {
+		// replay the entire history of the game except one move
+		self.history.pop();
+		let mut state = self.seed.clone();
+		for instruction in self.history() {
+			state.process_instruction(instruction.clone());
+		}
+		self.state = state;
+	}
+}
+impl<G: Game> Game for Session<G>
+where
+	G::Instruction: Clone,
+{
+	type Instruction = G::Instruction;
+	fn possible_instructions(&self) -> impl Iterator<Item = Self::Instruction> + use<G> {
+		self.state.possible_instructions()
+	}
+	fn is_instruction_valid(&self, instruction: Self::Instruction) -> bool {
+		self.state.is_instruction_valid(instruction)
+	}
+	fn process_instruction(&mut self, instruction: Self::Instruction) {
+		self.history.push(instruction.clone());
+		self.state.process_instruction(instruction);
+	}
+	fn is_win(&self) -> bool {
+		self.state.is_win()
+	}
+}

card_game/src/lib.rs

@@ -1,512 +1,7 @@
-// test readme
-#[doc = include_str!("../README.md")]
-#[cfg(doctest)]
-struct ReadmeDoctests;
+mod card_game;
+pub use card_game::*;
 
-use core::ops::RangeBounds;
-
-// TODO: pub struct ValidInstruction<I>(I);
-pub trait Game: Clone + core::fmt::Debug {
-	type Stats: Clone + core::fmt::Debug;
-	type Config: Clone + core::fmt::Debug;
-	type Instruction: Clone + core::fmt::Debug;
-	fn possible_instructions(&self) -> impl Iterator<Item = Self::Instruction> + use<Self>;
-	fn is_instruction_valid(&self, config: &Self::Config, instruction: Self::Instruction) -> bool;
-	fn process_instruction(
-		&mut self,
-		stats: &mut Self::Stats,
-		config: &Self::Config,
-		instruction: Self::Instruction,
-	);
-	fn is_win(&self) -> bool;
-}
-
-/// card_game supports up to 4 identifiably separate decks.
-#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub enum Deck {
-	Deck1 = 0b00,
-	Deck2 = 0b01,
-	Deck3 = 0b10,
-	Deck4 = 0b11,
-}
-impl Deck {
-	pub const fn new(deck: u8) -> Option<Self> {
-		use Deck::*;
-		Some(match deck {
-			0b00 => Deck1,
-			0b01 => Deck2,
-			0b10 => Deck3,
-			0b11 => Deck4,
-			_ => return None,
-		})
-	}
-}
-
-#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub enum Suit {
-	Spades = 0b00,
-	Hearts = 0b01,
-	Clubs = 0b10,
-	Diamonds = 0b11,
-}
-impl Suit {
-	pub const SUITS: [Self; 4] = [Self::Spades, Self::Hearts, Self::Clubs, Self::Diamonds];
-	pub const fn new(suit: u8) -> Option<Self> {
-		use Suit::*;
-		Some(match suit {
-			0b00 => Spades,
-			0b01 => Hearts,
-			0b10 => Clubs,
-			0b11 => Diamonds,
-			_ => return None,
-		})
-	}
-	/// Is the suit red.
-	pub const fn is_red(self) -> bool {
-		self as u8 & 0b01 != 0
-	}
-	/// Suit value is 2 bits, is_red is the low bit.
-	pub const fn suit_high_bit(self) -> bool {
-		self as u8 & 0b10 != 0
-	}
-}
-
-#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub enum Rank {
-	Ace = 1,
-	Two = 2,
-	Three = 3,
-	Four = 4,
-	Five = 5,
-	Six = 6,
-	Seven = 7,
-	Eight = 8,
-	Nine = 9,
-	Ten = 10,
-	Jack = 11,
-	Queen = 12,
-	King = 13,
-}
-impl Rank {
-	pub const RANKS: [Self; 13] = [
-		Self::Ace,
-		Self::Two,
-		Self::Three,
-		Self::Four,
-		Self::Five,
-		Self::Six,
-		Self::Seven,
-		Self::Eight,
-		Self::Nine,
-		Self::Ten,
-		Self::Jack,
-		Self::Queen,
-		Self::King,
-	];
-	pub const fn new(rank: u8) -> Option<Self> {
-		use Rank::*;
-		Some(match rank {
-			1 => Ace,
-			2 => Two,
-			3 => Three,
-			4 => Four,
-			5 => Five,
-			6 => Six,
-			7 => Seven,
-			8 => Eight,
-			9 => Nine,
-			10 => Ten,
-			11 => Jack,
-			12 => Queen,
-			13 => King,
-			_ => return None,
-		})
-	}
-	pub const fn checked_add(self, offset: u8) -> Option<Rank> {
-		match (self as u8).checked_add(offset) {
-			Some(rank) => Self::new(rank),
-			None => None,
-		}
-	}
-	pub const fn checked_sub(self, offset: u8) -> Option<Rank> {
-		match (self as u8).checked_sub(offset) {
-			Some(rank) => Self::new(rank),
-			None => None,
-		}
-	}
-}
-
-/// A card which specifies the deck id, suit, and card value.
-/// 2 bits for deck ID
-/// 2 bits for suit ID
-/// 4 bits for card Value
-#[derive(Clone, Debug, Eq, Hash, PartialEq)]
-pub struct Card(core::num::NonZeroU8);
-impl Card {
-	pub const fn new(deck: Deck, suit: Suit, rank: Rank) -> Self {
-		let packed = (deck as u8) << 6 | (suit as u8) << 4 | (rank as u8);
-		Self(core::num::NonZeroU8::new(packed).unwrap())
-	}
-	pub const fn rank(&self) -> Rank {
-		let masked = self.0.get() & 0b1111;
-		Rank::new(masked).unwrap()
-	}
-	pub const fn suit(&self) -> Suit {
-		let low_bit = self.is_red();
-		let high_bit = self.suit_high_bit();
-		match (high_bit, low_bit) {
-			(false, false) => Suit::Spades,
-			(false, true) => Suit::Hearts,
-			(true, false) => Suit::Clubs,
-			(true, true) => Suit::Diamonds,
-		}
-	}
-	/// Is the suit red.
-	pub const fn is_red(&self) -> bool {
-		self.0.get() & 0b010000 != 0
-	}
-	/// Suit value is 2 bits, is_red is the low bit.
-	pub const fn suit_high_bit(&self) -> bool {
-		self.0.get() & 0b100000 != 0
-	}
-	pub const fn deck(&self) -> Deck {
-		Deck::new(self.0.get() >> 6).unwrap()
-	}
-}
-
-#[derive(Clone, Debug, Default, Eq, Hash, PartialEq)]
-pub struct Stack<const CAP: usize>(arrayvec::ArrayVec<Card, CAP>);
-impl<const CAP: usize> Stack<CAP> {
-	pub const fn new() -> Self {
-		Self(arrayvec::ArrayVec::new_const())
-	}
-	pub fn take_range<R: RangeBounds<usize>>(&mut self, range: R) -> Self {
-		Stack::from_iter(self.drain(range))
-	}
-}
-impl Stack<52> {
-	/// Generate a full deck of cards with the specified deck id.
-	pub fn full_deck(deck: Deck) -> Self {
-		let mut stack = arrayvec::ArrayVec::new();
-		for suit in Suit::SUITS {
-			for rank in Rank::RANKS {
-				stack.push(Card::new(deck, suit, rank));
-			}
-		}
-		Stack(stack)
-	}
-}
-impl<const CAP: usize> From<arrayvec::ArrayVec<Card, CAP>> for Stack<CAP> {
-	fn from(value: arrayvec::ArrayVec<Card, CAP>) -> Self {
-		Self(value)
-	}
-}
-impl<const CAP: usize> FromIterator<Card> for Stack<CAP> {
-	fn from_iter<T: IntoIterator<Item = Card>>(iter: T) -> Self {
-		Self(arrayvec::ArrayVec::from_iter(iter))
-	}
-}
-impl<const CAP: usize> core::ops::Deref for Stack<CAP> {
-	type Target = arrayvec::ArrayVec<Card, CAP>;
-	fn deref(&self) -> &Self::Target {
-		&self.0
-	}
-}
-impl<const CAP: usize> core::ops::DerefMut for Stack<CAP> {
-	fn deref_mut(&mut self) -> &mut Self::Target {
-		&mut self.0
-	}
-}
-impl<const CAP: usize> IntoIterator for Stack<CAP> {
-	type Item = Card;
-	type IntoIter = arrayvec::IntoIter<Card, CAP>;
-	fn into_iter(self) -> Self::IntoIter {
-		self.0.into_iter()
-	}
-}
-
-/// A pile is a stack of face down cards and a stack of face up cards.
-#[derive(Clone, Debug, Default, Eq, Hash, PartialEq)]
-pub struct Pile<const DN: usize, const UP: usize> {
-	face_down: Stack<DN>,
-	face_up: Stack<UP>,
-}
-impl<const DN: usize, const UP: usize> Pile<DN, UP> {
-	pub const fn new() -> Self {
-		Self {
-			face_down: Stack::new(),
-			face_up: Stack::new(),
-		}
-	}
-	pub const fn new_face_down(stack: Stack<DN>) -> Self {
-		Self {
-			face_down: stack,
-			face_up: Stack::new(),
-		}
-	}
-	pub fn flip_up(&mut self) {
-		if let Some(card) = self.face_down.pop() {
-			self.face_up.push(card);
-		}
-	}
-	pub fn is_empty(&self) -> bool {
-		self.face_down.is_empty() && self.face_up.is_empty()
-	}
-	pub fn pop(&mut self) -> Option<Card> {
-		self.face_up.pop()
-	}
-	pub fn pop_flip_up(&mut self) -> Option<Card> {
-		let card = self.face_up.pop()?;
-		if self.face_up.is_empty() {
-			self.flip_up();
-		}
-		Some(card)
-	}
-	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)
-	}
-	pub fn take_range_flip_up<R: RangeBounds<usize>>(&mut self, range: R) -> Stack<UP> {
-		let cards = self.take_range(range);
-		if self.face_up.is_empty() {
-			self.flip_up();
-		}
-		cards
-	}
-	pub fn push(&mut self, card: Card) {
-		self.face_up.push(card);
-	}
-	pub fn extend<I: IntoIterator<Item = Card>>(&mut self, cards: I) {
-		self.face_up.extend(cards);
-	}
-	pub fn face_up(&self) -> &[Card] {
-		&self.face_up
-	}
-	pub fn face_down(&self) -> &[Card] {
-		&self.face_down
-	}
-}
-impl<const CAP: usize> Pile<CAP, CAP> {
-	pub fn flip_it_and_reverse_it(&mut self) {
-		self.swap_up_down();
-		self.face_down.reverse();
-	}
-	pub const fn swap_up_down(&mut self) {
-		core::mem::swap(&mut self.face_up, &mut self.face_down);
-	}
-}
-
-#[derive(Clone, Debug)]
-pub enum SessionInstruction<I> {
-	Undo,
-	InnerInstruction(I),
-}
-
-#[derive(Clone, Debug, Default)]
-pub struct SessionStats<S> {
-	inner_stats: S,
-	undos: usize,
-}
-impl<S> SessionStats<S> {
-	pub const fn stats(&self) -> &S {
-		&self.inner_stats
-	}
-	const fn increment_undos(&mut self) {
-		self.undos += 1;
-	}
-	pub const fn undos(&self) -> usize {
-		self.undos
-	}
-}
-
-#[derive(Debug)]
-pub struct Oom;
-
-#[derive(Clone, Debug)]
-pub struct Session<G: Game> {
-	stats: SessionStats<G::Stats>,
-	config: G::Config,
-	state: SessionState<G>,
-}
-#[derive(Clone, Debug)]
-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> {
-	state: G,
-	history: Vec<StateSnapshot<G>>,
-}
-impl<G: Game + Clone> SessionState<G> {
-	fn new(state: G) -> Self {
-		Self {
-			state,
-			history: Vec::new(),
-		}
-	}
-}
-impl<G: Game> Session<G>
-where
-	G: Clone + Eq + core::hash::Hash,
-	G::Stats: Clone + Default,
-	G::Config: Clone,
-	G::Instruction: Clone + Eq + core::hash::Hash,
-{
-	pub fn new(state: G, config: G::Config) -> Self {
-		Self {
-			stats: SessionStats::default(),
-			config,
-			state: SessionState::new(state),
-		}
-	}
-	pub fn new_default(state: G) -> Self
-	where
-		G::Config: Default,
-	{
-		Self::new(state, Default::default())
-	}
-	pub const fn stats(&self) -> &SessionStats<G::Stats> {
-		&self.stats
-	}
-	pub const fn state(&self) -> &G {
-		&self.state.state
-	}
-	pub const fn config(&self) -> &G::Config {
-		&self.config
-	}
-	pub fn history(&self) -> &[StateSnapshot<G>] {
-		&self.state.history
-	}
-	pub fn undo(&mut self) {
-		self.state
-			.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()
-	}
-	pub fn process_instruction(&mut self, instruction: G::Instruction) {
-		self.state.process_instruction(
-			&mut self.stats,
-			&self.config,
-			SessionInstruction::InnerInstruction(instruction),
-		)
-	}
-	pub fn is_win(&self) -> bool {
-		self.state.is_win()
-	}
-	pub fn is_winnable(&self) -> Result<Option<Vec<StateSnapshot<G>>>, Oom> {
-		const HUGE_CAP: usize = 1 << 25;
-		let mut state_moves = std::collections::HashMap::with_capacity(HUGE_CAP);
-		let mut state = self.clone();
-		while !state.is_win() {
-			// don't look for empty hash map buckets when the hash map is 99% full!
-			if HUGE_CAP * 127 <= state_moves.len() * 128 {
-				return Err(Oom);
-			}
-
-			// Continue existing iterator if it exists
-			let it = state_moves
-				.entry(state.state().clone())
-				.or_insert_with(|| state.state().possible_instructions());
-
-			// Run one possible move
-			if let Some(instruction) = it.next() {
-				state.process_instruction(instruction);
-				continue;
-			}
-
-			// No more moves. If we can't undo we're done
-			if state.history().is_empty() {
-				return Ok(None);
-			} else {
-				state.undo();
-			}
-		}
-
-		// 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> Game for SessionState<G>
-where
-	G::Stats: Default,
-{
-	type Stats = SessionStats<G::Stats>;
-	type Config = G::Config;
-	type Instruction = SessionInstruction<G::Instruction>;
-	fn possible_instructions(&self) -> impl Iterator<Item = Self::Instruction> + use<G> {
-		self.state
-			.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, instruction)
-			}
-		}
-	}
-	fn process_instruction(
-		&mut self,
-		stats: &mut Self::Stats,
-		config: &Self::Config,
-		instruction: Self::Instruction,
-	) {
-		match instruction {
-			SessionInstruction::Undo => {
-				if let Some(snapshot) = self.history.pop() {
-					self.state = snapshot.state;
-					stats.increment_undos();
-				}
-			}
-			SessionInstruction::InnerInstruction(instruction) => {
-				self.history.push(StateSnapshot {
-					state: self.state.clone(),
-					instruction: instruction.clone(),
-				});
-				self.state
-					.process_instruction(&mut stats.inner_stats, config, instruction);
-			}
-		}
-	}
-	fn is_win(&self) -> bool {
-		self.state.is_win()
-	}
-}
+// // test readme
+// #[doc = include_str!("../README.md")]
+// #[cfg(doctest)]
+// struct ReadmeDoctests;

klondike-bench/Cargo.toml

@@ -1,12 +0,0 @@
-[package]
-name = "klondike-bench"
-version = "0.1.0"
-edition = "2024"
-
-[dependencies]
-card_game.workspace = true
-klondike.workspace = true
-rand = { version = "0.10.1", default-features = false }
-
-[lints]
-workspace = true

klondike-bench/src/main.rs

@@ -1,46 +0,0 @@
-use card_game::Game;
-use klondike::{Klondike, KlondikeConfig, KlondikeStats, Rng};
-
-const MAX_MOVES: usize = 250;
-
-fn play_to_win(rng: &mut Rng) -> Option<KlondikeStats> {
-	// create game session
-	let mut game = Klondike::with_rng(rng);
-	let mut stats = KlondikeStats::new();
-	const CONFIG: KlondikeConfig = KlondikeConfig {
-		draw_stock: klondike::DrawStockConfig::DrawOne,
-	};
-	// play game a bit
-	while let Some(instruction) = game.get_auto_move()
-		&& !game.is_win()
-	{
-		// quit before 250 moves
-		if MAX_MOVES < stats.moves() + 1 {
-			return None;
-		}
-
-		game.process_instruction(&mut stats, &CONFIG, instruction);
-	}
-	game.is_win().then_some(stats)
-}
-fn main() {
-	use rand::SeedableRng;
-	let mut rng = Rng::seed_from_u64(0);
-	const GAMES: u32 = 1000;
-	let mut wins = 0;
-	let mut score_tally = [0usize; MAX_MOVES * 10 / 5];
-	let mut recycle_tally = [0usize; MAX_MOVES];
-	let mut moves_tally = [0usize; MAX_MOVES];
-	for _ in 0..GAMES {
-		if let Some(stats) = play_to_win(&mut rng) {
-			wins += 1;
-			score_tally[stats.score() / 5] += 1;
-			recycle_tally[stats.recycle_count()] += 1;
-			moves_tally[stats.moves()] += 1;
-		}
-	}
-	println!("score_tally={score_tally:?}");
-	println!("recycle_tally={recycle_tally:?}");
-	println!("moves_tally={moves_tally:?}");
-	println!("wins = {wins}/{GAMES} win_rate = {}%", wins * 100 / GAMES);
-}

klondike-cli/Cargo.toml

@@ -4,9 +4,5 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
-card_game.workspace = true
-klondike.workspace = true
-rand = { version = "0.10.1", default-features = false, features = ["thread_rng"] }
-
-[lints]
-workspace = true
+card_game = { version = "0.1.0", path = "../card_game" }
+klondike = { version = "0.1.0", path = "../klondike" }

klondike-cli/src/main.rs

@@ -1,23 +1,20 @@
-use card_game::{Card, Game, Pile, Rank, Session, SessionStats, Suit};
+use card_game::{Card, Game, Pile, Session, Suit};
 use klondike::{
-	DstFoundation, DstTableau, Foundation, Klondike, KlondikeConfig, KlondikeInstruction,
-	KlondikePile, KlondikePileStack, KlondikeStats, SkipCards, Tableau, TableauStack,
+	DstFoundation, DstTableau, Foundation, Klondike, KlondikeInstruction, KlondikePile,
+	KlondikePileStack, SkipCards, Tableau, TableauStack,
 };
 
-#[cfg(test)]
-mod test;
-
 use std::fmt::Display;
 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::Jack => write!(f, "J"),
-			Rank::Queen => write!(f, "Q"),
-			Rank::King => write!(f, "K"),
-			other => write!(f, "{}", other as u8),
+		match self.0.value().get() {
+			1 => write!(f, "A"),
+			11 => write!(f, "J"),
+			12 => write!(f, "Q"),
+			13 => write!(f, "K"),
+			other => write!(f, "{other}"),
 		}?;
 		match self.0.suit() {
 			Suit::Spades => write!(f, "♠"),
@@ -86,19 +83,6 @@ impl Display for Displayed<&Klondike> {
 	}
 }
 
-impl Display for Displayed<&SessionStats<KlondikeStats>> {
-	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-		write!(
-			f,
-			"recycles: {} moves: {} undos: {} score:{}",
-			self.0.stats().recycle_count(),
-			self.0.stats().moves(),
-			self.0.undos(),
-			self.0.stats().score() as isize - self.0.undos() as isize * 15,
-		)
-	}
-}
-
 #[derive(Debug)]
 struct Invalid;
 struct Parsed<T>(T);
@@ -151,7 +135,7 @@ impl core::str::FromStr for SessionInstruction {
 			"new" | "n" => Self::New,
 			"undo" | "u" => Self::Undo,
 			"hint" | "h" => Self::Hint,
-			"auto" | "a" | "" => Self::Auto,
+			"auto" | "a" => Self::Auto,
 			"exit" => Self::Exit,
 			"s" => Self::Stock,
 			other => Self::Klondike(other.parse()?),
@@ -160,7 +144,6 @@ impl core::str::FromStr for SessionInstruction {
 }
 
 fn find_valid_instruction(
-	config: &KlondikeConfig,
 	state: &Klondike,
 	naive_instruction: NaiveInstruction,
 ) -> Option<KlondikeInstruction> {
@@ -190,7 +173,7 @@ fn find_valid_instruction(
 						});
 						let instruction =
 							KlondikeInstruction::DstTableau(DstTableau { tableau, src });
-						if state.is_instruction_valid(config, instruction) {
+						if state.is_instruction_valid(instruction) {
 							return Some(instruction);
 						}
 					}
@@ -208,30 +191,18 @@ fn find_valid_instruction(
 		_ => return None,
 	};
 	state
-		.is_instruction_valid(config, instruction)
+		.is_instruction_valid(instruction)
 		.then_some(instruction)
 }
 
 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().skip(1).next() {
-		seed.parse().expect("Invalid u64 seed")
-	} else {
-		rng.random()
-	};
-	let mut session = Session::new_default(Klondike::with_seed(seed));
-	let mut input = String::new();
+	let mut session = Session::new(Klondike::new_random_default());
 	loop {
-		// display stats
-		println!("seed: {seed} ");
-		println!("{}", Displayed(session.stats()));
 		// display game
 		println!("{}", Displayed(session.state()));
 
 		// parse input
-		input.clear();
+		let mut input = String::new();
 		std::io::stdin().read_line(&mut input)?;
 		let Ok(instruction) = input.trim().parse() else {
 			println!("Invalid instruction.");
@@ -240,10 +211,7 @@ fn main() -> Result<(), std::io::Error> {
 
 		// run game
 		match instruction {
-			SessionInstruction::New => {
-				seed = rng.random();
-				session = Session::new_default(Klondike::with_seed(seed))
-			}
+			SessionInstruction::New => session = Session::new(Klondike::new_random_default()),
 			SessionInstruction::Undo => session.undo(),
 			SessionInstruction::Exit => break Ok(()),
 			SessionInstruction::Hint => {
@@ -252,7 +220,33 @@ fn main() -> Result<(), std::io::Error> {
 				}
 			}
 			SessionInstruction::Auto => {
-				if let Some(instruction) = session.state().get_auto_move() {
+				fn useless_moves(instruction: &KlondikeInstruction) -> bool {
+					!matches!(
+						instruction,
+						// foundation -> foundation is a useless move
+						KlondikeInstruction::DstFoundation(DstFoundation {
+							src: KlondikePile::Foundation(_),
+							..
+						})
+						// Tableau -> Tableau when not revealing a new card is _usually_ a useless move
+						| KlondikeInstruction::DstTableau(DstTableau {
+							src: KlondikePileStack::Tableau(TableauStack {
+								skip_cards: SkipCards::Skip1
+									| SkipCards::Skip2 | SkipCards::Skip3
+									| SkipCards::Skip4 | SkipCards::Skip5
+									| SkipCards::Skip6 | SkipCards::Skip7
+									| SkipCards::Skip8 | SkipCards::Skip9
+									| SkipCards::Skip10 | SkipCards::Skip11
+									| SkipCards::Skip12,
+								..
+							}),
+							..
+						})
+					)
+				}
+				if let Some(instruction) =
+					session.possible_instructions().filter(useless_moves).next()
+				{
 					session.process_instruction(instruction);
 				} else {
 					println!("No valid moves!");
@@ -263,7 +257,7 @@ fn main() -> Result<(), std::io::Error> {
 			}
 			SessionInstruction::Klondike(naive_instruction) => {
 				if let Some(instruction) =
-					find_valid_instruction(session.config(), session.state(), naive_instruction)
+					find_valid_instruction(session.state(), naive_instruction)
 				{
 					session.process_instruction(instruction);
 				} else {

klondike-cli/src/test.rs

@@ -1,15 +0,0 @@
-use card_game::Session;
-use klondike::Klondike;
-#[test]
-fn test_is_winnable() {
-	// is winnable
-	let is_winnable = Session::new_default(Klondike::with_seed(0)).is_winnable().unwrap();
-	if let Some(win_moves) = is_winnable {
-		// 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");
-	}
-}

klondike/Cargo.toml

@@ -4,8 +4,5 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
-card_game.workspace = true
-rand = { version = "0.10.1", default-features = false, features = ["std_rng"] }
-
-[lints]
-workspace = true
+card_game = { version = "0.1.0", path = "../card_game" }
+rand = { version = "0.10.1", default-features = false, features = ["thread_rng"] }

klondike/LICENSE-APACHE

@@ -1,176 +0,0 @@
-                              Apache License
-                        Version 2.0, January 2004
-                     http://www.apache.org/licenses/
-
-TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-1. Definitions.
-
-   "License" shall mean the terms and conditions for use, reproduction,
-   and distribution as defined by Sections 1 through 9 of this document.
-
-   "Licensor" shall mean the copyright owner or entity authorized by
-   the copyright owner that is granting the License.
-
-   "Legal Entity" shall mean the union of the acting entity and all
-   other entities that control, are controlled by, or are under common
-   control with that entity. For the purposes of this definition,
-   "control" means (i) the power, direct or indirect, to cause the
-   direction or management of such entity, whether by contract or
-   otherwise, or (ii) ownership of fifty percent (50%) or more of the
-   outstanding shares, or (iii) beneficial ownership of such entity.
-
-   "You" (or "Your") shall mean an individual or Legal Entity
-   exercising permissions granted by this License.
-
-   "Source" form shall mean the preferred form for making modifications,
-   including but not limited to software source code, documentation
-   source, and configuration files.
-
-   "Object" form shall mean any form resulting from mechanical
-   transformation or translation of a Source form, including but
-   not limited to compiled object code, generated documentation,
-   and conversions to other media types.
-
-   "Work" shall mean the work of authorship, whether in Source or
-   Object form, made available under the License, as indicated by a
-   copyright notice that is included in or attached to the work
-   (an example is provided in the Appendix below).
-
-   "Derivative Works" shall mean any work, whether in Source or Object
-   form, that is based on (or derived from) the Work and for which the
-   editorial revisions, annotations, elaborations, or other modifications
-   represent, as a whole, an original work of authorship. For the purposes
-   of this License, Derivative Works shall not include works that remain
-   separable from, or merely link (or bind by name) to the interfaces of,
-   the Work and Derivative Works thereof.
-
-   "Contribution" shall mean any work of authorship, including
-   the original version of the Work and any modifications or additions
-   to that Work or Derivative Works thereof, that is intentionally
-   submitted to Licensor for inclusion in the Work by the copyright owner
-   or by an individual or Legal Entity authorized to submit on behalf of
-   the copyright owner. For the purposes of this definition, "submitted"
-   means any form of electronic, verbal, or written communication sent
-   to the Licensor or its representatives, including but not limited to
-   communication on electronic mailing lists, source code control systems,
-   and issue tracking systems that are managed by, or on behalf of, the
-   Licensor for the purpose of discussing and improving the Work, but
-   excluding communication that is conspicuously marked or otherwise
-   designated in writing by the copyright owner as "Not a Contribution."
-
-   "Contributor" shall mean Licensor and any individual or Legal Entity
-   on behalf of whom a Contribution has been received by Licensor and
-   subsequently incorporated within the Work.
-
-2. Grant of Copyright License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   copyright license to reproduce, prepare Derivative Works of,
-   publicly display, publicly perform, sublicense, and distribute the
-   Work and such Derivative Works in Source or Object form.
-
-3. Grant of Patent License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   (except as stated in this section) patent license to make, have made,
-   use, offer to sell, sell, import, and otherwise transfer the Work,
-   where such license applies only to those patent claims licensable
-   by such Contributor that are necessarily infringed by their
-   Contribution(s) alone or by combination of their Contribution(s)
-   with the Work to which such Contribution(s) was submitted. If You
-   institute patent litigation against any entity (including a
-   cross-claim or counterclaim in a lawsuit) alleging that the Work
-   or a Contribution incorporated within the Work constitutes direct
-   or contributory patent infringement, then any patent licenses
-   granted to You under this License for that Work shall terminate
-   as of the date such litigation is filed.
-
-4. Redistribution. You may reproduce and distribute copies of the
-   Work or Derivative Works thereof in any medium, with or without
-   modifications, and in Source or Object form, provided that You
-   meet the following conditions:
-
-   (a) You must give any other recipients of the Work or
-       Derivative Works a copy of this License; and
-
-   (b) You must cause any modified files to carry prominent notices
-       stating that You changed the files; and
-
-   (c) You must retain, in the Source form of any Derivative Works
-       that You distribute, all copyright, patent, trademark, and
-       attribution notices from the Source form of the Work,
-       excluding those notices that do not pertain to any part of
-       the Derivative Works; and
-
-   (d) If the Work includes a "NOTICE" text file as part of its
-       distribution, then any Derivative Works that You distribute must
-       include a readable copy of the attribution notices contained
-       within such NOTICE file, excluding those notices that do not
-       pertain to any part of the Derivative Works, in at least one
-       of the following places: within a NOTICE text file distributed
-       as part of the Derivative Works; within the Source form or
-       documentation, if provided along with the Derivative Works; or,
-       within a display generated by the Derivative Works, if and
-       wherever such third-party notices normally appear. The contents
-       of the NOTICE file are for informational purposes only and
-       do not modify the License. You may add Your own attribution
-       notices within Derivative Works that You distribute, alongside
-       or as an addendum to the NOTICE text from the Work, provided
-       that such additional attribution notices cannot be construed
-       as modifying the License.
-
-   You may add Your own copyright statement to Your modifications and
-   may provide additional or different license terms and conditions
-   for use, reproduction, or distribution of Your modifications, or
-   for any such Derivative Works as a whole, provided Your use,
-   reproduction, and distribution of the Work otherwise complies with
-   the conditions stated in this License.
-
-5. Submission of Contributions. Unless You explicitly state otherwise,
-   any Contribution intentionally submitted for inclusion in the Work
-   by You to the Licensor shall be under the terms and conditions of
-   this License, without any additional terms or conditions.
-   Notwithstanding the above, nothing herein shall supersede or modify
-   the terms of any separate license agreement you may have executed
-   with Licensor regarding such Contributions.
-
-6. Trademarks. This License does not grant permission to use the trade
-   names, trademarks, service marks, or product names of the Licensor,
-   except as required for reasonable and customary use in describing the
-   origin of the Work and reproducing the content of the NOTICE file.
-
-7. Disclaimer of Warranty. Unless required by applicable law or
-   agreed to in writing, Licensor provides the Work (and each
-   Contributor provides its Contributions) on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-   implied, including, without limitation, any warranties or conditions
-   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-   PARTICULAR PURPOSE. You are solely responsible for determining the
-   appropriateness of using or redistributing the Work and assume any
-   risks associated with Your exercise of permissions under this License.
-
-8. Limitation of Liability. In no event and under no legal theory,
-   whether in tort (including negligence), contract, or otherwise,
-   unless required by applicable law (such as deliberate and grossly
-   negligent acts) or agreed to in writing, shall any Contributor be
-   liable to You for damages, including any direct, indirect, special,
-   incidental, or consequential damages of any character arising as a
-   result of this License or out of the use or inability to use the
-   Work (including but not limited to damages for loss of goodwill,
-   work stoppage, computer failure or malfunction, or any and all
-   other commercial damages or losses), even if such Contributor
-   has been advised of the possibility of such damages.
-
-9. Accepting Warranty or Additional Liability. While redistributing
-   the Work or Derivative Works thereof, You may choose to offer,
-   and charge a fee for, acceptance of support, warranty, indemnity,
-   or other liability obligations and/or rights consistent with this
-   License. However, in accepting such obligations, You may act only
-   on Your own behalf and on Your sole responsibility, not on behalf
-   of any other Contributor, and only if You agree to indemnify,
-   defend, and hold each Contributor harmless for any liability
-   incurred by, or claims asserted against, such Contributor by reason
-   of your accepting any such warranty or additional liability.
-
-END OF TERMS AND CONDITIONS

klondike/LICENSE-MIT

@@ -1,23 +0,0 @@
-Permission is hereby granted, free of charge, to any
-person obtaining a copy of this software and associated
-documentation files (the "Software"), to deal in the
-Software without restriction, including without
-limitation the rights to use, copy, modify, merge,
-publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software
-is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice
-shall be included in all copies or substantial portions
-of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.

klondike/README.md

@@ -1,50 +0,0 @@
-Klondike
-========
-
-`klondike` is a pure-logic implementation of Klondike using `card_game`.  Graphics not included.
-
-## Example
-
-```rust
-use card_game::Session;
-use klondike::Klondike;
-
-// create game session
-let game = Klondike::with_seed(123);
-let mut session = Session::new_default(game);
-
-// play game a bit
-while let Some(instruction) = session.state().get_auto_move() {
-	session.process_instruction(instruction);
-
-	// quit after 1000 moves
-	if 1000 < session.stats().stats().moves() {
-		break;
-	}
-}
-
-// 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}");
-```
-
-#### License
-
-<sup>
-Licensed under either of <a href="LICENSE-APACHE">Apache License, Version
-2.0</a> or <a href="LICENSE-MIT">MIT license</a> at your option.
-</sup>
-
-<br>
-
-<sub>
-Unless you explicitly state otherwise, any contribution intentionally submitted
-for inclusion in this crate by you, as defined in the Apache-2.0 license, shall
-be dual licensed as above, without any additional terms or conditions.
-</sub>

klondike/src/lib.rs

@@ -1,60 +1,15 @@
-pub type Rng = rand::rngs::StdRng;
+pub type Rng = rand::rngs::ThreadRng;
 
-use card_game::{Card, Game, Pile, Rank, Stack};
+use card_game::{Card, CardValue, Game, Pile, Stack};
 
-// test readme
-#[doc = include_str!("../README.md")]
-#[cfg(doctest)]
-struct ReadmeDoctests;
+#[cfg(test)]
+mod test;
 
-#[derive(Clone, Copy, Debug, Default)]
-pub enum DrawStockConfig {
-	#[default]
-	DrawOne = 1,
-	DrawThree = 3,
-}
-
-#[derive(Clone, Debug, Default)]
-pub struct KlondikeConfig {
-	pub draw_stock: DrawStockConfig,
-}
-
-#[derive(Clone, Debug, Default)]
-pub struct KlondikeStats {
-	score: usize,
-	recycle_count: usize,
-	moves: usize,
-}
-impl KlondikeStats {
-	pub const fn new() -> Self {
-		KlondikeStats {
-			score: 0,
-			recycle_count: 0,
-			moves: 0,
-		}
-	}
-	pub const fn score(&self) -> usize {
-		self.score
-	}
-	pub const fn recycle_count(&self) -> usize {
-		self.recycle_count
-	}
-	pub const fn moves(&self) -> usize {
-		self.moves
-	}
-	/// A card was moved to a foundation.
-	const fn increment_score_foundation(&mut self) {
-		self.score += 10;
-	}
-	/// A card was moved from stock to tableau.
-	const fn increment_score_tableau(&mut self) {
-		self.score += 5;
-	}
-	const fn increment_recycle_count(&mut self) {
-		self.recycle_count += 1;
-	}
-	const fn increment_moves(&mut self) {
-		self.moves += 1;
+#[derive(Clone, Debug, Eq, Hash, PartialEq)]
+pub struct KlondikeConfig {}
+impl Default for KlondikeConfig {
+	fn default() -> Self {
+		KlondikeConfig {}
 	}
 }
 
@@ -199,7 +154,7 @@ impl TableauStack {
 			});
 		}
 		if let Some(tableau) = tableau.next() {
-			let skip_cards = SkipCards::ITER_BEGIN;
+			let skip_cards = SkipCards::Skip0;
 			return Some(Self {
 				tableau,
 				skip_cards,
@@ -299,16 +254,6 @@ impl KlondikeInstruction {
 			Self::RotateStock => return None,
 		})
 	}
-	/// foundation -> foundation is a useless move
-	pub fn is_useless(&self) -> bool {
-		matches!(
-			self,
-			KlondikeInstruction::DstFoundation(DstFoundation {
-				src: KlondikePile::Foundation(_),
-				..
-			})
-		)
-	}
 }
 
 const TABLEAUS: usize = 7;
@@ -366,18 +311,7 @@ impl KlondikeState {
 	pub const fn tableau7(&self) -> &Pile<6, 13> {
 		&self.tableau7
 	}
-	pub fn is_tableau_face_down_empty(&self, tableau: Tableau) -> bool {
-		match tableau {
-			Tableau::Tableau1 => self.tableau1.face_down().is_empty(),
-			Tableau::Tableau2 => self.tableau2.face_down().is_empty(),
-			Tableau::Tableau3 => self.tableau3.face_down().is_empty(),
-			Tableau::Tableau4 => self.tableau4.face_down().is_empty(),
-			Tableau::Tableau5 => self.tableau5.face_down().is_empty(),
-			Tableau::Tableau6 => self.tableau6.face_down().is_empty(),
-			Tableau::Tableau7 => self.tableau7.face_down().is_empty(),
-		}
-	}
-	pub fn stack_bottom_card(&self, src: KlondikePileStack) -> Option<&Card> {
+	pub fn card(&self, src: KlondikePileStack) -> Option<&Card> {
 		match src {
 			KlondikePileStack::Tableau(TableauStack {
 				tableau,
@@ -397,8 +331,8 @@ impl KlondikeState {
 			KlondikePileStack::Stock => self.stock.face_up().last(),
 		}
 	}
-	pub fn top_card<S: Into<KlondikePile>>(&self, src: S) -> Option<&Card> {
-		match src.into() {
+	pub fn top_card(&self, src: KlondikePile) -> Option<&Card> {
+		match src {
 			KlondikePile::Tableau(tableau) => match tableau {
 				Tableau::Tableau1 => self.tableau1.face_up().last(),
 				Tableau::Tableau2 => self.tableau2.face_up().last(),
@@ -432,8 +366,8 @@ impl KlondikeState {
 			KlondikePileStack::Stock => Stack::from_iter(self.stock.pop()),
 		}
 	}
-	fn take_top_card<S: Into<KlondikePile>>(&mut self, src: S) -> Option<Card> {
-		match src.into() {
+	fn take_top_card(&mut self, src: KlondikePile) -> Option<Card> {
+		match src {
 			KlondikePile::Tableau(tableau) => match tableau {
 				Tableau::Tableau1 => self.tableau1.pop_flip_up(),
 				Tableau::Tableau2 => self.tableau2.pop_flip_up(),
@@ -444,18 +378,12 @@ impl KlondikeState {
 				Tableau::Tableau7 => self.tableau7.pop_flip_up(),
 			},
 			KlondikePile::Foundation(foundation) => self.foundations[foundation as usize].pop(),
-			KlondikePile::Stock => self.stock.pop(),
+			KlondikePile::Stock => self.stock.pop_flip_up(),
 		}
 	}
-	fn extend_foundation<I: IntoIterator<Item = Card>>(
-		&mut self,
-		foundation: Foundation,
-		cards: I,
-	) {
-		self.foundations[foundation as usize].extend(cards)
-	}
-	fn extend_tableau<I: IntoIterator<Item = Card>>(&mut self, tableau: Tableau, cards: I) {
-		match tableau {
+	fn extend<I: IntoIterator<Item = Card>>(&mut self, dst: KlondikePile, cards: I) {
+		match dst {
+			KlondikePile::Tableau(tableau) => match tableau {
 				Tableau::Tableau1 => self.tableau1.extend(cards),
 				Tableau::Tableau2 => self.tableau2.extend(cards),
 				Tableau::Tableau3 => self.tableau3.extend(cards),
@@ -463,6 +391,11 @@ impl KlondikeState {
 				Tableau::Tableau5 => self.tableau5.extend(cards),
 				Tableau::Tableau6 => self.tableau6.extend(cards),
 				Tableau::Tableau7 => self.tableau7.extend(cards),
+			},
+			KlondikePile::Foundation(foundation) => {
+				self.foundations[foundation as usize].extend(cards)
+			}
+			KlondikePile::Stock => self.stock.extend(cards),
 		}
 	}
 	pub fn is_instruction_valid(&self, instruction: KlondikeInstruction) -> bool {
@@ -477,16 +410,16 @@ impl KlondikeState {
 			KlondikeInstruction::DstFoundation(dst_foundation) => {
 				// get the top cards
 				if let Some(src_card) = self.top_card(dst_foundation.src) {
-					match self.top_card(dst_foundation.foundation) {
+					match self.top_card(dst_foundation.foundation.into()) {
 						// destination card exists
 						Some(dst_card) => {
 							// suit matches?
 							src_card.suit() == dst_card.suit()
 							// value is +1?
-							&& dst_card.rank().checked_add(1) == Some(src_card.rank())
+							&& dst_card.value().checked_add(1) == Some(src_card.value())
 						}
 						// only ace is allowed to go onto empty foundation
-						None => src_card.rank() == Rank::Ace,
+						None => src_card.value() == CardValue::ACE,
 					}
 				} else {
 					false
@@ -495,17 +428,17 @@ impl KlondikeState {
 			// other = move to tableau
 			KlondikeInstruction::DstTableau(dst_tableau) => {
 				// get the cards
-				if let Some(src_card) = self.stack_bottom_card(dst_tableau.src) {
-					match self.top_card(dst_tableau.tableau) {
+				if let Some(src_card) = self.card(dst_tableau.src) {
+					match self.top_card(dst_tableau.tableau.into()) {
 						// destination card exists
 						Some(dst_card) => {
 							// red-ness is opposite?
 							src_card.is_red() != dst_card.is_red()
 							// value is -1?
-							&& dst_card.rank().checked_sub(1) == Some(src_card.rank())
+							&& dst_card.value().checked_sub(1) == Some(src_card.value())
 						}
 						// only king is allowed to go onto empty tableau
-						None => src_card.rank() == Rank::King,
+						None => src_card.value() == CardValue::KING,
 					}
 				} else {
 					false
@@ -533,26 +466,21 @@ impl Iterator for KlondikeIter {
 		instruction
 	}
 }
-#[test]
-fn test_klondike_iter() {
-	assert_eq!(KlondikeIter::new().count(), 721);
-}
 
 #[derive(Clone, Debug, Eq, Hash, PartialEq)]
 pub struct Klondike {
+	config: KlondikeConfig,
 	state: KlondikeState,
 }
 impl Klondike {
-	pub fn with_seed(seed: u64) -> Self {
-		use rand::SeedableRng;
-		let mut rng = Rng::seed_from_u64(seed);
-		Self::with_rng(&mut rng)
+	pub fn new_random_default() -> Self {
+		Self::new(Rng::default(), KlondikeConfig::default())
 	}
-	pub fn with_rng(rng: &mut Rng) -> Self {
+	pub fn new(mut seed: Rng, config: KlondikeConfig) -> Self {
 		// shuffle a new deck
-		let mut deck = Stack::full_deck(card_game::Deck::Deck1);
+		let mut deck = Stack::full_deck(0);
 		use rand::seq::SliceRandom;
-		deck.shuffle(rng);
+		deck.shuffle(&mut seed);
 		let mut deck = deck.into_iter();
 
 		// generate tableaus
@@ -584,13 +512,43 @@ impl Klondike {
 			tableau6,
 			tableau7,
 		};
-		Self { state }
+		Self { config, state }
 	}
 	pub const fn state(&self) -> &KlondikeState {
 		&self.state
 	}
-	/// Check if the game should be auto-completed
-	pub fn is_win_trivial(&self) -> bool {
+}
+
+impl Game for Klondike {
+	type Instruction = KlondikeInstruction;
+	fn possible_instructions(&self) -> impl Iterator<Item = Self::Instruction> + use<> {
+		let state = self.state.clone();
+		KlondikeIter::new().filter(move |&instruction| state.is_instruction_valid(instruction))
+	}
+	fn is_instruction_valid(&self, instruction: Self::Instruction) -> bool {
+		self.state.is_instruction_valid(instruction)
+	}
+	fn process_instruction(&mut self, instruction: Self::Instruction) {
+		match instruction {
+			// Reset the stock if it's empty
+			KlondikeInstruction::RotateStock => {
+				if self.state.stock.face_down().is_empty() {
+					self.state.stock.flip_it_and_reverse_it();
+				} else {
+					self.state.stock.flip_up();
+				}
+			}
+			KlondikeInstruction::DstFoundation(DstFoundation { src, foundation }) => {
+				let cards = self.state.take_top_card(src);
+				self.state.extend(foundation.into(), cards);
+			}
+			KlondikeInstruction::DstTableau(DstTableau { src, tableau }) => {
+				let cards = self.state.take_stack(src);
+				self.state.extend(tableau.into(), cards);
+			}
+		}
+	}
+	fn is_win(&self) -> bool {
 		// all face down cards empty means win
 		self.state.stock.face_down().is_empty()
 			&& self.state.tableau1.face_down().is_empty()
@@ -601,105 +559,4 @@ impl Klondike {
 			&& self.state.tableau6.face_down().is_empty()
 			&& self.state.tableau7.face_down().is_empty()
 	}
-	fn instruction_priority(&self, instruction: &KlondikeInstruction) -> usize {
-		// 1 Move into foundation
-		// 2 T->T Move to reveal new card (moving a non-king to reveal empty tableau also counts)
-		// 3 Move from stock
-		// 4 Rotate stock
-		// 5 T->T Move not revealing new card
-		// 6 Move from foundation
-		match instruction {
-			KlondikeInstruction::DstFoundation(_) => 1,
-			&KlondikeInstruction::DstTableau(dst_tableau) => match dst_tableau.src {
-				KlondikePileStack::Tableau(TableauStack {
-					tableau,
-					skip_cards: SkipCards::Skip0,
-				}) if !self.state().is_tableau_face_down_empty(tableau)
-					|| self
-						.state()
-						.stack_bottom_card(dst_tableau.src)
-						.is_some_and(|card| card.rank() != Rank::King) =>
-				{
-					2
-				}
-				KlondikePileStack::Stock => 3,
-				KlondikePileStack::Tableau(_) => 5,
-				KlondikePileStack::Foundation(_) => 6,
-			},
-			KlondikeInstruction::RotateStock => 4,
-		}
-	}
-	/// A single move that usually makes progress towards a winning game
-	pub fn get_auto_move(&self) -> Option<KlondikeInstruction> {
-		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) -> Vec<KlondikeInstruction> {
-		let mut useful_moves: Vec<_> = self
-			.possible_instructions()
-			.filter(|ins| !ins.is_useless())
-			.collect();
-		useful_moves.sort_by_key(|ins| self.instruction_priority(ins));
-		useful_moves
-	}
-}
-
-impl Game for Klondike {
-	type Stats = KlondikeStats;
-	type Config = KlondikeConfig;
-	type Instruction = KlondikeInstruction;
-	fn possible_instructions(&self) -> impl Iterator<Item = Self::Instruction> + use<> {
-		let state = self.state.clone();
-		KlondikeIter::new().filter(move |&instruction| state.is_instruction_valid(instruction))
-	}
-	fn is_instruction_valid(&self, _config: &Self::Config, instruction: Self::Instruction) -> bool {
-		self.state.is_instruction_valid(instruction)
-	}
-	fn process_instruction(
-		&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 self.state.stock.face_down().is_empty() {
-					self.state.stock.flip_it_and_reverse_it();
-					stats.increment_recycle_count();
-				} else {
-					for _ in 0..config.draw_stock as usize {
-						self.state.stock.flip_up();
-					}
-				}
-			}
-			// Move a card from anywhere to a foundation
-			KlondikeInstruction::DstFoundation(DstFoundation { src, foundation }) => {
-				stats.increment_score_foundation();
-				let card = self.state.take_top_card(src);
-				self.state.extend_foundation(foundation, card);
-			}
-			// Move a stack of cards from anywhere to a tableau
-			KlondikeInstruction::DstTableau(DstTableau { src, tableau }) => {
-				if src == KlondikePileStack::Stock {
-					stats.increment_score_tableau();
-				}
-				let cards = self.state.take_stack(src);
-				self.state.extend_tableau(tableau, cards);
-			}
-		}
-	}
-	fn is_win(&self) -> bool {
-		// all foundations contain all ranks
-		self.state.foundations.iter().all(|foundation| {
-			foundation.len() == Rank::RANKS.len()
-				&& foundation
-					.iter()
-					.zip(Rank::RANKS)
-					.all(|(card, rank)| card.rank() == rank)
-		})
-	}
 }

klondike/src/test.rs

@@ -0,0 +1,33 @@
+use crate::Klondike;
+use card_game::{Game, Session};
+#[test]
+fn test_is_winnable() {
+	// is winnable
+	let is_winnable = Session::new(Klondike::new_random_default()).is_winnable();
+	println!("is_winnable = {is_winnable:?}");
+}
+#[test]
+fn test_klondike() {
+	// create game session
+	let game = Klondike::new_random_default();
+	let mut session = Session::new(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}");
+}