use custom arrayvec

Cargo.lock

@@ -11,8 +11,8 @@ checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c"
 [[package]]
 name = "arrayvec"
 version = "0.7.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
+source = "sparse+https://git.aleshym.co/api/packages/Quaternions/cargo/"
+checksum = "813440870d646c57c222c1d713dc4e3ddcb2919c3801564d767d85d7bf2afee4"
 
 [[package]]
 name = "bitflags"
@@ -22,7 +22,7 @@ checksum = "c4512299f36f043ab09a583e57bceb5a5aab7a73db1805848e8fef3c9e8c78b3"
 
 [[package]]
 name = "card_game"
-version = "0.1.0"
+version = "0.2.0"
 dependencies = [
  "arrayvec",
 ]
@@ -132,6 +132,15 @@ dependencies = [
  "rand",
 ]
 
+[[package]]
+name = "klondike-bench"
+version = "0.1.0"
+dependencies = [
+ "card_game",
+ "klondike",
+ "rand",
+]
+
 [[package]]
 name = "klondike-cli"
 version = "0.1.0"

Cargo.toml

@@ -2,10 +2,15 @@
 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"

card_game/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "card_game"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2024"
 repository = "https://git.aleshym.co/Quaternions/card_game"
 license = "MIT OR Apache-2.0"
@@ -9,4 +9,7 @@ authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 keywords = ["card", "cards", "solitaire", "klondike"]
 
 [dependencies]
-arrayvec = "0.7.6"
+arrayvec = { version = "0.7.6", registry = "Quaternions", features = ["len_u8"], default-features = false }
+
+[lints]
+workspace = true

card_game/README.md

@@ -1,7 +1,7 @@
 Card Game
 =========
 
-`card_game` is a library to implement card games.  Mainly interesting for the `Game` trait and the `Session` type.
+`card_game` is a collection of algorithms, structs, and enums which are useful to implement card games.
 
 ## Example
 

card_game/src/lib.rs

@@ -135,7 +135,8 @@ impl Rank {
 		}
 	}
 }
-/// An identifier which specifies the deck id, suit, and card value.
+
+/// 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
@@ -224,6 +225,7 @@ impl<const CAP: usize> IntoIterator for Stack<CAP> {
 	}
 }
 
+/// 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>,

klondike-bench/Cargo.toml

@@ -0,0 +1,12 @@
+[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

@@ -0,0 +1,46 @@
+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,6 +4,9 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
-card_game = { version = "0.1.0", path = "../card_game" }
-klondike = { version = "0.1.0", path = "../klondike" }
+card_game.workspace = true
+klondike.workspace = true
 rand = { version = "0.10.1", default-features = false, features = ["thread_rng"] }
+
+[lints]
+workspace = true

klondike/Cargo.toml

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

klondike/README.md

@@ -1,12 +1,12 @@
-Card Game
-=========
+Klondike
+========
 
-`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.
+`klondike` is a pure-logic implementation of Klondike using `card_game`.  Graphics not included.
 
 ## Example
 
 ```rust
-use card_game::{Session, Game};
+use card_game::Session;
 use klondike::Klondike;
 
 // create game session
@@ -14,11 +14,11 @@ let game = Klondike::with_seed(123);
 let mut session = Session::new_default(game);
 
 // play game a bit
-while let Some(instruction) = session.possible_instructions().next() {
+while let Some(instruction) = session.state().get_auto_move() {
 	session.process_instruction(instruction);
 
-	// quit after 1000 moves
-	if 1000 < session.stats().stats().moves() {
+	// quit after 200 moves or win
+	if session.is_win() || 200 < session.stats().stats().moves() {
 		break;
 	}
 }

klondike/src/lib.rs

@@ -137,7 +137,6 @@ impl From<Foundation> for KlondikePile {
 	}
 }
 
-#[repr(u8)]
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
 pub enum SkipCards {
 	Skip0,
@@ -541,14 +540,14 @@ pub struct Klondike {
 impl Klondike {
 	pub fn with_seed(seed: u64) -> Self {
 		use rand::SeedableRng;
-		let rng = Rng::seed_from_u64(seed);
-		Self::with_rng(rng)
+		let mut rng = Rng::seed_from_u64(seed);
+		Self::with_rng(&mut rng)
 	}
-	pub fn with_rng(mut rng: Rng) -> Self {
+	pub fn with_rng(rng: &mut Rng) -> Self {
 		// shuffle a new deck
 		let mut deck = Stack::full_deck(card_game::Deck::Deck1);
 		use rand::seq::SliceRandom;
-		deck.shuffle(&mut rng);
+		deck.shuffle(rng);
 		let mut deck = deck.into_iter();
 
 		// generate tableaus
@@ -625,12 +624,13 @@ impl Klondike {
 			KlondikeInstruction::RotateStock => 4,
 		}
 	}
-	/// A list of possible moves sorted by a simple prioirty function
+	/// 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()