Compare commits
4 Commits
ai
..
dc186483c5
| Author | SHA1 | Date | |
|---|---|---|---|
 Quaternions
|
dc186483c5 | ||
|
Quaternions
|
6edc3532ac | ||
|
Quaternions
|
d601777e9d | ||
|
Quaternions
|
4fdc011be5 |
@@ -1,2 +0,0 @@
|
||||
[registries.Quaternions]
|
||||
index = "sparse+https://git.aleshym.co/api/packages/Quaternions/cargo/"
|
||||
Generated
+4
-32
@@ -11,8 +11,8 @@ checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c"
|
||||
[[package]]
|
||||
name = "arrayvec"
|
||||
version = "0.7.6"
|
||||
source = "sparse+https://git.aleshym.co/api/packages/Quaternions/cargo/"
|
||||
checksum = "813440870d646c57c222c1d713dc4e3ddcb2919c3801564d767d85d7bf2afee4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
|
||||
|
||||
[[package]]
|
||||
name = "bitflags"
|
||||
@@ -22,10 +22,10 @@ checksum = "c4512299f36f043ab09a583e57bceb5a5aab7a73db1805848e8fef3c9e8c78b3"
|
||||
|
||||
[[package]]
|
||||
name = "card_game"
|
||||
version = "0.4.0"
|
||||
version = "0.1.0"
|
||||
dependencies = [
|
||||
"arrayvec",
|
||||
"serde",
|
||||
"rand",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -125,33 +125,6 @@ version = "1.0.18"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
|
||||
|
||||
[[package]]
|
||||
name = "klondike"
|
||||
version = "0.3.0"
|
||||
dependencies = [
|
||||
"card_game",
|
||||
"rand",
|
||||
"serde",
|
||||
]
|
||||
|
||||
[[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]]
|
||||
name = "leb128fmt"
|
||||
version = "0.1.0"
|
||||
@@ -240,7 +213,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
|
||||
dependencies = [
|
||||
"serde_core",
|
||||
"serde_derive",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
|
||||
+7
-22
@@ -1,23 +1,8 @@
|
||||
[workspace]
|
||||
members = [
|
||||
"card_game",
|
||||
"klondike",
|
||||
"klondike-bench",
|
||||
"klondike-cli",
|
||||
]
|
||||
resolver = "3"
|
||||
[package]
|
||||
name = "card_game"
|
||||
version = "0.1.0"
|
||||
edition = "2024"
|
||||
|
||||
[workspace.dependencies]
|
||||
card_game = { version = "0.4.0", path = "card_game", registry = "Quaternions" }
|
||||
klondike = { version = "0.3.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"
|
||||
[dependencies]
|
||||
arrayvec = "0.7.6"
|
||||
rand = { version = "0.10.1", default-features = false, features = ["thread_rng"] }
|
||||
|
||||
@@ -0,0 +1,50 @@
|
||||
Card Game
|
||||
=========
|
||||
|
||||
`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::Rng;
|
||||
use card_game::card_game::{Session, Game};
|
||||
use card_game::klondike::Klondike;
|
||||
|
||||
// create game session
|
||||
let game = Klondike::new_random_default();
|
||||
let mut session = Session::new(game);
|
||||
|
||||
// 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
|
||||
|
||||
<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>
|
||||
@@ -1,19 +0,0 @@
|
||||
[package]
|
||||
name = "card_game"
|
||||
version = "0.4.0"
|
||||
edition = "2024"
|
||||
repository = "https://git.aleshym.co/Quaternions/card_game"
|
||||
license = "MIT OR Apache-2.0"
|
||||
description = "Card game library."
|
||||
authors = ["Rhys Lloyd <krakow20@gmail.com>"]
|
||||
keywords = ["card", "cards", "solitaire", "klondike"]
|
||||
|
||||
[features]
|
||||
serde = ["dep:serde"]
|
||||
|
||||
[dependencies]
|
||||
arrayvec = { version = "0.7.6", registry = "Quaternions", features = ["len_u8"], default-features = false }
|
||||
serde = { version = "1", optional = true, default-features = false, features = ["derive"] }
|
||||
|
||||
[lints]
|
||||
workspace = true
|
||||
@@ -1,32 +0,0 @@
|
||||
Card Game
|
||||
=========
|
||||
|
||||
`card_game` is a collection of algorithms, structs, and enums which are useful to implement card games.
|
||||
|
||||
## Example
|
||||
|
||||
```rust
|
||||
use card_game::{Card, Deck, Rank, Stack, Suit};
|
||||
|
||||
// create a full deck (unshuffled)
|
||||
let mut deck = Stack::full_deck(Deck::Deck1);
|
||||
|
||||
// inspect the top card
|
||||
let card = deck.pop().unwrap();
|
||||
assert_eq!(card, Card::new(Deck::Deck1, Suit::Diamonds, Rank::King));
|
||||
```
|
||||
|
||||
#### 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>
|
||||
@@ -1,597 +0,0 @@
|
||||
// test readme
|
||||
#[doc = include_str!("../README.md")]
|
||||
#[cfg(doctest)]
|
||||
struct ReadmeDoctests;
|
||||
|
||||
use core::ops::RangeBounds;
|
||||
|
||||
// TODO: pub struct ValidInstruction<I>(I);
|
||||
pub trait Game: Clone {
|
||||
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,
|
||||
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,
|
||||
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)]
|
||||
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
|
||||
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)]
|
||||
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
|
||||
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)]
|
||||
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
|
||||
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)]
|
||||
#[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 {
|
||||
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(),
|
||||
}
|
||||
}
|
||||
/// Returns whether a card was flipped up.
|
||||
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()
|
||||
}
|
||||
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>, bool) {
|
||||
let card = match self.face_up.pop() {
|
||||
Some(card) => card,
|
||||
None => return (None, false),
|
||||
};
|
||||
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> {
|
||||
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>, bool) {
|
||||
let cards = self.take_range(range);
|
||||
let did_flip_up = if self.face_up.is_empty() {
|
||||
self.flip_up()
|
||||
} else {
|
||||
false
|
||||
};
|
||||
(cards, did_flip_up)
|
||||
}
|
||||
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 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,
|
||||
InnerInstruction(I),
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Default)]
|
||||
pub struct SessionStats<S> {
|
||||
inner: S,
|
||||
undos: u32,
|
||||
}
|
||||
impl<S> SessionStats<S> {
|
||||
pub const fn stats(&self) -> &S {
|
||||
&self.inner
|
||||
}
|
||||
const fn increment_undos(&mut self) {
|
||||
self.undos += 1;
|
||||
}
|
||||
pub const fn undos(&self) -> u32 {
|
||||
self.undos
|
||||
}
|
||||
}
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct SessionConfig<C> {
|
||||
pub inner: C,
|
||||
pub undo_penalty: i32,
|
||||
pub solve_moves_budget: u64,
|
||||
pub solve_states_budget: u64,
|
||||
}
|
||||
impl<C> SessionConfig<C> {
|
||||
fn new_default(inner: C) -> Self {
|
||||
Self {
|
||||
inner,
|
||||
undo_penalty: -15,
|
||||
solve_moves_budget: 100_000,
|
||||
solve_states_budget: 100_000,
|
||||
}
|
||||
}
|
||||
}
|
||||
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>,
|
||||
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> SessionState<G> {
|
||||
pub const fn state(&self) -> &G {
|
||||
&self.state
|
||||
}
|
||||
}
|
||||
impl<G: Game<Score = i32>> Session<G>
|
||||
where
|
||||
G: Eq + core::hash::Hash,
|
||||
G::Stats: Default,
|
||||
G::Instruction: Eq + core::hash::Hash,
|
||||
{
|
||||
pub fn new(state: G, config: SessionConfig<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) -> &SessionState<G> {
|
||||
&self.state
|
||||
}
|
||||
pub const fn config(&self) -> &SessionConfig<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(&self.config.inner)
|
||||
}
|
||||
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()
|
||||
}
|
||||
/// Attempt to produce a solution.
|
||||
pub fn solve(&self) -> Result<Option<Solution<G>>, SolveError> {
|
||||
let mut state_moves = std::collections::HashMap::new();
|
||||
let mut session = self.clone();
|
||||
let mut moves = 0;
|
||||
while !session.is_win() {
|
||||
moves += 1;
|
||||
if self.config.solve_moves_budget < moves {
|
||||
return Err(SolveError::MovesBudgetExceeded);
|
||||
}
|
||||
if self.config.solve_states_budget < state_moves.len() as u64 {
|
||||
return Err(SolveError::StatesBudgetExceeded);
|
||||
}
|
||||
// Continue existing iterator if it exists
|
||||
let it = state_moves
|
||||
.entry(session.state().state().clone())
|
||||
.or_insert_with(|| {
|
||||
session
|
||||
.state()
|
||||
.state()
|
||||
.possible_instructions(&self.config().inner)
|
||||
});
|
||||
|
||||
// Run one possible move
|
||||
if let Some(instruction) = it.next() {
|
||||
session.process_instruction(instruction);
|
||||
continue;
|
||||
}
|
||||
|
||||
// No more moves. If we can't undo we're done
|
||||
if session.history().is_empty() {
|
||||
return Ok(None);
|
||||
} else {
|
||||
session.undo();
|
||||
}
|
||||
}
|
||||
Ok(Some(Solution {
|
||||
solution: session.state.history,
|
||||
}))
|
||||
}
|
||||
}
|
||||
impl<G: Game<Score = i32>> Game for SessionState<G>
|
||||
where
|
||||
G::Stats: Default,
|
||||
{
|
||||
type Score = G::Score;
|
||||
type Stats = SessionStats<G::Stats>;
|
||||
type Config = SessionConfig<G::Config>;
|
||||
type Instruction = SessionInstruction<G::Instruction>;
|
||||
fn score(&self, stats: &Self::Stats, config: &Self::Config) -> Self::Score {
|
||||
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)
|
||||
.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)
|
||||
}
|
||||
}
|
||||
}
|
||||
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, &config.inner, instruction);
|
||||
}
|
||||
}
|
||||
}
|
||||
fn is_win(&self) -> bool {
|
||||
self.state.is_win()
|
||||
}
|
||||
}
|
||||
@@ -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
|
||||
@@ -1,48 +0,0 @@
|
||||
use card_game::Game;
|
||||
use klondike::{Klondike, KlondikeConfig, KlondikeStats, Rng, ScoringConfig};
|
||||
|
||||
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,
|
||||
move_from_foundation: klondike::MoveFromFoundationConfig::Allowed,
|
||||
scoring: ScoringConfig::DEFAULT,
|
||||
};
|
||||
// play game a bit
|
||||
while let Some(instruction) = game.get_auto_move(&CONFIG)
|
||||
&& !game.is_win()
|
||||
{
|
||||
// quit before 250 moves
|
||||
if (MAX_MOVES as u32) < 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(&ScoringConfig::DEFAULT) / 5) as usize] += 1;
|
||||
recycle_tally[stats.recycle_count() as usize] += 1;
|
||||
moves_tally[stats.moves() as usize] += 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);
|
||||
}
|
||||
@@ -1,12 +0,0 @@
|
||||
[package]
|
||||
name = "klondike-cli"
|
||||
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
|
||||
@@ -1,16 +0,0 @@
|
||||
use card_game::Session;
|
||||
use klondike::Klondike;
|
||||
#[test]
|
||||
fn test_is_winnable() {
|
||||
// is winnable
|
||||
let solution_result = Session::new_default(Klondike::with_seed(124)).solve();
|
||||
if let Ok(Some(solution)) = solution_result {
|
||||
let win_moves = solution.clean_solution();
|
||||
// for (i, ins) in win_moves.into_iter().enumerate() {
|
||||
// println!("{i} = {:?}", ins.instruction());
|
||||
// }
|
||||
println!("Game is winnable with {} moves", win_moves.len());
|
||||
} else {
|
||||
println!("Game is not winnable");
|
||||
}
|
||||
}
|
||||
@@ -1,15 +0,0 @@
|
||||
[package]
|
||||
name = "klondike"
|
||||
version = "0.3.0"
|
||||
edition = "2024"
|
||||
|
||||
[features]
|
||||
serde = ["dep:serde"]
|
||||
|
||||
[dependencies]
|
||||
card_game.workspace = true
|
||||
rand = { version = "0.10.1", default-features = false, features = ["std_rng"] }
|
||||
serde = { version = "1", optional = true, default-features = false, features = ["derive"] }
|
||||
|
||||
[lints]
|
||||
workspace = true
|
||||
@@ -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
|
||||
@@ -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.
|
||||
@@ -1,51 +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, KlondikeConfig};
|
||||
|
||||
// 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) {
|
||||
session.process_instruction(instruction);
|
||||
|
||||
// quit after 200 moves or win
|
||||
if session.is_win() || 200 < 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>
|
||||
@@ -1,808 +0,0 @@
|
||||
pub type Rng = rand::rngs::StdRng;
|
||||
|
||||
use card_game::{Card, Game, Pile, Rank, Stack};
|
||||
|
||||
// test readme
|
||||
#[doc = include_str!("../README.md")]
|
||||
#[cfg(doctest)]
|
||||
struct ReadmeDoctests;
|
||||
|
||||
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
|
||||
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,
|
||||
move_to_foundation_count: u32,
|
||||
flip_up_bonus_count: u32,
|
||||
move_to_tableau_count: u32,
|
||||
move_from_foundation_count: u32,
|
||||
recycle_count: u32,
|
||||
}
|
||||
impl KlondikeStats {
|
||||
pub const fn new() -> Self {
|
||||
KlondikeStats {
|
||||
moves: 0,
|
||||
move_to_foundation_count: 0,
|
||||
flip_up_bonus_count: 0,
|
||||
move_to_tableau_count: 0,
|
||||
move_from_foundation_count: 0,
|
||||
recycle_count: 0,
|
||||
}
|
||||
}
|
||||
pub const fn score(&self, config: &ScoringConfig) -> i32 {
|
||||
self.move_to_foundation_count as i32 * config.move_to_foundation
|
||||
+ 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 {
|
||||
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.
|
||||
const fn increment_move_to_foundation(&mut self) {
|
||||
self.move_to_foundation_count += 1;
|
||||
}
|
||||
/// A card on the tableau was flipped up.
|
||||
const fn increment_flip_up_bonus(&mut self) {
|
||||
self.flip_up_bonus_count += 1;
|
||||
}
|
||||
/// A card was moved from stock to tableau.
|
||||
const fn increment_move_to_tableau(&mut self) {
|
||||
self.move_to_tableau_count += 1;
|
||||
}
|
||||
/// 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;
|
||||
}
|
||||
const fn increment_moves(&mut self) {
|
||||
self.moves += 1;
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
|
||||
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
|
||||
pub enum Tableau {
|
||||
Tableau1,
|
||||
Tableau2,
|
||||
Tableau3,
|
||||
Tableau4,
|
||||
Tableau5,
|
||||
Tableau6,
|
||||
Tableau7,
|
||||
}
|
||||
impl Tableau {
|
||||
const ITER_BEGIN: Self = Self::Tableau1;
|
||||
const fn next(self) -> Option<Self> {
|
||||
use Tableau::*;
|
||||
Some(match self {
|
||||
Tableau1 => Tableau2,
|
||||
Tableau2 => Tableau3,
|
||||
Tableau3 => Tableau4,
|
||||
Tableau4 => Tableau5,
|
||||
Tableau5 => Tableau6,
|
||||
Tableau6 => Tableau7,
|
||||
Tableau7 => return None,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
|
||||
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
|
||||
pub enum Foundation {
|
||||
Foundation1,
|
||||
Foundation2,
|
||||
Foundation3,
|
||||
Foundation4,
|
||||
}
|
||||
impl Foundation {
|
||||
const ITER_BEGIN: Self = Self::Foundation1;
|
||||
const fn next(self) -> Option<Self> {
|
||||
use Foundation::*;
|
||||
Some(match self {
|
||||
Foundation1 => Foundation2,
|
||||
Foundation2 => Foundation3,
|
||||
Foundation3 => Foundation4,
|
||||
Foundation4 => return None,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
|
||||
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
|
||||
pub enum KlondikePile {
|
||||
Tableau(Tableau),
|
||||
Stock,
|
||||
Foundation(Foundation),
|
||||
}
|
||||
impl KlondikePile {
|
||||
const ITER_BEGIN: Self = Self::Tableau(Tableau::ITER_BEGIN);
|
||||
const fn next(self) -> Option<Self> {
|
||||
Some(match self {
|
||||
Self::Tableau(tableau_stack) => match tableau_stack.next() {
|
||||
Some(tableau_stack) => Self::Tableau(tableau_stack),
|
||||
None => Self::Stock,
|
||||
},
|
||||
Self::Stock => Self::Foundation(Foundation::ITER_BEGIN),
|
||||
Self::Foundation(foundation) => match foundation.next() {
|
||||
Some(foundation) => Self::Foundation(foundation),
|
||||
None => return None,
|
||||
},
|
||||
})
|
||||
}
|
||||
}
|
||||
impl From<Tableau> for KlondikePile {
|
||||
fn from(value: Tableau) -> Self {
|
||||
KlondikePile::Tableau(value)
|
||||
}
|
||||
}
|
||||
impl From<Foundation> for KlondikePile {
|
||||
fn from(value: Foundation) -> Self {
|
||||
KlondikePile::Foundation(value)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
|
||||
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
|
||||
pub enum SkipCards {
|
||||
Skip0,
|
||||
Skip1,
|
||||
Skip2,
|
||||
Skip3,
|
||||
Skip4,
|
||||
Skip5,
|
||||
Skip6,
|
||||
Skip7,
|
||||
Skip8,
|
||||
Skip9,
|
||||
Skip10,
|
||||
Skip11,
|
||||
Skip12,
|
||||
}
|
||||
impl SkipCards {
|
||||
const ITER_BEGIN: Self = Self::Skip0;
|
||||
const fn next(self) -> Option<Self> {
|
||||
use SkipCards::*;
|
||||
Some(match self {
|
||||
Skip0 => Skip1,
|
||||
Skip1 => Skip2,
|
||||
Skip2 => Skip3,
|
||||
Skip3 => Skip4,
|
||||
Skip4 => Skip5,
|
||||
Skip5 => Skip6,
|
||||
Skip6 => Skip7,
|
||||
Skip7 => Skip8,
|
||||
Skip8 => Skip9,
|
||||
Skip9 => Skip10,
|
||||
Skip10 => Skip11,
|
||||
Skip11 => Skip12,
|
||||
Skip12 => return None,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
#[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,
|
||||
}
|
||||
|
||||
impl TableauStack {
|
||||
const ITER_BEGIN: Self = Self {
|
||||
tableau: Tableau::ITER_BEGIN,
|
||||
skip_cards: SkipCards::ITER_BEGIN,
|
||||
};
|
||||
const fn next(self) -> Option<Self> {
|
||||
let TableauStack {
|
||||
tableau,
|
||||
skip_cards,
|
||||
} = self;
|
||||
if let Some(skip_cards) = skip_cards.next() {
|
||||
return Some(Self {
|
||||
tableau,
|
||||
skip_cards,
|
||||
});
|
||||
}
|
||||
if let Some(tableau) = tableau.next() {
|
||||
let skip_cards = SkipCards::ITER_BEGIN;
|
||||
return Some(Self {
|
||||
tableau,
|
||||
skip_cards,
|
||||
});
|
||||
}
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
|
||||
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
|
||||
pub enum KlondikePileStack {
|
||||
Tableau(TableauStack),
|
||||
Stock,
|
||||
Foundation(Foundation),
|
||||
}
|
||||
impl KlondikePileStack {
|
||||
const ITER_BEGIN: Self = Self::Tableau(TableauStack::ITER_BEGIN);
|
||||
const fn next(self) -> Option<Self> {
|
||||
Some(match self {
|
||||
Self::Tableau(tableau_stack) => match tableau_stack.next() {
|
||||
Some(tableau_stack) => Self::Tableau(tableau_stack),
|
||||
None => Self::Stock,
|
||||
},
|
||||
Self::Stock => Self::Foundation(Foundation::ITER_BEGIN),
|
||||
Self::Foundation(foundation) => match foundation.next() {
|
||||
Some(foundation) => Self::Foundation(foundation),
|
||||
None => return None,
|
||||
},
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
#[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,
|
||||
}
|
||||
impl DstFoundation {
|
||||
const ITER_BEGIN: Self = Self {
|
||||
src: KlondikePile::ITER_BEGIN,
|
||||
foundation: Foundation::ITER_BEGIN,
|
||||
};
|
||||
const fn next(self) -> Option<Self> {
|
||||
let DstFoundation { src, foundation } = self;
|
||||
if let Some(src) = src.next() {
|
||||
return Some(Self { src, foundation });
|
||||
}
|
||||
if let Some(foundation) = foundation.next() {
|
||||
let src = KlondikePile::ITER_BEGIN;
|
||||
return Some(Self { src, foundation });
|
||||
}
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
#[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,
|
||||
}
|
||||
impl DstTableau {
|
||||
const ITER_BEGIN: Self = Self {
|
||||
src: KlondikePileStack::ITER_BEGIN,
|
||||
tableau: Tableau::ITER_BEGIN,
|
||||
};
|
||||
const fn next(self) -> Option<Self> {
|
||||
let DstTableau { src, tableau } = self;
|
||||
if let Some(src) = src.next() {
|
||||
return Some(Self { src, tableau });
|
||||
}
|
||||
if let Some(tableau) = tableau.next() {
|
||||
let src = KlondikePileStack::ITER_BEGIN;
|
||||
return Some(Self { src, tableau });
|
||||
}
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
|
||||
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
|
||||
pub enum KlondikeInstruction {
|
||||
DstFoundation(DstFoundation),
|
||||
DstTableau(DstTableau),
|
||||
RotateStock,
|
||||
}
|
||||
impl KlondikeInstruction {
|
||||
const ITER_BEGIN: Self = Self::DstFoundation(DstFoundation::ITER_BEGIN);
|
||||
const fn next(self) -> Option<Self> {
|
||||
Some(match self {
|
||||
Self::DstFoundation(dst_foundation) => match dst_foundation.next() {
|
||||
Some(dst_foundation) => Self::DstFoundation(dst_foundation),
|
||||
None => Self::DstTableau(DstTableau::ITER_BEGIN),
|
||||
},
|
||||
Self::DstTableau(tableau) => match tableau.next() {
|
||||
Some(tableau) => Self::DstTableau(tableau),
|
||||
None => Self::RotateStock,
|
||||
},
|
||||
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;
|
||||
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],
|
||||
tableau1: Pile<0, NUM_RANKS>,
|
||||
tableau2: Pile<1, NUM_RANKS>,
|
||||
tableau3: Pile<2, NUM_RANKS>,
|
||||
tableau4: Pile<3, NUM_RANKS>,
|
||||
tableau5: Pile<4, NUM_RANKS>,
|
||||
tableau6: Pile<5, NUM_RANKS>,
|
||||
tableau7: Pile<6, NUM_RANKS>,
|
||||
}
|
||||
impl KlondikeState {
|
||||
pub const fn stock(&self) -> &Pile<STOCK, STOCK> {
|
||||
&self.stock
|
||||
}
|
||||
pub const fn foundation1(&self) -> &Stack<NUM_RANKS> {
|
||||
&self.foundations[Foundation::Foundation1 as usize]
|
||||
}
|
||||
pub const fn foundation2(&self) -> &Stack<NUM_RANKS> {
|
||||
&self.foundations[Foundation::Foundation2 as usize]
|
||||
}
|
||||
pub const fn foundation3(&self) -> &Stack<NUM_RANKS> {
|
||||
&self.foundations[Foundation::Foundation3 as usize]
|
||||
}
|
||||
pub const fn foundation4(&self) -> &Stack<NUM_RANKS> {
|
||||
&self.foundations[Foundation::Foundation4 as usize]
|
||||
}
|
||||
pub const fn tableau1(&self) -> &Pile<0, NUM_RANKS> {
|
||||
&self.tableau1
|
||||
}
|
||||
pub const fn tableau2(&self) -> &Pile<1, NUM_RANKS> {
|
||||
&self.tableau2
|
||||
}
|
||||
pub const fn tableau3(&self) -> &Pile<2, NUM_RANKS> {
|
||||
&self.tableau3
|
||||
}
|
||||
pub const fn tableau4(&self) -> &Pile<3, NUM_RANKS> {
|
||||
&self.tableau4
|
||||
}
|
||||
pub const fn tableau5(&self) -> &Pile<4, NUM_RANKS> {
|
||||
&self.tableau5
|
||||
}
|
||||
pub const fn tableau6(&self) -> &Pile<5, NUM_RANKS> {
|
||||
&self.tableau6
|
||||
}
|
||||
pub const fn tableau7(&self) -> &Pile<6, NUM_RANKS> {
|
||||
&self.tableau7
|
||||
}
|
||||
pub fn tableau_face_down_cards(&self, tableau: Tableau) -> &[Card] {
|
||||
match tableau {
|
||||
Tableau::Tableau1 => self.tableau1.face_down(),
|
||||
Tableau::Tableau2 => self.tableau2.face_down(),
|
||||
Tableau::Tableau3 => self.tableau3.face_down(),
|
||||
Tableau::Tableau4 => self.tableau4.face_down(),
|
||||
Tableau::Tableau5 => self.tableau5.face_down(),
|
||||
Tableau::Tableau6 => self.tableau6.face_down(),
|
||||
Tableau::Tableau7 => self.tableau7.face_down(),
|
||||
}
|
||||
}
|
||||
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> {
|
||||
match src {
|
||||
KlondikePileStack::Tableau(TableauStack {
|
||||
tableau,
|
||||
skip_cards,
|
||||
}) => self.tableau_face_up_cards(tableau).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> {
|
||||
self.tableau_face_up_cards(tableau).last()
|
||||
}
|
||||
pub fn foundation_top_card(&self, foundation: Foundation) -> Option<&Card> {
|
||||
self.foundations[foundation as usize].last()
|
||||
}
|
||||
pub fn top_card(&self, pile: KlondikePile) -> Option<&Card> {
|
||||
match pile {
|
||||
KlondikePile::Tableau(tableau) => self.tableau_top_card(tableau),
|
||||
KlondikePile::Foundation(foundation) => self.foundation_top_card(foundation),
|
||||
KlondikePile::Stock => self.stock.face_up().last(),
|
||||
}
|
||||
}
|
||||
fn take_stack_flip_up(&mut self, src: KlondikePileStack) -> (Stack<NUM_RANKS>, bool) {
|
||||
match src {
|
||||
KlondikePileStack::Tableau(TableauStack {
|
||||
tableau,
|
||||
skip_cards,
|
||||
}) => match tableau {
|
||||
Tableau::Tableau1 => self.tableau1.take_range_flip_up(skip_cards as usize..),
|
||||
Tableau::Tableau2 => self.tableau2.take_range_flip_up(skip_cards as usize..),
|
||||
Tableau::Tableau3 => self.tableau3.take_range_flip_up(skip_cards as usize..),
|
||||
Tableau::Tableau4 => self.tableau4.take_range_flip_up(skip_cards as usize..),
|
||||
Tableau::Tableau5 => self.tableau5.take_range_flip_up(skip_cards as usize..),
|
||||
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) => (
|
||||
Stack::from_iter(self.foundations[foundation as usize].pop()),
|
||||
false,
|
||||
),
|
||||
KlondikePileStack::Stock => (Stack::from_iter(self.stock.pop()), false),
|
||||
}
|
||||
}
|
||||
fn take_top_card_flip_up(&mut self, pile: KlondikePile) -> (Option<Card>, bool) {
|
||||
match pile {
|
||||
KlondikePile::Tableau(tableau) => match tableau {
|
||||
Tableau::Tableau1 => self.tableau1.pop_flip_up(),
|
||||
Tableau::Tableau2 => self.tableau2.pop_flip_up(),
|
||||
Tableau::Tableau3 => self.tableau3.pop_flip_up(),
|
||||
Tableau::Tableau4 => self.tableau4.pop_flip_up(),
|
||||
Tableau::Tableau5 => self.tableau5.pop_flip_up(),
|
||||
Tableau::Tableau6 => self.tableau6.pop_flip_up(),
|
||||
Tableau::Tableau7 => self.tableau7.pop_flip_up(),
|
||||
},
|
||||
KlondikePile::Foundation(foundation) => {
|
||||
(self.foundations[foundation as usize].pop(), false)
|
||||
}
|
||||
KlondikePile::Stock => (self.stock.pop(), false),
|
||||
}
|
||||
}
|
||||
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 {
|
||||
Tableau::Tableau1 => self.tableau1.extend(cards),
|
||||
Tableau::Tableau2 => self.tableau2.extend(cards),
|
||||
Tableau::Tableau3 => self.tableau3.extend(cards),
|
||||
Tableau::Tableau4 => self.tableau4.extend(cards),
|
||||
Tableau::Tableau5 => self.tableau5.extend(cards),
|
||||
Tableau::Tableau6 => self.tableau6.extend(cards),
|
||||
Tableau::Tableau7 => self.tableau7.extend(cards),
|
||||
}
|
||||
}
|
||||
pub fn is_instruction_valid(
|
||||
&self,
|
||||
config: &KlondikeConfig,
|
||||
instruction: KlondikeInstruction,
|
||||
) -> bool {
|
||||
match instruction {
|
||||
// Stock -> Stock draws a card or resets the stock
|
||||
KlondikeInstruction::RotateStock => {
|
||||
// cannot move stock when stock is empty
|
||||
!self.stock.is_empty()
|
||||
}
|
||||
|
||||
// moving to foundation has special rules
|
||||
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) {
|
||||
// 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())
|
||||
}
|
||||
// only ace is allowed to go onto empty foundation
|
||||
None => src_card.rank() == Rank::Ace,
|
||||
}
|
||||
} else {
|
||||
false
|
||||
}
|
||||
}
|
||||
// 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) {
|
||||
// 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())
|
||||
}
|
||||
// only king is allowed to go onto empty tableau
|
||||
None => src_card.rank() == Rank::King,
|
||||
}
|
||||
} else {
|
||||
false
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub struct KlondikeIter {
|
||||
instruction: Option<KlondikeInstruction>,
|
||||
}
|
||||
impl KlondikeIter {
|
||||
const fn new() -> Self {
|
||||
Self {
|
||||
instruction: Some(KlondikeInstruction::ITER_BEGIN),
|
||||
}
|
||||
}
|
||||
}
|
||||
impl Iterator for KlondikeIter {
|
||||
type Item = KlondikeInstruction;
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
let instruction = self.instruction;
|
||||
self.instruction = instruction?.next();
|
||||
instruction
|
||||
}
|
||||
}
|
||||
#[test]
|
||||
fn test_klondike_iter() {
|
||||
assert_eq!(KlondikeIter::new().count(), 721);
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
|
||||
pub struct Klondike {
|
||||
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 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(rng);
|
||||
let mut deck = deck.into_iter();
|
||||
|
||||
// generate tableaus
|
||||
fn pile<const DN: usize>(
|
||||
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());
|
||||
pile
|
||||
}
|
||||
let tableau1 = pile(&mut deck);
|
||||
let tableau2 = pile(&mut deck);
|
||||
let tableau3 = pile(&mut deck);
|
||||
let tableau4 = pile(&mut deck);
|
||||
let tableau5 = pile(&mut deck);
|
||||
let tableau6 = pile(&mut deck);
|
||||
let tableau7 = pile(&mut deck);
|
||||
|
||||
// stock is remaining cards
|
||||
let stock = Pile::new_face_down(Stack::from_iter(deck));
|
||||
|
||||
let state = KlondikeState {
|
||||
stock,
|
||||
foundations: core::array::from_fn(|_| Stack::new()),
|
||||
tableau1,
|
||||
tableau2,
|
||||
tableau3,
|
||||
tableau4,
|
||||
tableau5,
|
||||
tableau6,
|
||||
tableau7,
|
||||
};
|
||||
Self { state }
|
||||
}
|
||||
pub const fn state(&self) -> &KlondikeState {
|
||||
&self.state
|
||||
}
|
||||
/// 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.tableau1.face_down().is_empty()
|
||||
&& self.state.tableau2.face_down().is_empty()
|
||||
&& self.state.tableau3.face_down().is_empty()
|
||||
&& self.state.tableau4.face_down().is_empty()
|
||||
&& self.state.tableau5.face_down().is_empty()
|
||||
&& 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().tableau_face_down_cards(tableau).is_empty()
|
||||
|| 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, config: &KlondikeConfig) -> Option<KlondikeInstruction> {
|
||||
self.possible_instructions(config)
|
||||
.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> {
|
||||
let mut useful_moves: Vec<_> = self
|
||||
.possible_instructions(config)
|
||||
.filter(|ins| !ins.is_useless())
|
||||
.collect();
|
||||
useful_moves.sort_by_key(|ins| self.instruction_priority(ins));
|
||||
useful_moves
|
||||
}
|
||||
}
|
||||
|
||||
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 {
|
||||
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(&config, instruction))
|
||||
}
|
||||
fn is_instruction_valid(&self, config: &Self::Config, instruction: Self::Instruction) -> bool {
|
||||
self.state.is_instruction_valid(config, 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_move_to_foundation();
|
||||
let (card, did_flip_up) = self.state.take_top_card_flip_up(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 {
|
||||
KlondikePileStack::Stock => stats.increment_move_to_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();
|
||||
}
|
||||
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)
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,307 @@
|
||||
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 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()
|
||||
}
|
||||
}
|
||||
+558
@@ -0,0 +1,558 @@
|
||||
use crate::Rng;
|
||||
use crate::card_game::{Card, CardValue, Game, Pile, Stack};
|
||||
|
||||
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
|
||||
pub struct KlondikeConfig {}
|
||||
impl Default for KlondikeConfig {
|
||||
fn default() -> Self {
|
||||
KlondikeConfig {}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
|
||||
pub enum Tableau {
|
||||
Tableau1,
|
||||
Tableau2,
|
||||
Tableau3,
|
||||
Tableau4,
|
||||
Tableau5,
|
||||
Tableau6,
|
||||
Tableau7,
|
||||
}
|
||||
impl Tableau {
|
||||
const ITER_BEGIN: Self = Self::Tableau1;
|
||||
const fn next(self) -> Option<Self> {
|
||||
use Tableau::*;
|
||||
Some(match self {
|
||||
Tableau1 => Tableau2,
|
||||
Tableau2 => Tableau3,
|
||||
Tableau3 => Tableau4,
|
||||
Tableau4 => Tableau5,
|
||||
Tableau5 => Tableau6,
|
||||
Tableau6 => Tableau7,
|
||||
Tableau7 => return None,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
|
||||
pub enum Foundation {
|
||||
Foundation1,
|
||||
Foundation2,
|
||||
Foundation3,
|
||||
Foundation4,
|
||||
}
|
||||
impl Foundation {
|
||||
const ITER_BEGIN: Self = Self::Foundation1;
|
||||
const fn next(self) -> Option<Self> {
|
||||
use Foundation::*;
|
||||
Some(match self {
|
||||
Foundation1 => Foundation2,
|
||||
Foundation2 => Foundation3,
|
||||
Foundation3 => Foundation4,
|
||||
Foundation4 => return None,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
|
||||
pub enum KlondikePile {
|
||||
Tableau(Tableau),
|
||||
Stock,
|
||||
Foundation(Foundation),
|
||||
}
|
||||
impl KlondikePile {
|
||||
const ITER_BEGIN: Self = Self::Tableau(Tableau::ITER_BEGIN);
|
||||
const fn next(self) -> Option<Self> {
|
||||
Some(match self {
|
||||
Self::Tableau(tableau_stack) => match tableau_stack.next() {
|
||||
Some(tableau_stack) => Self::Tableau(tableau_stack),
|
||||
None => Self::Stock,
|
||||
},
|
||||
Self::Stock => Self::Foundation(Foundation::ITER_BEGIN),
|
||||
Self::Foundation(foundation) => match foundation.next() {
|
||||
Some(foundation) => Self::Foundation(foundation),
|
||||
None => return None,
|
||||
},
|
||||
})
|
||||
}
|
||||
}
|
||||
impl From<Tableau> for KlondikePile {
|
||||
fn from(value: Tableau) -> Self {
|
||||
KlondikePile::Tableau(value)
|
||||
}
|
||||
}
|
||||
impl From<Foundation> for KlondikePile {
|
||||
fn from(value: Foundation) -> Self {
|
||||
KlondikePile::Foundation(value)
|
||||
}
|
||||
}
|
||||
|
||||
#[repr(u8)]
|
||||
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
|
||||
pub enum SkipCards {
|
||||
Skip0,
|
||||
Skip1,
|
||||
Skip2,
|
||||
Skip3,
|
||||
Skip4,
|
||||
Skip5,
|
||||
Skip6,
|
||||
Skip7,
|
||||
Skip8,
|
||||
Skip9,
|
||||
Skip10,
|
||||
Skip11,
|
||||
Skip12,
|
||||
}
|
||||
impl SkipCards {
|
||||
const ITER_BEGIN: Self = Self::Skip0;
|
||||
const fn next(self) -> Option<Self> {
|
||||
use SkipCards::*;
|
||||
Some(match self {
|
||||
Skip0 => Skip1,
|
||||
Skip1 => Skip2,
|
||||
Skip2 => Skip3,
|
||||
Skip3 => Skip4,
|
||||
Skip4 => Skip5,
|
||||
Skip5 => Skip6,
|
||||
Skip6 => Skip7,
|
||||
Skip7 => Skip8,
|
||||
Skip8 => Skip9,
|
||||
Skip9 => Skip10,
|
||||
Skip10 => Skip11,
|
||||
Skip11 => Skip12,
|
||||
Skip12 => return None,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
|
||||
pub struct TableauStack {
|
||||
pub tableau: Tableau,
|
||||
pub skip_cards: SkipCards,
|
||||
}
|
||||
|
||||
impl TableauStack {
|
||||
const ITER_BEGIN: Self = Self {
|
||||
tableau: Tableau::ITER_BEGIN,
|
||||
skip_cards: SkipCards::ITER_BEGIN,
|
||||
};
|
||||
const fn next(self) -> Option<Self> {
|
||||
let TableauStack {
|
||||
tableau,
|
||||
skip_cards,
|
||||
} = self;
|
||||
if let Some(skip_cards) = skip_cards.next() {
|
||||
return Some(Self {
|
||||
tableau,
|
||||
skip_cards,
|
||||
});
|
||||
}
|
||||
if let Some(tableau) = tableau.next() {
|
||||
let skip_cards = SkipCards::Skip0;
|
||||
return Some(Self {
|
||||
tableau,
|
||||
skip_cards,
|
||||
});
|
||||
}
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
|
||||
pub enum KlondikePileStack {
|
||||
Tableau(TableauStack),
|
||||
Stock,
|
||||
Foundation(Foundation),
|
||||
}
|
||||
impl KlondikePileStack {
|
||||
const ITER_BEGIN: Self = Self::Tableau(TableauStack::ITER_BEGIN);
|
||||
const fn next(self) -> Option<Self> {
|
||||
Some(match self {
|
||||
Self::Tableau(tableau_stack) => match tableau_stack.next() {
|
||||
Some(tableau_stack) => Self::Tableau(tableau_stack),
|
||||
None => Self::Stock,
|
||||
},
|
||||
Self::Stock => Self::Foundation(Foundation::ITER_BEGIN),
|
||||
Self::Foundation(foundation) => match foundation.next() {
|
||||
Some(foundation) => Self::Foundation(foundation),
|
||||
None => return None,
|
||||
},
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
|
||||
pub struct DstFoundation {
|
||||
pub src: KlondikePile,
|
||||
pub foundation: Foundation,
|
||||
}
|
||||
impl DstFoundation {
|
||||
const ITER_BEGIN: Self = Self {
|
||||
src: KlondikePile::ITER_BEGIN,
|
||||
foundation: Foundation::ITER_BEGIN,
|
||||
};
|
||||
const fn next(self) -> Option<Self> {
|
||||
let DstFoundation { src, foundation } = self;
|
||||
if let Some(src) = src.next() {
|
||||
return Some(Self { src, foundation });
|
||||
}
|
||||
if let Some(foundation) = foundation.next() {
|
||||
let src = KlondikePile::ITER_BEGIN;
|
||||
return Some(Self { src, foundation });
|
||||
}
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
|
||||
pub struct DstTableau {
|
||||
pub src: KlondikePileStack,
|
||||
pub tableau: Tableau,
|
||||
}
|
||||
impl DstTableau {
|
||||
const ITER_BEGIN: Self = Self {
|
||||
src: KlondikePileStack::ITER_BEGIN,
|
||||
tableau: Tableau::ITER_BEGIN,
|
||||
};
|
||||
const fn next(self) -> Option<Self> {
|
||||
let DstTableau { src, tableau } = self;
|
||||
if let Some(src) = src.next() {
|
||||
return Some(Self { src, tableau });
|
||||
}
|
||||
if let Some(tableau) = tableau.next() {
|
||||
let src = KlondikePileStack::ITER_BEGIN;
|
||||
return Some(Self { src, tableau });
|
||||
}
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
|
||||
pub enum KlondikeInstruction {
|
||||
DstFoundation(DstFoundation),
|
||||
DstTableau(DstTableau),
|
||||
RotateStock,
|
||||
}
|
||||
impl KlondikeInstruction {
|
||||
const ITER_BEGIN: Self = Self::DstFoundation(DstFoundation::ITER_BEGIN);
|
||||
const fn next(self) -> Option<Self> {
|
||||
Some(match self {
|
||||
Self::DstFoundation(dst_foundation) => match dst_foundation.next() {
|
||||
Some(dst_foundation) => Self::DstFoundation(dst_foundation),
|
||||
None => Self::DstTableau(DstTableau::ITER_BEGIN),
|
||||
},
|
||||
Self::DstTableau(tableau) => match tableau.next() {
|
||||
Some(tableau) => Self::DstTableau(tableau),
|
||||
None => Self::RotateStock,
|
||||
},
|
||||
Self::RotateStock => return None,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
const TABLEAUS: usize = 7;
|
||||
const fn sum(n: usize) -> usize {
|
||||
n * (n + 1) / 2
|
||||
}
|
||||
const MAX_STACK: usize = 52 - sum(TABLEAUS);
|
||||
|
||||
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
|
||||
pub struct KlondikeState {
|
||||
stock: Pile<MAX_STACK, MAX_STACK>,
|
||||
foundations: [Stack<13>; 4],
|
||||
tableau1: Pile<0, 13>,
|
||||
tableau2: Pile<1, 13>,
|
||||
tableau3: Pile<2, 13>,
|
||||
tableau4: Pile<3, 13>,
|
||||
tableau5: Pile<4, 13>,
|
||||
tableau6: Pile<5, 13>,
|
||||
tableau7: Pile<6, 13>,
|
||||
}
|
||||
impl KlondikeState {
|
||||
pub const fn stock(&self) -> &Pile<MAX_STACK, MAX_STACK> {
|
||||
&self.stock
|
||||
}
|
||||
pub const fn foundation1(&self) -> &Stack<13> {
|
||||
&self.foundations[1 - 1]
|
||||
}
|
||||
pub const fn foundation2(&self) -> &Stack<13> {
|
||||
&self.foundations[2 - 1]
|
||||
}
|
||||
pub const fn foundation3(&self) -> &Stack<13> {
|
||||
&self.foundations[3 - 1]
|
||||
}
|
||||
pub const fn foundation4(&self) -> &Stack<13> {
|
||||
&self.foundations[4 - 1]
|
||||
}
|
||||
pub const fn tableau1(&self) -> &Pile<0, 13> {
|
||||
&self.tableau1
|
||||
}
|
||||
pub const fn tableau2(&self) -> &Pile<1, 13> {
|
||||
&self.tableau2
|
||||
}
|
||||
pub const fn tableau3(&self) -> &Pile<2, 13> {
|
||||
&self.tableau3
|
||||
}
|
||||
pub const fn tableau4(&self) -> &Pile<3, 13> {
|
||||
&self.tableau4
|
||||
}
|
||||
pub const fn tableau5(&self) -> &Pile<4, 13> {
|
||||
&self.tableau5
|
||||
}
|
||||
pub const fn tableau6(&self) -> &Pile<5, 13> {
|
||||
&self.tableau6
|
||||
}
|
||||
pub const fn tableau7(&self) -> &Pile<6, 13> {
|
||||
&self.tableau7
|
||||
}
|
||||
fn card(&self, src: KlondikePileStack) -> Option<&Card> {
|
||||
match src {
|
||||
KlondikePileStack::Tableau(TableauStack {
|
||||
tableau,
|
||||
skip_cards,
|
||||
}) => 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(),
|
||||
}
|
||||
}
|
||||
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(),
|
||||
Tableau::Tableau3 => self.tableau3.face_up().last(),
|
||||
Tableau::Tableau4 => self.tableau4.face_up().last(),
|
||||
Tableau::Tableau5 => self.tableau5.face_up().last(),
|
||||
Tableau::Tableau6 => self.tableau6.face_up().last(),
|
||||
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_cards(&mut self, src: KlondikePileStack) -> Stack<13> {
|
||||
match src {
|
||||
KlondikePileStack::Tableau(TableauStack {
|
||||
tableau,
|
||||
skip_cards,
|
||||
}) => match tableau {
|
||||
Tableau::Tableau1 => self.tableau1.take_range_flip_up(skip_cards as usize..),
|
||||
Tableau::Tableau2 => self.tableau2.take_range_flip_up(skip_cards as usize..),
|
||||
Tableau::Tableau3 => self.tableau3.take_range_flip_up(skip_cards as usize..),
|
||||
Tableau::Tableau4 => self.tableau4.take_range_flip_up(skip_cards as usize..),
|
||||
Tableau::Tableau5 => self.tableau5.take_range_flip_up(skip_cards as usize..),
|
||||
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) => {
|
||||
Stack::from_iter(self.foundations[foundation as usize].pop())
|
||||
}
|
||||
KlondikePileStack::Stock => Stack::from_iter(self.stock.pop()),
|
||||
}
|
||||
}
|
||||
fn take_top_card(&mut self, src: KlondikePile) -> Option<Card> {
|
||||
match src {
|
||||
KlondikePile::Tableau(tableau) => match tableau {
|
||||
Tableau::Tableau1 => self.tableau1.pop(),
|
||||
Tableau::Tableau2 => self.tableau2.pop(),
|
||||
Tableau::Tableau3 => self.tableau3.pop(),
|
||||
Tableau::Tableau4 => self.tableau4.pop(),
|
||||
Tableau::Tableau5 => self.tableau5.pop(),
|
||||
Tableau::Tableau6 => self.tableau6.pop(),
|
||||
Tableau::Tableau7 => self.tableau7.pop(),
|
||||
},
|
||||
KlondikePile::Foundation(foundation) => self.foundations[foundation as usize].pop(),
|
||||
KlondikePile::Stock => self.stock.pop(),
|
||||
}
|
||||
}
|
||||
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),
|
||||
Tableau::Tableau4 => self.tableau4.extend(cards),
|
||||
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),
|
||||
}
|
||||
}
|
||||
fn is_instruction_valid(&self, instruction: KlondikeInstruction) -> bool {
|
||||
match instruction {
|
||||
// Stock -> Stock draws a card or resets the stock
|
||||
KlondikeInstruction::RotateStock => {
|
||||
// cannot move stock when stock is empty
|
||||
!self.stock.is_empty()
|
||||
}
|
||||
|
||||
// moving to foundation has special rules
|
||||
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.into()) {
|
||||
// destination card exists
|
||||
Some(dst_card) => {
|
||||
// suit matches?
|
||||
src_card.suit() == dst_card.suit()
|
||||
// value is +1?
|
||||
&& dst_card.value().checked_add(1) == Some(src_card.value())
|
||||
}
|
||||
// only ace is allowed to go onto empty foundation
|
||||
None => src_card.value() == CardValue::ACE,
|
||||
}
|
||||
} else {
|
||||
false
|
||||
}
|
||||
}
|
||||
// other = move to tableau
|
||||
KlondikeInstruction::DstTableau(dst_tableau) => {
|
||||
// get the cards
|
||||
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.value().checked_sub(1) == Some(src_card.value())
|
||||
}
|
||||
// only king is allowed to go onto empty tableau
|
||||
None => src_card.value() == CardValue::KING,
|
||||
}
|
||||
} else {
|
||||
false
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub struct KlondikeIter {
|
||||
instruction: Option<KlondikeInstruction>,
|
||||
}
|
||||
impl KlondikeIter {
|
||||
const fn new() -> Self {
|
||||
Self {
|
||||
instruction: Some(KlondikeInstruction::ITER_BEGIN),
|
||||
}
|
||||
}
|
||||
}
|
||||
impl Iterator for KlondikeIter {
|
||||
type Item = KlondikeInstruction;
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
let instruction = self.instruction;
|
||||
self.instruction = instruction?.next();
|
||||
instruction
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
|
||||
pub struct Klondike {
|
||||
config: KlondikeConfig,
|
||||
state: KlondikeState,
|
||||
}
|
||||
impl Klondike {
|
||||
pub fn new_random_default() -> Self {
|
||||
Self::new(Rng::default(), KlondikeConfig::default())
|
||||
}
|
||||
pub fn new(mut seed: Rng, config: KlondikeConfig) -> Self {
|
||||
// shuffle a new deck
|
||||
let mut deck = Stack::full_deck(0);
|
||||
use rand::seq::SliceRandom;
|
||||
deck.shuffle(&mut seed);
|
||||
let mut deck = deck.into_iter();
|
||||
|
||||
// generate tableaus
|
||||
fn pile<const DN: usize>(deck: &mut arrayvec::IntoIter<Card, 52>) -> Pile<DN, 13> {
|
||||
let stack = arrayvec::ArrayVec::from_iter(deck.take(DN)).into();
|
||||
let mut pile = Pile::new_face_down(stack);
|
||||
pile.push(deck.next().unwrap());
|
||||
pile
|
||||
}
|
||||
let tableau1 = pile(&mut deck);
|
||||
let tableau2 = pile(&mut deck);
|
||||
let tableau3 = pile(&mut deck);
|
||||
let tableau4 = pile(&mut deck);
|
||||
let tableau5 = pile(&mut deck);
|
||||
let tableau6 = pile(&mut deck);
|
||||
let tableau7 = pile(&mut deck);
|
||||
|
||||
// stock is remaining cards
|
||||
let stock = Pile::new_face_down(arrayvec::ArrayVec::from_iter(deck).into());
|
||||
|
||||
let state = KlondikeState {
|
||||
stock,
|
||||
foundations: core::array::from_fn(|_| Stack::new()),
|
||||
tableau1,
|
||||
tableau2,
|
||||
tableau3,
|
||||
tableau4,
|
||||
tableau5,
|
||||
tableau6,
|
||||
tableau7,
|
||||
};
|
||||
Self { config, state }
|
||||
}
|
||||
pub const fn state(&self) -> &KlondikeState {
|
||||
&self.state
|
||||
}
|
||||
}
|
||||
|
||||
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_cards(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()
|
||||
&& self.state.tableau2.face_down().is_empty()
|
||||
&& self.state.tableau3.face_down().is_empty()
|
||||
&& self.state.tableau4.face_down().is_empty()
|
||||
&& self.state.tableau5.face_down().is_empty()
|
||||
&& self.state.tableau6.face_down().is_empty()
|
||||
&& self.state.tableau7.face_down().is_empty()
|
||||
}
|
||||
}
|
||||
+12
@@ -0,0 +1,12 @@
|
||||
pub mod card_game;
|
||||
pub mod klondike;
|
||||
|
||||
#[cfg(test)]
|
||||
mod test;
|
||||
|
||||
pub type Rng = rand::rngs::ThreadRng;
|
||||
|
||||
// // test readme
|
||||
// #[doc = include_str!("../README.md")]
|
||||
// #[cfg(doctest)]
|
||||
// struct ReadmeDoctests;
|
||||
@@ -1,25 +1,26 @@
|
||||
use card_game::{Card, Game, Pile, Rank, Session, Suit};
|
||||
mod card_game;
|
||||
mod klondike;
|
||||
|
||||
pub type Rng = rand::rngs::ThreadRng;
|
||||
|
||||
use card_game::{Card, Game, Pile, Session, Suit};
|
||||
use klondike::{
|
||||
DstFoundation, DstTableau, Foundation, Klondike, KlondikeConfig, KlondikeInstruction,
|
||||
KlondikePile, KlondikePileStack, 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> {
|
||||
impl Display for 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, "{:>2}", other as u8),
|
||||
match self.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() {
|
||||
match self.suit() {
|
||||
Suit::Spades => write!(f, "♠"),
|
||||
Suit::Hearts => write!(f, "♡"),
|
||||
Suit::Clubs => write!(f, "♣"),
|
||||
@@ -32,96 +33,60 @@ struct OptionalCard<'a>(Option<&'a Card>);
|
||||
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(Some(card)) => write!(f, "{card}"),
|
||||
OptionalCard(None) => write!(f, "None"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Display for Displayed<&Klondike> {
|
||||
impl Display for Klondike {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
// Stock
|
||||
let stock_count = self.0.state().stock().face_down().len();
|
||||
let stock_count = self.state().stock().face_down().len();
|
||||
writeln!(f, "Stock: {stock_count}")?;
|
||||
|
||||
// Hand
|
||||
let hand = self.0.state().stock().face_up().last();
|
||||
let hand = self.state().stock().face_up().last();
|
||||
writeln!(f, "Hand: {}", OptionalCard(hand))?;
|
||||
|
||||
// Foundations
|
||||
writeln!(f, " STOCK F1 F2 F3 F4")?;
|
||||
write!(
|
||||
f,
|
||||
" {:>2} {} {} {} {} {}",
|
||||
stock_count,
|
||||
OptionalCard(hand),
|
||||
OptionalCard(self.0.state().foundation1().last()),
|
||||
OptionalCard(self.0.state().foundation2().last()),
|
||||
OptionalCard(self.0.state().foundation3().last()),
|
||||
OptionalCard(self.0.state().foundation4().last()),
|
||||
"Foundations: {} {} {} {}",
|
||||
OptionalCard(self.state().foundation1().last()),
|
||||
OptionalCard(self.state().foundation2().last()),
|
||||
OptionalCard(self.state().foundation3().last()),
|
||||
OptionalCard(self.state().foundation4().last()),
|
||||
)?;
|
||||
writeln!(f)?;
|
||||
|
||||
writeln!(f, " T1 T2 T3 T4 T5 T6 T7")?;
|
||||
|
||||
fn write_pile_card<const DN: usize, const UP: usize>(
|
||||
fn write_pile<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) {
|
||||
return write!(f, " ⎾⏋"); // └┘ ⨽⨼ ⫭⫬
|
||||
write!(f, "T{} ", pile_id)?;
|
||||
for _ in pile.face_down() {
|
||||
write!(f, "]")?;
|
||||
}
|
||||
let Some(row) = row.checked_sub(pile.face_down().len()) else {
|
||||
return write!(f, " ");
|
||||
};
|
||||
if let Some(card) = pile.face_up().get(row) {
|
||||
return write!(f, "{}", Displayed(card));
|
||||
for card in pile.face_up() {
|
||||
write!(f, "{card}")?;
|
||||
}
|
||||
write!(f, " ")
|
||||
}
|
||||
|
||||
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)?;
|
||||
writeln!(f)?;
|
||||
Ok(())
|
||||
}
|
||||
write_pile(f, self.state().tableau1(), 1)?;
|
||||
write_pile(f, self.state().tableau2(), 2)?;
|
||||
write_pile(f, self.state().tableau3(), 3)?;
|
||||
write_pile(f, self.state().tableau4(), 4)?;
|
||||
write_pile(f, self.state().tableau5(), 5)?;
|
||||
write_pile(f, self.state().tableau6(), 6)?;
|
||||
write_pile(f, self.state().tableau7(), 7)?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
struct DisplayStats<'a>(&'a Session<Klondike>);
|
||||
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().stats().moves(),
|
||||
self.0.stats().undos(),
|
||||
self.0.state().score(self.0.stats(), self.0.config()),
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
struct Invalid;
|
||||
struct Parsed<T>(T);
|
||||
@@ -174,7 +139,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()?),
|
||||
@@ -183,7 +148,6 @@ impl core::str::FromStr for SessionInstruction {
|
||||
}
|
||||
|
||||
fn find_valid_instruction(
|
||||
config: &KlondikeConfig,
|
||||
state: &Klondike,
|
||||
naive_instruction: NaiveInstruction,
|
||||
) -> Option<KlondikeInstruction> {
|
||||
@@ -213,7 +177,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);
|
||||
}
|
||||
}
|
||||
@@ -231,30 +195,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().nth(1) {
|
||||
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!("{}", DisplayStats(&session));
|
||||
// display game
|
||||
println!("{}", Displayed(session.state().state()));
|
||||
println!("{}", 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.");
|
||||
@@ -263,10 +215,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 => {
|
||||
@@ -275,11 +224,7 @@ fn main() -> Result<(), std::io::Error> {
|
||||
}
|
||||
}
|
||||
SessionInstruction::Auto => {
|
||||
if let Some(instruction) = session
|
||||
.state()
|
||||
.state()
|
||||
.get_auto_move(&session.config().inner)
|
||||
{
|
||||
if let Some(instruction) = session.possible_instructions().next() {
|
||||
session.process_instruction(instruction);
|
||||
} else {
|
||||
println!("No valid moves!");
|
||||
@@ -289,11 +234,9 @@ fn main() -> Result<(), std::io::Error> {
|
||||
session.process_instruction(KlondikeInstruction::RotateStock)
|
||||
}
|
||||
SessionInstruction::Klondike(naive_instruction) => {
|
||||
if let Some(instruction) = find_valid_instruction(
|
||||
&session.config().inner,
|
||||
session.state().state(),
|
||||
naive_instruction,
|
||||
) {
|
||||
if let Some(instruction) =
|
||||
find_valid_instruction(session.state(), naive_instruction)
|
||||
{
|
||||
session.process_instruction(instruction);
|
||||
} else {
|
||||
println!("Invalid move!");
|
||||
+33
@@ -0,0 +1,33 @@
|
||||
use crate::card_game::{Game, Session};
|
||||
use crate::klondike::Klondike;
|
||||
#[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}");
|
||||
}
|
||||
Reference in New Issue
Block a user