Compare commits
2 Commits
master
..
2f2910dce2
| Author | SHA1 | Date | |
|---|---|---|---|
 Quaternions
|
2f2910dce2 | ||
|
Quaternions
|
03f5e70498 |
Generated
+2
-157
@@ -11,14 +11,8 @@ checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c"
|
|||||||
[[package]]
|
[[package]]
|
||||||
name = "arrayvec"
|
name = "arrayvec"
|
||||||
version = "0.7.6"
|
version = "0.7.6"
|
||||||
source = "sparse+https://git.aleshym.co/api/packages/Quaternions/cargo/"
|
|
||||||
checksum = "813440870d646c57c222c1d713dc4e3ddcb2919c3801564d767d85d7bf2afee4"
|
|
||||||
|
|
||||||
[[package]]
|
|
||||||
name = "autocfg"
|
|
||||||
version = "1.5.1"
|
|
||||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||||
checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"
|
checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
|
||||||
|
|
||||||
[[package]]
|
[[package]]
|
||||||
name = "bitflags"
|
name = "bitflags"
|
||||||
@@ -28,11 +22,9 @@ checksum = "c4512299f36f043ab09a583e57bceb5a5aab7a73db1805848e8fef3c9e8c78b3"
|
|||||||
|
|
||||||
[[package]]
|
[[package]]
|
||||||
name = "card_game"
|
name = "card_game"
|
||||||
version = "0.4.1"
|
version = "0.1.0"
|
||||||
dependencies = [
|
dependencies = [
|
||||||
"arrayvec",
|
"arrayvec",
|
||||||
"serde",
|
|
||||||
"serde_derive",
|
|
||||||
]
|
]
|
||||||
|
|
||||||
[[package]]
|
[[package]]
|
||||||
@@ -52,17 +44,6 @@ dependencies = [
|
|||||||
"rand_core",
|
"rand_core",
|
||||||
]
|
]
|
||||||
|
|
||||||
[[package]]
|
|
||||||
name = "console"
|
|
||||||
version = "0.16.3"
|
|
||||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
||||||
checksum = "d64e8af5551369d19cf50138de61f1c42074ab970f74e99be916646777f8fc87"
|
|
||||||
dependencies = [
|
|
||||||
"encode_unicode",
|
|
||||||
"libc",
|
|
||||||
"windows-sys",
|
|
||||||
]
|
|
||||||
|
|
||||||
[[package]]
|
[[package]]
|
||||||
name = "cpufeatures"
|
name = "cpufeatures"
|
||||||
version = "0.3.0"
|
version = "0.3.0"
|
||||||
@@ -72,34 +53,12 @@ dependencies = [
|
|||||||
"libc",
|
"libc",
|
||||||
]
|
]
|
||||||
|
|
||||||
[[package]]
|
|
||||||
name = "encode_unicode"
|
|
||||||
version = "1.0.0"
|
|
||||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
||||||
checksum = "34aa73646ffb006b8f5147f3dc182bd4bcb190227ce861fc4a4844bf8e3cb2c0"
|
|
||||||
|
|
||||||
[[package]]
|
[[package]]
|
||||||
name = "equivalent"
|
name = "equivalent"
|
||||||
version = "1.0.2"
|
version = "1.0.2"
|
||||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||||
checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
|
checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
|
||||||
|
|
||||||
[[package]]
|
|
||||||
name = "errno"
|
|
||||||
version = "0.3.14"
|
|
||||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
||||||
checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
|
|
||||||
dependencies = [
|
|
||||||
"libc",
|
|
||||||
"windows-sys",
|
|
||||||
]
|
|
||||||
|
|
||||||
[[package]]
|
|
||||||
name = "fastrand"
|
|
||||||
version = "2.4.1"
|
|
||||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
||||||
checksum = "9f1f227452a390804cdb637b74a86990f2a7d7ba4b7d5693aac9b4dd6defd8d6"
|
|
||||||
|
|
||||||
[[package]]
|
[[package]]
|
||||||
name = "foldhash"
|
name = "foldhash"
|
||||||
version = "0.1.5"
|
version = "0.1.5"
|
||||||
@@ -159,18 +118,6 @@ dependencies = [
|
|||||||
"serde_core",
|
"serde_core",
|
||||||
]
|
]
|
||||||
|
|
||||||
[[package]]
|
|
||||||
name = "insta"
|
|
||||||
version = "1.47.2"
|
|
||||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
||||||
checksum = "7b4a6248eb93a4401ed2f37dfe8ea592d3cf05b7cf4f8efa867b6895af7e094e"
|
|
||||||
dependencies = [
|
|
||||||
"console",
|
|
||||||
"once_cell",
|
|
||||||
"similar",
|
|
||||||
"tempfile",
|
|
||||||
]
|
|
||||||
|
|
||||||
[[package]]
|
[[package]]
|
||||||
name = "itoa"
|
name = "itoa"
|
||||||
version = "1.0.18"
|
version = "1.0.18"
|
||||||
@@ -179,23 +126,9 @@ checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
|
|||||||
|
|
||||||
[[package]]
|
[[package]]
|
||||||
name = "klondike"
|
name = "klondike"
|
||||||
version = "0.4.0"
|
|
||||||
dependencies = [
|
|
||||||
"card_game",
|
|
||||||
"insta",
|
|
||||||
"rand",
|
|
||||||
"rmp-serde",
|
|
||||||
"serde",
|
|
||||||
"serde_derive",
|
|
||||||
"serde_json",
|
|
||||||
]
|
|
||||||
|
|
||||||
[[package]]
|
|
||||||
name = "klondike-bench"
|
|
||||||
version = "0.1.0"
|
version = "0.1.0"
|
||||||
dependencies = [
|
dependencies = [
|
||||||
"card_game",
|
"card_game",
|
||||||
"klondike",
|
|
||||||
"rand",
|
"rand",
|
||||||
]
|
]
|
||||||
|
|
||||||
@@ -205,7 +138,6 @@ version = "0.1.0"
|
|||||||
dependencies = [
|
dependencies = [
|
||||||
"card_game",
|
"card_game",
|
||||||
"klondike",
|
"klondike",
|
||||||
"rand",
|
|
||||||
]
|
]
|
||||||
|
|
||||||
[[package]]
|
[[package]]
|
||||||
@@ -220,12 +152,6 @@ version = "0.2.186"
|
|||||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||||
checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66"
|
checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66"
|
||||||
|
|
||||||
[[package]]
|
|
||||||
name = "linux-raw-sys"
|
|
||||||
version = "0.12.1"
|
|
||||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
||||||
checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53"
|
|
||||||
|
|
||||||
[[package]]
|
[[package]]
|
||||||
name = "log"
|
name = "log"
|
||||||
version = "0.4.29"
|
version = "0.4.29"
|
||||||
@@ -238,21 +164,6 @@ version = "2.8.0"
|
|||||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||||
checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
|
checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
|
||||||
|
|
||||||
[[package]]
|
|
||||||
name = "num-traits"
|
|
||||||
version = "0.2.19"
|
|
||||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
||||||
checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
|
|
||||||
dependencies = [
|
|
||||||
"autocfg",
|
|
||||||
]
|
|
||||||
|
|
||||||
[[package]]
|
|
||||||
name = "once_cell"
|
|
||||||
version = "1.21.4"
|
|
||||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
||||||
checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
|
|
||||||
|
|
||||||
[[package]]
|
[[package]]
|
||||||
name = "prettyplease"
|
name = "prettyplease"
|
||||||
version = "0.2.37"
|
version = "0.2.37"
|
||||||
@@ -304,38 +215,6 @@ version = "0.10.1"
|
|||||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||||
checksum = "63b8176103e19a2643978565ca18b50549f6101881c443590420e4dc998a3c69"
|
checksum = "63b8176103e19a2643978565ca18b50549f6101881c443590420e4dc998a3c69"
|
||||||
|
|
||||||
[[package]]
|
|
||||||
name = "rmp"
|
|
||||||
version = "0.8.15"
|
|
||||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
||||||
checksum = "4ba8be72d372b2c9b35542551678538b562e7cf86c3315773cae48dfbfe7790c"
|
|
||||||
dependencies = [
|
|
||||||
"num-traits",
|
|
||||||
]
|
|
||||||
|
|
||||||
[[package]]
|
|
||||||
name = "rmp-serde"
|
|
||||||
version = "1.3.1"
|
|
||||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
||||||
checksum = "72f81bee8c8ef9b577d1681a70ebbc962c232461e397b22c208c43c04b67a155"
|
|
||||||
dependencies = [
|
|
||||||
"rmp",
|
|
||||||
"serde",
|
|
||||||
]
|
|
||||||
|
|
||||||
[[package]]
|
|
||||||
name = "rustix"
|
|
||||||
version = "1.1.4"
|
|
||||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
||||||
checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190"
|
|
||||||
dependencies = [
|
|
||||||
"bitflags",
|
|
||||||
"errno",
|
|
||||||
"libc",
|
|
||||||
"linux-raw-sys",
|
|
||||||
"windows-sys",
|
|
||||||
]
|
|
||||||
|
|
||||||
[[package]]
|
[[package]]
|
||||||
name = "semver"
|
name = "semver"
|
||||||
version = "1.0.28"
|
version = "1.0.28"
|
||||||
@@ -384,12 +263,6 @@ dependencies = [
|
|||||||
"zmij",
|
"zmij",
|
||||||
]
|
]
|
||||||
|
|
||||||
[[package]]
|
|
||||||
name = "similar"
|
|
||||||
version = "2.7.0"
|
|
||||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
||||||
checksum = "bbbb5d9659141646ae647b42fe094daf6c6192d1620870b449d9557f748b2daa"
|
|
||||||
|
|
||||||
[[package]]
|
[[package]]
|
||||||
name = "syn"
|
name = "syn"
|
||||||
version = "2.0.117"
|
version = "2.0.117"
|
||||||
@@ -401,19 +274,6 @@ dependencies = [
|
|||||||
"unicode-ident",
|
"unicode-ident",
|
||||||
]
|
]
|
||||||
|
|
||||||
[[package]]
|
|
||||||
name = "tempfile"
|
|
||||||
version = "3.27.0"
|
|
||||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
||||||
checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd"
|
|
||||||
dependencies = [
|
|
||||||
"fastrand",
|
|
||||||
"getrandom",
|
|
||||||
"once_cell",
|
|
||||||
"rustix",
|
|
||||||
"windows-sys",
|
|
||||||
]
|
|
||||||
|
|
||||||
[[package]]
|
[[package]]
|
||||||
name = "unicode-ident"
|
name = "unicode-ident"
|
||||||
version = "1.0.24"
|
version = "1.0.24"
|
||||||
@@ -478,21 +338,6 @@ dependencies = [
|
|||||||
"semver",
|
"semver",
|
||||||
]
|
]
|
||||||
|
|
||||||
[[package]]
|
|
||||||
name = "windows-link"
|
|
||||||
version = "0.2.1"
|
|
||||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
||||||
checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
|
|
||||||
|
|
||||||
[[package]]
|
|
||||||
name = "windows-sys"
|
|
||||||
version = "0.61.2"
|
|
||||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
|
||||||
checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
|
|
||||||
dependencies = [
|
|
||||||
"windows-link",
|
|
||||||
]
|
|
||||||
|
|
||||||
[[package]]
|
[[package]]
|
||||||
name = "wit-bindgen"
|
name = "wit-bindgen"
|
||||||
version = "0.51.0"
|
version = "0.51.0"
|
||||||
|
|||||||
-16
@@ -2,22 +2,6 @@
|
|||||||
members = [
|
members = [
|
||||||
"card_game",
|
"card_game",
|
||||||
"klondike",
|
"klondike",
|
||||||
"klondike-bench",
|
|
||||||
"klondike-cli",
|
"klondike-cli",
|
||||||
]
|
]
|
||||||
resolver = "3"
|
resolver = "3"
|
||||||
|
|
||||||
[workspace.dependencies]
|
|
||||||
card_game = { version = "0.4.1", path = "card_game", registry = "Quaternions" }
|
|
||||||
klondike = { version = "0.4.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"
|
|
||||||
|
|||||||
+2
-11
@@ -1,6 +1,6 @@
|
|||||||
[package]
|
[package]
|
||||||
name = "card_game"
|
name = "card_game"
|
||||||
version = "0.4.1"
|
version = "0.1.0"
|
||||||
edition = "2024"
|
edition = "2024"
|
||||||
repository = "https://git.aleshym.co/Quaternions/card_game"
|
repository = "https://git.aleshym.co/Quaternions/card_game"
|
||||||
license = "MIT OR Apache-2.0"
|
license = "MIT OR Apache-2.0"
|
||||||
@@ -9,13 +9,4 @@ authors = ["Rhys Lloyd <krakow20@gmail.com>"]
|
|||||||
keywords = ["card", "cards", "solitaire", "klondike"]
|
keywords = ["card", "cards", "solitaire", "klondike"]
|
||||||
|
|
||||||
[dependencies]
|
[dependencies]
|
||||||
arrayvec = { version = "0.7.6", registry = "Quaternions", features = ["len_u8"], default-features = false }
|
arrayvec = "0.7.6"
|
||||||
serde = { version = "1.0.228", default-features = false, optional = true }
|
|
||||||
serde_derive = { version = "1.0.228", default-features = false, optional = true }
|
|
||||||
|
|
||||||
[lints]
|
|
||||||
workspace = true
|
|
||||||
|
|
||||||
[features]
|
|
||||||
default = ["serde"]
|
|
||||||
serde = ["dep:serde", "dep:serde_derive"]
|
|
||||||
|
|||||||
@@ -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>
|
|
||||||
+166
-506
@@ -1,21 +1,11 @@
|
|||||||
// test readme
|
|
||||||
#[doc = include_str!("../README.md")]
|
|
||||||
#[cfg(doctest)]
|
|
||||||
struct ReadmeDoctests;
|
|
||||||
|
|
||||||
use core::ops::RangeBounds;
|
use core::ops::RangeBounds;
|
||||||
|
|
||||||
// TODO: pub struct ValidInstruction<I>(I);
|
// TODO: pub struct ValidInstruction<I>(I);
|
||||||
pub trait Game: Clone {
|
pub trait Game {
|
||||||
type Score: Clone + core::fmt::Debug;
|
type Stats;
|
||||||
type Stats: Clone + core::fmt::Debug;
|
type Config;
|
||||||
type Config: Clone + core::fmt::Debug;
|
type Instruction;
|
||||||
type Instruction: Clone + core::fmt::Debug;
|
fn possible_instructions(&self) -> impl Iterator<Item = Self::Instruction> + use<Self>;
|
||||||
fn score(&self, stats: &Self::Stats, config: &Self::Config) -> Self::Score;
|
|
||||||
fn possible_instructions(
|
|
||||||
&self,
|
|
||||||
config: &Self::Config,
|
|
||||||
) -> impl Iterator<Item = Self::Instruction> + use<Self>;
|
|
||||||
fn is_instruction_valid(&self, config: &Self::Config, instruction: Self::Instruction) -> bool;
|
fn is_instruction_valid(&self, config: &Self::Config, instruction: Self::Instruction) -> bool;
|
||||||
fn process_instruction(
|
fn process_instruction(
|
||||||
&mut self,
|
&mut self,
|
||||||
@@ -26,27 +16,6 @@ pub trait Game: Clone {
|
|||||||
fn is_win(&self) -> bool;
|
fn is_win(&self) -> bool;
|
||||||
}
|
}
|
||||||
|
|
||||||
/// card_game supports up to 4 identifiably separate decks.
|
|
||||||
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
|
|
||||||
pub enum Deck {
|
|
||||||
Deck1 = 0b00,
|
|
||||||
Deck2 = 0b01,
|
|
||||||
Deck3 = 0b10,
|
|
||||||
Deck4 = 0b11,
|
|
||||||
}
|
|
||||||
impl Deck {
|
|
||||||
pub const fn new(deck: u8) -> Option<Self> {
|
|
||||||
use Deck::*;
|
|
||||||
Some(match deck {
|
|
||||||
0b00 => Deck1,
|
|
||||||
0b01 => Deck2,
|
|
||||||
0b10 => Deck3,
|
|
||||||
0b11 => Deck4,
|
|
||||||
_ => return None,
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
|
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
|
||||||
pub enum Suit {
|
pub enum Suit {
|
||||||
Spades = 0b00,
|
Spades = 0b00,
|
||||||
@@ -56,115 +25,71 @@ pub enum Suit {
|
|||||||
}
|
}
|
||||||
impl Suit {
|
impl Suit {
|
||||||
pub const SUITS: [Self; 4] = [Self::Spades, Self::Hearts, Self::Clubs, Self::Diamonds];
|
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.
|
/// Is the suit red.
|
||||||
pub const fn is_red(self) -> bool {
|
pub fn is_red(self) -> bool {
|
||||||
self as u8 & 0b01 != 0
|
self as u8 & 0b01 != 0
|
||||||
}
|
}
|
||||||
/// Suit value is 2 bits, is_red is the low bit.
|
/// Is the suit shape spikey. (Bouba/kiki)
|
||||||
pub const fn suit_high_bit(self) -> bool {
|
pub fn is_kiki(self) -> bool {
|
||||||
self as u8 & 0b10 != 0
|
self as u8 & 0b10 != 0
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
|
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
|
||||||
pub enum Rank {
|
pub struct CardValue(u8);
|
||||||
Ace = 1,
|
impl CardValue {
|
||||||
Two = 2,
|
pub const ACE: Self = CardValue(1);
|
||||||
Three = 3,
|
pub const TWO: Self = CardValue(2);
|
||||||
Four = 4,
|
pub const THREE: Self = CardValue(3);
|
||||||
Five = 5,
|
pub const FOUR: Self = CardValue(4);
|
||||||
Six = 6,
|
pub const FIVE: Self = CardValue(5);
|
||||||
Seven = 7,
|
pub const SIX: Self = CardValue(6);
|
||||||
Eight = 8,
|
pub const SEVEN: Self = CardValue(7);
|
||||||
Nine = 9,
|
pub const EIGHT: Self = CardValue(8);
|
||||||
Ten = 10,
|
pub const NINE: Self = CardValue(9);
|
||||||
Jack = 11,
|
pub const TEN: Self = CardValue(10);
|
||||||
Queen = 12,
|
pub const JACK: Self = CardValue(11);
|
||||||
King = 13,
|
pub const QUEEN: Self = CardValue(12);
|
||||||
}
|
pub const KING: Self = CardValue(13);
|
||||||
impl Rank {
|
pub fn get(self) -> u8 {
|
||||||
pub const RANKS: [Self; 13] = [
|
self.0
|
||||||
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> {
|
pub fn checked_add(self, offset: u8) -> Option<CardValue> {
|
||||||
match (self as u8).checked_add(offset) {
|
let new_value = self.0.checked_add(offset)?;
|
||||||
Some(rank) => Self::new(rank),
|
if 13 < new_value {
|
||||||
None => None,
|
None
|
||||||
|
} else {
|
||||||
|
Some(CardValue(new_value))
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
pub const fn checked_sub(self, offset: u8) -> Option<Rank> {
|
pub fn checked_sub(self, offset: u8) -> Option<CardValue> {
|
||||||
match (self as u8).checked_sub(offset) {
|
let new_value = self.0.checked_sub(offset)?;
|
||||||
Some(rank) => Self::new(rank),
|
if new_value < 1 {
|
||||||
None => None,
|
None
|
||||||
|
} else {
|
||||||
|
Some(CardValue(new_value))
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
/// An identifier which specifies the deck id, suit, and card value.
|
||||||
/// A card which specifies the deck id, suit, and card value.
|
|
||||||
/// 2 bits for deck ID
|
/// 2 bits for deck ID
|
||||||
/// 2 bits for suit ID
|
/// 2 bits for suit ID
|
||||||
/// 4 bits for card Value
|
/// 4 bits for card Value
|
||||||
|
/// TODO: better encoding for slightly more decks
|
||||||
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
|
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
|
||||||
#[cfg_attr(
|
pub struct Card(u8);
|
||||||
feature = "serde",
|
|
||||||
derive(serde_derive::Deserialize, serde_derive::Serialize),
|
|
||||||
serde(transparent)
|
|
||||||
)]
|
|
||||||
pub struct Card(core::num::NonZeroU8);
|
|
||||||
impl Card {
|
impl Card {
|
||||||
pub const fn new(deck: Deck, suit: Suit, rank: Rank) -> Self {
|
pub fn new(deck: u8, suit: Suit, CardValue(value): CardValue) -> Self {
|
||||||
let packed = (deck as u8) << 6 | (suit as u8) << 4 | (rank as u8);
|
Self(deck << 6 | (suit as u8) << 4 | value)
|
||||||
Self(core::num::NonZeroU8::new(packed).unwrap())
|
|
||||||
}
|
}
|
||||||
pub const fn rank(&self) -> Rank {
|
pub fn value(&self) -> CardValue {
|
||||||
let masked = self.0.get() & 0b1111;
|
let masked = self.0 & 0b1111;
|
||||||
Rank::new(masked).unwrap()
|
CardValue(masked)
|
||||||
}
|
}
|
||||||
pub const fn suit(&self) -> Suit {
|
pub fn suit(&self) -> Suit {
|
||||||
let low_bit = self.is_red();
|
let red = self.is_red();
|
||||||
let high_bit = self.suit_high_bit();
|
let kiki = self.is_kiki();
|
||||||
match (high_bit, low_bit) {
|
match (kiki, red) {
|
||||||
(false, false) => Suit::Spades,
|
(false, false) => Suit::Spades,
|
||||||
(false, true) => Suit::Hearts,
|
(false, true) => Suit::Hearts,
|
||||||
(true, false) => Suit::Clubs,
|
(true, false) => Suit::Clubs,
|
||||||
@@ -172,19 +97,19 @@ impl Card {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
/// Is the suit red.
|
/// Is the suit red.
|
||||||
pub const fn is_red(&self) -> bool {
|
pub fn is_red(&self) -> bool {
|
||||||
self.0.get() & 0b010000 != 0
|
self.0 & 0b010000 != 0
|
||||||
}
|
}
|
||||||
/// Suit value is 2 bits, is_red is the low bit.
|
/// Is the suit shape spikey. (Bouba/kiki)
|
||||||
pub const fn suit_high_bit(&self) -> bool {
|
pub fn is_kiki(&self) -> bool {
|
||||||
self.0.get() & 0b100000 != 0
|
self.0 & 0b100000 != 0
|
||||||
}
|
}
|
||||||
pub const fn deck(&self) -> Deck {
|
pub fn deck(&self) -> u8 {
|
||||||
Deck::new(self.0.get() >> 6).unwrap()
|
self.0 >> 6
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
#[derive(Clone, Debug, Default, Eq, Hash, PartialEq)]
|
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
|
||||||
pub struct Stack<const CAP: usize>(arrayvec::ArrayVec<Card, CAP>);
|
pub struct Stack<const CAP: usize>(arrayvec::ArrayVec<Card, CAP>);
|
||||||
impl<const CAP: usize> Stack<CAP> {
|
impl<const CAP: usize> Stack<CAP> {
|
||||||
pub const fn new() -> Self {
|
pub const fn new() -> Self {
|
||||||
@@ -196,11 +121,11 @@ impl<const CAP: usize> Stack<CAP> {
|
|||||||
}
|
}
|
||||||
impl Stack<52> {
|
impl Stack<52> {
|
||||||
/// Generate a full deck of cards with the specified deck id.
|
/// Generate a full deck of cards with the specified deck id.
|
||||||
pub fn full_deck(deck: Deck) -> Self {
|
pub fn full_deck(deck: u8) -> Self {
|
||||||
let mut stack = arrayvec::ArrayVec::new();
|
let mut stack = arrayvec::ArrayVec::new();
|
||||||
for suit in Suit::SUITS {
|
for suit in Suit::SUITS {
|
||||||
for rank in Rank::RANKS {
|
for value in 1..=13 {
|
||||||
stack.push(Card::new(deck, suit, rank));
|
stack.push(Card::new(deck, suit, CardValue(value)));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
Stack(stack)
|
Stack(stack)
|
||||||
@@ -235,78 +160,28 @@ impl<const CAP: usize> IntoIterator for Stack<CAP> {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
#[cfg(feature = "serde")]
|
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
|
||||||
impl<'de, const CAP: usize> serde::Deserialize<'de> for Stack<CAP> {
|
|
||||||
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
|
|
||||||
where
|
|
||||||
D: serde::Deserializer<'de>,
|
|
||||||
{
|
|
||||||
struct StackVisitor<const CAP: usize>;
|
|
||||||
impl<'de, const CAP: usize> serde::de::Visitor<'de> for StackVisitor<CAP> {
|
|
||||||
type Value = Stack<CAP>;
|
|
||||||
fn expecting(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
|
|
||||||
write!(f, "Card Stack")
|
|
||||||
}
|
|
||||||
fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
|
|
||||||
where
|
|
||||||
A: serde::de::SeqAccess<'de>,
|
|
||||||
{
|
|
||||||
use serde::de::Error;
|
|
||||||
let mut stack = Stack::new();
|
|
||||||
while let Some(card) = seq.next_element()? {
|
|
||||||
stack.try_push(card).map_err(A::Error::custom)?;
|
|
||||||
}
|
|
||||||
Ok(stack)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
deserializer.deserialize_seq(StackVisitor)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
#[cfg(feature = "serde")]
|
|
||||||
impl<const CAP: usize> serde::Serialize for Stack<CAP> {
|
|
||||||
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
|
|
||||||
where
|
|
||||||
S: serde::Serializer,
|
|
||||||
{
|
|
||||||
use serde::ser::SerializeSeq;
|
|
||||||
let mut seq = serializer.serialize_seq(Some(self.len()))?;
|
|
||||||
for card in self.as_slice() {
|
|
||||||
seq.serialize_element(card)?;
|
|
||||||
}
|
|
||||||
seq.end()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// A pile is a stack of face down cards and a stack of face up cards.
|
|
||||||
#[derive(Clone, Debug, Default, Eq, Hash, PartialEq)]
|
|
||||||
#[cfg_attr(
|
|
||||||
feature = "serde",
|
|
||||||
derive(serde_derive::Deserialize, serde_derive::Serialize)
|
|
||||||
)]
|
|
||||||
pub struct Pile<const DN: usize, const UP: usize> {
|
pub struct Pile<const DN: usize, const UP: usize> {
|
||||||
face_down: Stack<DN>,
|
face_down: Stack<DN>,
|
||||||
face_up: Stack<UP>,
|
face_up: Stack<UP>,
|
||||||
}
|
}
|
||||||
impl<const DN: usize, const UP: usize> Pile<DN, UP> {
|
impl<const DN: usize, const UP: usize> Pile<DN, UP> {
|
||||||
pub const fn new() -> Self {
|
pub fn new() -> Self {
|
||||||
Self {
|
Self {
|
||||||
face_down: Stack::new(),
|
face_down: Stack::new(),
|
||||||
face_up: Stack::new(),
|
face_up: Stack::new(),
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
pub const fn new_face_down(stack: Stack<DN>) -> Self {
|
pub fn new_face_down(stack: Stack<DN>) -> Self {
|
||||||
Self {
|
Self {
|
||||||
face_down: stack,
|
face_down: stack,
|
||||||
face_up: Stack::new(),
|
face_up: Stack::new(),
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
/// Returns whether a card was flipped up.
|
pub fn flip_up(&mut self) {
|
||||||
pub fn flip_up(&mut self) -> bool {
|
|
||||||
if let Some(card) = self.face_down.pop() {
|
if let Some(card) = self.face_down.pop() {
|
||||||
self.face_up.push(card);
|
self.face_up.push(card);
|
||||||
return true;
|
|
||||||
}
|
}
|
||||||
false
|
|
||||||
}
|
}
|
||||||
pub fn is_empty(&self) -> bool {
|
pub fn is_empty(&self) -> bool {
|
||||||
self.face_down.is_empty() && self.face_up.is_empty()
|
self.face_down.is_empty() && self.face_up.is_empty()
|
||||||
@@ -314,31 +189,25 @@ impl<const DN: usize, const UP: usize> Pile<DN, UP> {
|
|||||||
pub fn pop(&mut self) -> Option<Card> {
|
pub fn pop(&mut self) -> Option<Card> {
|
||||||
self.face_up.pop()
|
self.face_up.pop()
|
||||||
}
|
}
|
||||||
/// Returns the popped card and whether a card was flipped up.
|
pub fn pop_flip_up(&mut self) -> Option<Card> {
|
||||||
pub fn pop_flip_up(&mut self) -> (Option<Card>, bool) {
|
let card = self.face_up.pop()?;
|
||||||
let card = match self.face_up.pop() {
|
if self.face_up.is_empty() {
|
||||||
Some(card) => card,
|
self.flip_up();
|
||||||
None => return (None, false),
|
}
|
||||||
};
|
Some(card)
|
||||||
let did_flip_up = if self.face_up.is_empty() {
|
|
||||||
self.flip_up()
|
|
||||||
} else {
|
|
||||||
false
|
|
||||||
};
|
|
||||||
(Some(card), did_flip_up)
|
|
||||||
}
|
}
|
||||||
pub fn take_range<R: RangeBounds<usize>>(&mut self, range: R) -> Stack<UP> {
|
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)
|
self.face_up.take_range(range)
|
||||||
}
|
}
|
||||||
/// Returns the card range and whether a card was flipped up.
|
pub fn take_range_flip_up<R: RangeBounds<usize>>(&mut self, range: R) -> Stack<UP> {
|
||||||
pub fn take_range_flip_up<R: RangeBounds<usize>>(&mut self, range: R) -> (Stack<UP>, bool) {
|
|
||||||
let cards = self.take_range(range);
|
let cards = self.take_range(range);
|
||||||
let did_flip_up = if self.face_up.is_empty() {
|
if self.face_up.is_empty() {
|
||||||
self.flip_up()
|
self.flip_up();
|
||||||
} else {
|
}
|
||||||
false
|
cards
|
||||||
};
|
|
||||||
(cards, did_flip_up)
|
|
||||||
}
|
}
|
||||||
pub fn push(&mut self, card: Card) {
|
pub fn push(&mut self, card: Card) {
|
||||||
self.face_up.push(card);
|
self.face_up.push(card);
|
||||||
@@ -358,187 +227,78 @@ impl<const CAP: usize> Pile<CAP, CAP> {
|
|||||||
self.swap_up_down();
|
self.swap_up_down();
|
||||||
self.face_down.reverse();
|
self.face_down.reverse();
|
||||||
}
|
}
|
||||||
pub const fn swap_up_down(&mut self) {
|
pub fn swap_up_down(&mut self) {
|
||||||
core::mem::swap(&mut self.face_up, &mut self.face_down);
|
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)]
|
#[derive(Clone, Debug)]
|
||||||
pub enum SessionInstruction<I> {
|
pub enum SessionInstruction<I> {
|
||||||
Undo,
|
Undo,
|
||||||
InnerInstruction(I),
|
InnerInstruction(I),
|
||||||
}
|
}
|
||||||
|
|
||||||
#[derive(Clone, Debug, Default)]
|
#[derive(Clone, Debug)]
|
||||||
#[cfg_attr(
|
|
||||||
feature = "serde",
|
|
||||||
derive(serde_derive::Deserialize, serde_derive::Serialize)
|
|
||||||
)]
|
|
||||||
pub struct SessionStats<S> {
|
pub struct SessionStats<S> {
|
||||||
inner: S,
|
inner_stats: S,
|
||||||
undos: u32,
|
undos: usize,
|
||||||
}
|
}
|
||||||
impl<S> SessionStats<S> {
|
impl<S> SessionStats<S> {
|
||||||
pub const fn stats(&self) -> &S {
|
const fn new(inner_stats: S) -> Self {
|
||||||
&self.inner
|
SessionStats {
|
||||||
|
inner_stats,
|
||||||
|
undos: 0,
|
||||||
|
}
|
||||||
}
|
}
|
||||||
const fn increment_undos(&mut self) {
|
const fn increment_undos(&mut self) {
|
||||||
self.undos += 1;
|
self.undos += 1;
|
||||||
}
|
}
|
||||||
pub const fn undos(&self) -> u32 {
|
|
||||||
self.undos
|
|
||||||
}
|
|
||||||
}
|
|
||||||
#[derive(Clone, Debug)]
|
|
||||||
#[cfg_attr(
|
|
||||||
feature = "serde",
|
|
||||||
derive(serde_derive::Deserialize, serde_derive::Serialize)
|
|
||||||
)]
|
|
||||||
pub struct SessionConfig<C> {
|
|
||||||
pub inner: C,
|
|
||||||
pub undo_penalty: i32,
|
|
||||||
pub solve_moves_budget: u64,
|
|
||||||
pub solve_states_budget: u64,
|
|
||||||
}
|
|
||||||
impl<C> SessionConfig<C> {
|
|
||||||
fn new_default(inner: C) -> Self {
|
|
||||||
Self {
|
|
||||||
inner,
|
|
||||||
undo_penalty: -15,
|
|
||||||
solve_moves_budget: 100_000,
|
|
||||||
solve_states_budget: 100_000,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl<C: Default> Default for SessionConfig<C> {
|
|
||||||
fn default() -> Self {
|
|
||||||
Self::new_default(C::default())
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
#[derive(Clone, Debug)]
|
|
||||||
pub struct Session<G: Game> {
|
pub struct Session<G: Game> {
|
||||||
stats: SessionStats<G::Stats>,
|
stats: SessionStats<G::Stats>,
|
||||||
config: SessionConfig<G::Config>,
|
config: G::Config,
|
||||||
state: SessionState<G>,
|
state: SessionState<G>,
|
||||||
}
|
}
|
||||||
#[derive(Clone, Debug)]
|
#[derive(Clone, Eq, Hash, PartialEq)]
|
||||||
#[cfg_attr(
|
|
||||||
feature = "serde",
|
|
||||||
derive(serde_derive::Deserialize, serde_derive::Serialize)
|
|
||||||
)]
|
|
||||||
pub struct StateSnapshot<G: Game> {
|
|
||||||
state: G,
|
|
||||||
instruction: G::Instruction,
|
|
||||||
}
|
|
||||||
impl<G: Game> StateSnapshot<G> {
|
|
||||||
pub const fn state(&self) -> &G {
|
|
||||||
&self.state
|
|
||||||
}
|
|
||||||
pub const fn instruction(&self) -> &G::Instruction {
|
|
||||||
&self.instruction
|
|
||||||
}
|
|
||||||
}
|
|
||||||
#[derive(Clone, Debug)]
|
|
||||||
pub struct SessionState<G: Game> {
|
pub struct SessionState<G: Game> {
|
||||||
|
seed: G,
|
||||||
state: G,
|
state: G,
|
||||||
history: Vec<StateSnapshot<G>>,
|
history: Vec<G::Instruction>,
|
||||||
}
|
}
|
||||||
impl<G: Game + Clone> SessionState<G> {
|
impl<G: Game> Session<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
|
where
|
||||||
G: Eq + core::hash::Hash,
|
G: Clone + Eq + core::hash::Hash,
|
||||||
G::Stats: Default,
|
G::Stats: Clone + Default,
|
||||||
G::Instruction: Eq + core::hash::Hash,
|
G::Instruction: Clone + Eq + core::hash::Hash,
|
||||||
{
|
{
|
||||||
pub fn new(state: G, config: SessionConfig<G::Config>) -> Self {
|
pub fn new(state: G, stats: G::Stats, config: G::Config) -> Self {
|
||||||
Self {
|
Self {
|
||||||
stats: SessionStats::default(),
|
stats: SessionStats {
|
||||||
|
inner_stats: stats,
|
||||||
|
undos: 0,
|
||||||
|
},
|
||||||
config,
|
config,
|
||||||
state: SessionState::new(state),
|
state: SessionState {
|
||||||
|
seed: state.clone(),
|
||||||
|
state,
|
||||||
|
history: Vec::new(),
|
||||||
|
},
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
pub fn new_default(state: G) -> Self
|
pub fn new_default(state: G) -> Self
|
||||||
where
|
where
|
||||||
G::Config: Default,
|
G::Config: Default,
|
||||||
{
|
{
|
||||||
Self::new(state, Default::default())
|
Self::new(state, Default::default(), Default::default())
|
||||||
}
|
}
|
||||||
pub const fn stats(&self) -> &SessionStats<G::Stats> {
|
pub const fn state(&self) -> &G {
|
||||||
&self.stats
|
&self.state.state
|
||||||
}
|
}
|
||||||
pub const fn state(&self) -> &SessionState<G> {
|
pub const fn config(&self) -> &G::Config {
|
||||||
&self.state
|
|
||||||
}
|
|
||||||
pub const fn config(&self) -> &SessionConfig<G::Config> {
|
|
||||||
&self.config
|
&self.config
|
||||||
}
|
}
|
||||||
pub fn history(&self) -> &[StateSnapshot<G>] {
|
pub fn history(&self) -> &[G::Instruction] {
|
||||||
&self.state.history
|
&self.state.history
|
||||||
}
|
}
|
||||||
pub fn undo(&mut self) {
|
pub fn undo(&mut self) {
|
||||||
@@ -546,83 +306,72 @@ where
|
|||||||
.process_instruction(&mut self.stats, &self.config, SessionInstruction::Undo)
|
.process_instruction(&mut self.stats, &self.config, SessionInstruction::Undo)
|
||||||
}
|
}
|
||||||
pub fn possible_instructions(&self) -> impl Iterator<Item = G::Instruction> + use<G> {
|
pub fn possible_instructions(&self) -> impl Iterator<Item = G::Instruction> + use<G> {
|
||||||
self.state.state.possible_instructions(&self.config.inner)
|
self.state.state.possible_instructions()
|
||||||
}
|
}
|
||||||
pub fn process_instruction(&mut self, instruction: G::Instruction) {
|
pub fn process_instruction(&mut self, instruction: G::Instruction) {
|
||||||
self.state.process_instruction(
|
self.state
|
||||||
&mut self.stats,
|
.state
|
||||||
&self.config,
|
.process_instruction(&mut self.stats.inner_stats, &self.config, instruction)
|
||||||
SessionInstruction::InnerInstruction(instruction),
|
|
||||||
)
|
|
||||||
}
|
}
|
||||||
pub fn is_win(&self) -> bool {
|
pub fn is_win(&self) -> bool {
|
||||||
self.state.is_win()
|
self.state.is_win()
|
||||||
}
|
}
|
||||||
/// Attempt to produce a solution.
|
pub fn is_winnable(&self) -> Option<Vec<G::Instruction>> {
|
||||||
pub fn solve(&self) -> Result<Option<Solution<G>>, SolveError> {
|
let mut observed = std::collections::HashSet::new();
|
||||||
let mut state_moves = std::collections::HashMap::new();
|
struct StateMachine<G, P, I> {
|
||||||
let mut session = self.clone();
|
state: G,
|
||||||
let mut moves = 0;
|
possible_instructions_iter: P,
|
||||||
while !session.is_win() {
|
instruction: I,
|
||||||
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 {
|
let mut dummy_stats = self.stats.inner_stats.clone();
|
||||||
solution: session.state.history,
|
let mut state = self.state.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(&mut dummy_stats, &self.config, 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())
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
impl<G: Game<Score = i32>> Game for SessionState<G>
|
impl<G: Game> Game for SessionState<G>
|
||||||
where
|
where
|
||||||
|
G: Clone,
|
||||||
|
G::Instruction: Clone,
|
||||||
G::Stats: Default,
|
G::Stats: Default,
|
||||||
{
|
{
|
||||||
type Score = G::Score;
|
|
||||||
type Stats = SessionStats<G::Stats>;
|
type Stats = SessionStats<G::Stats>;
|
||||||
type Config = SessionConfig<G::Config>;
|
type Config = G::Config;
|
||||||
type Instruction = SessionInstruction<G::Instruction>;
|
type Instruction = SessionInstruction<G::Instruction>;
|
||||||
fn score(&self, stats: &Self::Stats, config: &Self::Config) -> Self::Score {
|
fn possible_instructions(&self) -> impl Iterator<Item = Self::Instruction> + use<G> {
|
||||||
self.state.score(&stats.inner, &config.inner) + stats.undos as i32 * config.undo_penalty
|
|
||||||
}
|
|
||||||
fn possible_instructions(
|
|
||||||
&self,
|
|
||||||
config: &Self::Config,
|
|
||||||
) -> impl Iterator<Item = Self::Instruction> + use<G> {
|
|
||||||
self.state
|
self.state
|
||||||
.possible_instructions(&config.inner)
|
.possible_instructions()
|
||||||
.map(SessionInstruction::InnerInstruction)
|
.map(SessionInstruction::InnerInstruction)
|
||||||
}
|
}
|
||||||
fn is_instruction_valid(&self, config: &Self::Config, instruction: Self::Instruction) -> bool {
|
fn is_instruction_valid(&self, config: &Self::Config, instruction: Self::Instruction) -> bool {
|
||||||
match instruction {
|
match instruction {
|
||||||
SessionInstruction::Undo => !self.history.is_empty(),
|
SessionInstruction::Undo => !self.history.is_empty(),
|
||||||
SessionInstruction::InnerInstruction(instruction) => {
|
SessionInstruction::InnerInstruction(instruction) => {
|
||||||
self.state.is_instruction_valid(&config.inner, instruction)
|
self.state.is_instruction_valid(config, instruction)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -634,18 +383,21 @@ where
|
|||||||
) {
|
) {
|
||||||
match instruction {
|
match instruction {
|
||||||
SessionInstruction::Undo => {
|
SessionInstruction::Undo => {
|
||||||
if let Some(snapshot) = self.history.pop() {
|
// replay the entire history of the game except one move
|
||||||
self.state = snapshot.state;
|
self.history.pop();
|
||||||
stats.increment_undos();
|
let mut inner_stats = G::Stats::default();
|
||||||
|
let mut state = self.seed.clone();
|
||||||
|
for instruction in &self.history {
|
||||||
|
state.process_instruction(&mut inner_stats, config, instruction.clone());
|
||||||
}
|
}
|
||||||
|
self.state = state;
|
||||||
|
stats.inner_stats = inner_stats;
|
||||||
|
stats.increment_undos();
|
||||||
}
|
}
|
||||||
SessionInstruction::InnerInstruction(instruction) => {
|
SessionInstruction::InnerInstruction(instruction) => {
|
||||||
self.history.push(StateSnapshot {
|
self.history.push(instruction.clone());
|
||||||
state: self.state.clone(),
|
|
||||||
instruction: instruction.clone(),
|
|
||||||
});
|
|
||||||
self.state
|
self.state
|
||||||
.process_instruction(&mut stats.inner, &config.inner, instruction);
|
.process_instruction(&mut stats.inner_stats, config, instruction);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -653,95 +405,3 @@ where
|
|||||||
self.state.is_win()
|
self.state.is_win()
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
#[cfg(feature = "serde")]
|
|
||||||
impl<'de, G: Game<Score = i32>> serde::de::Deserialize<'de> for Session<G>
|
|
||||||
where
|
|
||||||
G: serde::Deserialize<'de> + Clone + Eq + core::hash::Hash,
|
|
||||||
G::Stats: Default,
|
|
||||||
G::Instruction: serde::Deserialize<'de> + Eq + core::hash::Hash,
|
|
||||||
SessionConfig<G::Config>: serde::Deserialize<'de>,
|
|
||||||
Vec<G::Instruction>: serde::Deserialize<'de>,
|
|
||||||
{
|
|
||||||
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
|
|
||||||
where
|
|
||||||
D: serde::Deserializer<'de>,
|
|
||||||
{
|
|
||||||
#[derive(serde_derive::Deserialize)]
|
|
||||||
#[serde(bound(deserialize = "
|
|
||||||
G: serde::Deserialize<'de>,
|
|
||||||
SessionConfig<G::Config>: serde::Deserialize<'de>,
|
|
||||||
Vec<G::Instruction>: serde::Deserialize<'de>,
|
|
||||||
"))]
|
|
||||||
struct SerializedSession<G: Game> {
|
|
||||||
config: SessionConfig<G::Config>,
|
|
||||||
initial_state: G,
|
|
||||||
instructions: Vec<G::Instruction>,
|
|
||||||
}
|
|
||||||
let serialized = SerializedSession::deserialize(deserializer)?;
|
|
||||||
let mut session = Session::new(serialized.initial_state, serialized.config);
|
|
||||||
for instruction in serialized.instructions {
|
|
||||||
session.process_instruction(instruction);
|
|
||||||
}
|
|
||||||
Ok(session)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
#[cfg(feature = "serde")]
|
|
||||||
impl<G: Game> serde::Serialize for Session<G>
|
|
||||||
where
|
|
||||||
G: serde::Serialize,
|
|
||||||
G::Config: serde::Serialize,
|
|
||||||
G::Instruction: serde::Serialize,
|
|
||||||
{
|
|
||||||
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
|
|
||||||
where
|
|
||||||
S: serde::Serializer,
|
|
||||||
{
|
|
||||||
struct History<'a, G: Game>(&'a [StateSnapshot<G>]);
|
|
||||||
impl<G: Game> serde::Serialize for History<'_, G>
|
|
||||||
where
|
|
||||||
G: serde::Serialize,
|
|
||||||
G::Instruction: serde::Serialize,
|
|
||||||
{
|
|
||||||
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
|
|
||||||
where
|
|
||||||
S: serde::Serializer,
|
|
||||||
{
|
|
||||||
let &History(history) = self;
|
|
||||||
use serde::ser::SerializeSeq;
|
|
||||||
let mut seq = serializer.serialize_seq(Some(history.len()))?;
|
|
||||||
for snapshot in history {
|
|
||||||
seq.serialize_element(&snapshot.instruction)?;
|
|
||||||
}
|
|
||||||
seq.end()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[derive(serde_derive::Serialize)]
|
|
||||||
#[serde(bound(serialize = "
|
|
||||||
G: serde::Serialize,
|
|
||||||
SessionConfig<G::Config>: serde::Serialize,
|
|
||||||
G::Instruction: serde::Serialize,
|
|
||||||
"))]
|
|
||||||
struct SerializedSession<'a, G: Game> {
|
|
||||||
config: &'a SessionConfig<G::Config>,
|
|
||||||
initial_state: &'a G,
|
|
||||||
instructions: History<'a, G>,
|
|
||||||
}
|
|
||||||
|
|
||||||
// serialize the initial state of the game.
|
|
||||||
// if there is history, it is the first snapshot's state,
|
|
||||||
// otherwise it is the current game state since there are no moves.
|
|
||||||
let initial_state = if let Some(snapshot) = self.state.history.first() {
|
|
||||||
snapshot.state()
|
|
||||||
} else {
|
|
||||||
&self.state.state
|
|
||||||
};
|
|
||||||
let session = SerializedSession {
|
|
||||||
config: &self.config,
|
|
||||||
initial_state,
|
|
||||||
instructions: History(&self.state.history),
|
|
||||||
};
|
|
||||||
session.serialize(serializer)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|||||||
@@ -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);
|
|
||||||
}
|
|
||||||
@@ -4,9 +4,5 @@ version = "0.1.0"
|
|||||||
edition = "2024"
|
edition = "2024"
|
||||||
|
|
||||||
[dependencies]
|
[dependencies]
|
||||||
card_game.workspace = true
|
card_game = { version = "0.1.0", path = "../card_game" }
|
||||||
klondike.workspace = true
|
klondike = { version = "0.1.0", path = "../klondike" }
|
||||||
rand = { version = "0.10.1", default-features = false, features = ["thread_rng"] }
|
|
||||||
|
|
||||||
[lints]
|
|
||||||
workspace = true
|
|
||||||
|
|||||||
+79
-90
@@ -1,4 +1,4 @@
|
|||||||
use card_game::{Card, Game, Pile, Rank, Session, Suit};
|
use card_game::{Card, CardValue, Game, Pile, Session, Suit};
|
||||||
use klondike::{
|
use klondike::{
|
||||||
DstFoundation, DstTableau, Foundation, Klondike, KlondikeConfig, KlondikeInstruction,
|
DstFoundation, DstTableau, Foundation, Klondike, KlondikeConfig, KlondikeInstruction,
|
||||||
KlondikePile, KlondikePileStack, SkipCards, Tableau, TableauStack,
|
KlondikePile, KlondikePileStack, SkipCards, Tableau, TableauStack,
|
||||||
@@ -9,12 +9,12 @@ struct Displayed<T>(T);
|
|||||||
|
|
||||||
impl Display for Displayed<&Card> {
|
impl Display for Displayed<&Card> {
|
||||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||||
match self.0.rank() {
|
match self.0.value().get() {
|
||||||
Rank::Ace => write!(f, " A"),
|
1 => write!(f, "A"),
|
||||||
Rank::Jack => write!(f, " J"),
|
11 => write!(f, "J"),
|
||||||
Rank::Queen => write!(f, " Q"),
|
12 => write!(f, "Q"),
|
||||||
Rank::King => write!(f, " K"),
|
13 => write!(f, "K"),
|
||||||
other => write!(f, "{:>2}", other as u8),
|
other => write!(f, "{other}"),
|
||||||
}?;
|
}?;
|
||||||
match self.0.suit() {
|
match self.0.suit() {
|
||||||
Suit::Spades => write!(f, "♠"),
|
Suit::Spades => write!(f, "♠"),
|
||||||
@@ -30,7 +30,7 @@ impl Display for OptionalCard<'_> {
|
|||||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||||
match self {
|
match self {
|
||||||
&OptionalCard(Some(card)) => write!(f, "{}", Displayed(card)),
|
&OptionalCard(Some(card)) => write!(f, "{}", Displayed(card)),
|
||||||
OptionalCard(None) => write!(f, " []"),
|
OptionalCard(None) => write!(f, "None"),
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -39,17 +39,16 @@ impl Display for Displayed<&Klondike> {
|
|||||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||||
// Stock
|
// Stock
|
||||||
let stock_count = self.0.state().stock().face_down().len();
|
let stock_count = self.0.state().stock().face_down().len();
|
||||||
|
writeln!(f, "Stock: {stock_count}")?;
|
||||||
|
|
||||||
// Hand
|
// Hand
|
||||||
let hand = self.0.state().stock().face_up().last();
|
let hand = self.0.state().stock().face_up().last();
|
||||||
|
writeln!(f, "Hand: {}", OptionalCard(hand))?;
|
||||||
|
|
||||||
// Foundations
|
// Foundations
|
||||||
writeln!(f, " STOCK F1 F2 F3 F4")?;
|
|
||||||
write!(
|
write!(
|
||||||
f,
|
f,
|
||||||
" {:>2} {} {} {} {} {}",
|
"Foundations: {} {} {} {}",
|
||||||
stock_count,
|
|
||||||
OptionalCard(hand),
|
|
||||||
OptionalCard(self.0.state().foundation1().last()),
|
OptionalCard(self.0.state().foundation1().last()),
|
||||||
OptionalCard(self.0.state().foundation2().last()),
|
OptionalCard(self.0.state().foundation2().last()),
|
||||||
OptionalCard(self.0.state().foundation3().last()),
|
OptionalCard(self.0.state().foundation3().last()),
|
||||||
@@ -57,68 +56,33 @@ impl Display for Displayed<&Klondike> {
|
|||||||
)?;
|
)?;
|
||||||
writeln!(f)?;
|
writeln!(f)?;
|
||||||
|
|
||||||
writeln!(f, " T1 T2 T3 T4 T5 T6 T7")?;
|
fn write_pile<const DN: usize, const UP: usize>(
|
||||||
|
|
||||||
fn write_pile_card<const DN: usize, const UP: usize>(
|
|
||||||
f: &mut std::fmt::Formatter<'_>,
|
f: &mut std::fmt::Formatter<'_>,
|
||||||
pile: &Pile<DN, UP>,
|
pile: &Pile<DN, UP>,
|
||||||
row: usize,
|
pile_id: usize,
|
||||||
) -> std::fmt::Result {
|
) -> std::fmt::Result {
|
||||||
if let Some(_card) = pile.face_down().get(row) {
|
write!(f, "T{} ", pile_id)?;
|
||||||
return write!(f, " ⎾⏋"); // └┘ ⨽⨼ ⫭⫬
|
for _ in pile.face_down() {
|
||||||
|
write!(f, "]")?;
|
||||||
}
|
}
|
||||||
let Some(row) = row.checked_sub(pile.face_down().len()) else {
|
for card in pile.face_up() {
|
||||||
return write!(f, " ");
|
write!(f, "{}", Displayed(card))?;
|
||||||
};
|
|
||||||
if let Some(card) = pile.face_up().get(row) {
|
|
||||||
return write!(f, "{}", Displayed(card));
|
|
||||||
}
|
}
|
||||||
write!(f, " ")
|
writeln!(f)?;
|
||||||
}
|
Ok(())
|
||||||
|
|
||||||
fn write_row(
|
|
||||||
f: &mut std::fmt::Formatter<'_>,
|
|
||||||
game: &Klondike,
|
|
||||||
row: usize,
|
|
||||||
) -> std::fmt::Result {
|
|
||||||
write_pile_card(f, game.state().tableau1(), row)?;
|
|
||||||
write!(f, " ")?;
|
|
||||||
write_pile_card(f, game.state().tableau2(), row)?;
|
|
||||||
write!(f, " ")?;
|
|
||||||
write_pile_card(f, game.state().tableau3(), row)?;
|
|
||||||
write!(f, " ")?;
|
|
||||||
write_pile_card(f, game.state().tableau4(), row)?;
|
|
||||||
write!(f, " ")?;
|
|
||||||
write_pile_card(f, game.state().tableau5(), row)?;
|
|
||||||
write!(f, " ")?;
|
|
||||||
write_pile_card(f, game.state().tableau6(), row)?;
|
|
||||||
write!(f, " ")?;
|
|
||||||
write_pile_card(f, game.state().tableau7(), row)?;
|
|
||||||
writeln!(f)
|
|
||||||
}
|
|
||||||
|
|
||||||
for row in 0..7 + 13 {
|
|
||||||
write_row(f, self.0, row)?;
|
|
||||||
}
|
}
|
||||||
|
write_pile(f, self.0.state().tableau1(), 1)?;
|
||||||
|
write_pile(f, self.0.state().tableau2(), 2)?;
|
||||||
|
write_pile(f, self.0.state().tableau3(), 3)?;
|
||||||
|
write_pile(f, self.0.state().tableau4(), 4)?;
|
||||||
|
write_pile(f, self.0.state().tableau5(), 5)?;
|
||||||
|
write_pile(f, self.0.state().tableau6(), 6)?;
|
||||||
|
write_pile(f, self.0.state().tableau7(), 7)?;
|
||||||
|
|
||||||
Ok(())
|
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)]
|
#[derive(Debug)]
|
||||||
struct Invalid;
|
struct Invalid;
|
||||||
struct Parsed<T>(T);
|
struct Parsed<T>(T);
|
||||||
@@ -232,23 +196,57 @@ fn find_valid_instruction(
|
|||||||
.then_some(instruction)
|
.then_some(instruction)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
fn get_good_move(state: &Klondike) -> Option<KlondikeInstruction> {
|
||||||
|
fn useless_moves(instruction: &KlondikeInstruction) -> bool {
|
||||||
|
!matches!(
|
||||||
|
instruction,
|
||||||
|
// foundation -> foundation is a useless move
|
||||||
|
KlondikeInstruction::DstFoundation(DstFoundation {
|
||||||
|
src: KlondikePile::Foundation(_),
|
||||||
|
..
|
||||||
|
})
|
||||||
|
)
|
||||||
|
}
|
||||||
|
fn instruction_priority(state: &Klondike, 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 !state.state().is_tableau_face_down_empty(tableau)
|
||||||
|
|| state
|
||||||
|
.state()
|
||||||
|
.stack_bottom_card(dst_tableau.src)
|
||||||
|
.is_some_and(|card| card.value() != CardValue::KING) =>
|
||||||
|
{
|
||||||
|
2
|
||||||
|
}
|
||||||
|
KlondikePileStack::Stock => 3,
|
||||||
|
KlondikePileStack::Tableau(_) => 5,
|
||||||
|
KlondikePileStack::Foundation(_) => 6,
|
||||||
|
},
|
||||||
|
KlondikeInstruction::RotateStock => 4,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
state
|
||||||
|
.possible_instructions()
|
||||||
|
.filter(useless_moves)
|
||||||
|
.min_by_key(|ins| instruction_priority(state, ins))
|
||||||
|
}
|
||||||
|
|
||||||
fn main() -> Result<(), std::io::Error> {
|
fn main() -> Result<(), std::io::Error> {
|
||||||
use rand::RngExt;
|
let mut session = Session::new_default(Klondike::new_random());
|
||||||
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 input = String::new();
|
||||||
loop {
|
loop {
|
||||||
// display stats
|
|
||||||
println!("seed: {seed} ");
|
|
||||||
println!("{}", DisplayStats(&session));
|
|
||||||
// display game
|
// display game
|
||||||
println!("{}", Displayed(session.state().state()));
|
println!("{}", Displayed(session.state()));
|
||||||
|
|
||||||
// parse input
|
// parse input
|
||||||
input.clear();
|
input.clear();
|
||||||
@@ -260,10 +258,7 @@ fn main() -> Result<(), std::io::Error> {
|
|||||||
|
|
||||||
// run game
|
// run game
|
||||||
match instruction {
|
match instruction {
|
||||||
SessionInstruction::New => {
|
SessionInstruction::New => session = Session::new_default(Klondike::new_random()),
|
||||||
seed = rng.random();
|
|
||||||
session = Session::new_default(Klondike::with_seed(seed))
|
|
||||||
}
|
|
||||||
SessionInstruction::Undo => session.undo(),
|
SessionInstruction::Undo => session.undo(),
|
||||||
SessionInstruction::Exit => break Ok(()),
|
SessionInstruction::Exit => break Ok(()),
|
||||||
SessionInstruction::Hint => {
|
SessionInstruction::Hint => {
|
||||||
@@ -272,11 +267,7 @@ fn main() -> Result<(), std::io::Error> {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
SessionInstruction::Auto => {
|
SessionInstruction::Auto => {
|
||||||
if let Some(instruction) = session
|
if let Some(instruction) = get_good_move(session.state()) {
|
||||||
.state()
|
|
||||||
.state()
|
|
||||||
.get_auto_move(&session.config().inner)
|
|
||||||
{
|
|
||||||
session.process_instruction(instruction);
|
session.process_instruction(instruction);
|
||||||
} else {
|
} else {
|
||||||
println!("No valid moves!");
|
println!("No valid moves!");
|
||||||
@@ -286,11 +277,9 @@ fn main() -> Result<(), std::io::Error> {
|
|||||||
session.process_instruction(KlondikeInstruction::RotateStock)
|
session.process_instruction(KlondikeInstruction::RotateStock)
|
||||||
}
|
}
|
||||||
SessionInstruction::Klondike(naive_instruction) => {
|
SessionInstruction::Klondike(naive_instruction) => {
|
||||||
if let Some(instruction) = find_valid_instruction(
|
if let Some(instruction) =
|
||||||
&session.config().inner,
|
find_valid_instruction(session.config(), session.state(), naive_instruction)
|
||||||
session.state().state(),
|
{
|
||||||
naive_instruction,
|
|
||||||
) {
|
|
||||||
session.process_instruction(instruction);
|
session.process_instruction(instruction);
|
||||||
} else {
|
} else {
|
||||||
println!("Invalid move!");
|
println!("Invalid move!");
|
||||||
|
|||||||
+3
-18
@@ -1,23 +1,8 @@
|
|||||||
[package]
|
[package]
|
||||||
name = "klondike"
|
name = "klondike"
|
||||||
version = "0.4.0"
|
version = "0.1.0"
|
||||||
edition = "2024"
|
edition = "2024"
|
||||||
|
|
||||||
[dependencies]
|
[dependencies]
|
||||||
card_game.workspace = true
|
card_game = { version = "0.1.0", path = "../card_game" }
|
||||||
rand = { version = "0.10.1", default-features = false, features = ["std_rng"] }
|
rand = { version = "0.10.1", default-features = false, features = ["thread_rng"] }
|
||||||
serde = { version = "1.0.228", default-features = false, optional = true }
|
|
||||||
serde_derive = { version = "1.0.228", default-features = false, optional = true }
|
|
||||||
|
|
||||||
[dev-dependencies]
|
|
||||||
insta = "1.47.2"
|
|
||||||
rmp-serde = "1.3.1"
|
|
||||||
serde = { version = "1.0.228", default-features = false }
|
|
||||||
serde_json = "1.0.149"
|
|
||||||
|
|
||||||
[lints]
|
|
||||||
workspace = true
|
|
||||||
|
|
||||||
[features]
|
|
||||||
default = ["serde"]
|
|
||||||
serde = ["dep:serde", "dep:serde_derive", "card_game/serde"]
|
|
||||||
|
|||||||
@@ -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.
|
|
||||||
+14
-15
@@ -1,27 +1,25 @@
|
|||||||
Klondike
|
Card Game
|
||||||
========
|
=========
|
||||||
|
|
||||||
`klondike` is a pure-logic implementation of Klondike using `card_game`. Graphics not included.
|
`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
|
## Example
|
||||||
|
|
||||||
```rust
|
```rust
|
||||||
use card_game::Session;
|
use card_game::Rng;
|
||||||
use klondike::{Klondike, KlondikeConfig};
|
use card_game::card_game::{Session, Game};
|
||||||
|
use card_game::klondike::Klondike;
|
||||||
|
|
||||||
// create game session
|
// create game session
|
||||||
let game = Klondike::with_seed(123);
|
let game = Klondike::new_random_default();
|
||||||
let config = KlondikeConfig::default();
|
let mut session = Session::new(game);
|
||||||
let mut session = Session::new_default(game);
|
|
||||||
|
|
||||||
// play game a bit
|
// is winnable
|
||||||
while let Some(instruction) = session.state().state().get_auto_move(&config) {
|
let is_winnable = session.is_winnable().is_some();
|
||||||
|
|
||||||
|
// play game
|
||||||
|
while let Some(instruction) = session.possible_instructions().next() {
|
||||||
session.process_instruction(instruction);
|
session.process_instruction(instruction);
|
||||||
|
|
||||||
// quit after 200 moves or win
|
|
||||||
if session.is_win() || 200 < session.stats().stats().moves() {
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
// did win
|
// did win
|
||||||
@@ -32,6 +30,7 @@ for (i, instruction) in session.history().iter().enumerate() {
|
|||||||
println!("move {i} = {instruction:?}");
|
println!("move {i} = {instruction:?}");
|
||||||
}
|
}
|
||||||
|
|
||||||
|
println!("is_winnable = {is_winnable}");
|
||||||
println!("is_win = {is_win}");
|
println!("is_win = {is_win}");
|
||||||
```
|
```
|
||||||
|
|
||||||
|
|||||||
+108
-396
@@ -1,6 +1,6 @@
|
|||||||
pub type Rng = rand::rngs::StdRng;
|
pub type Rng = rand::rngs::ThreadRng;
|
||||||
|
|
||||||
use card_game::{Card, Game, Pile, Rank, Stack};
|
use card_game::{Card, CardValue, Game, Pile, Stack};
|
||||||
|
|
||||||
#[cfg(test)]
|
#[cfg(test)]
|
||||||
mod test;
|
mod test;
|
||||||
@@ -10,127 +10,42 @@ mod test;
|
|||||||
#[cfg(doctest)]
|
#[cfg(doctest)]
|
||||||
struct ReadmeDoctests;
|
struct ReadmeDoctests;
|
||||||
|
|
||||||
#[cfg_attr(
|
#[derive(Clone, Copy, Debug, Default)]
|
||||||
feature = "serde",
|
enum DrawStockConfig {
|
||||||
derive(serde_derive::Deserialize, serde_derive::Serialize)
|
|
||||||
)]
|
|
||||||
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
|
|
||||||
pub enum DrawStockConfig {
|
|
||||||
#[default]
|
#[default]
|
||||||
DrawOne = 1,
|
DrawOne = 1,
|
||||||
DrawThree = 3,
|
DrawThree = 3,
|
||||||
}
|
}
|
||||||
|
|
||||||
#[cfg_attr(
|
|
||||||
feature = "serde",
|
|
||||||
derive(serde_derive::Deserialize, serde_derive::Serialize)
|
|
||||||
)]
|
|
||||||
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
|
|
||||||
pub enum MoveFromFoundationConfig {
|
|
||||||
#[default]
|
|
||||||
Allowed,
|
|
||||||
Disallowed,
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg_attr(
|
|
||||||
feature = "serde",
|
|
||||||
derive(serde_derive::Deserialize, serde_derive::Serialize)
|
|
||||||
)]
|
|
||||||
#[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
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg_attr(
|
|
||||||
feature = "serde",
|
|
||||||
derive(serde_derive::Deserialize, serde_derive::Serialize)
|
|
||||||
)]
|
|
||||||
#[derive(Clone, Debug, Default)]
|
#[derive(Clone, Debug, Default)]
|
||||||
pub struct KlondikeConfig {
|
pub struct KlondikeConfig {
|
||||||
pub draw_stock: DrawStockConfig,
|
draw_stock: DrawStockConfig,
|
||||||
pub move_from_foundation: MoveFromFoundationConfig,
|
}
|
||||||
pub scoring: ScoringConfig,
|
impl KlondikeConfig {
|
||||||
|
pub const fn draw_one_stock() -> Self {
|
||||||
|
KlondikeConfig {
|
||||||
|
draw_stock: DrawStockConfig::DrawOne,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
pub const fn draw_three_stock() -> Self {
|
||||||
|
KlondikeConfig {
|
||||||
|
draw_stock: DrawStockConfig::DrawThree,
|
||||||
|
}
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
#[derive(Clone, Debug, Default)]
|
#[derive(Clone, Debug, Default)]
|
||||||
pub struct KlondikeStats {
|
pub struct KlondikeStats {
|
||||||
moves: u32,
|
recycle_count: usize,
|
||||||
move_to_foundation_count: u32,
|
moves: usize,
|
||||||
flip_up_bonus_count: u32,
|
|
||||||
move_to_tableau_count: u32,
|
|
||||||
move_from_foundation_count: u32,
|
|
||||||
recycle_count: u32,
|
|
||||||
}
|
}
|
||||||
impl KlondikeStats {
|
impl KlondikeStats {
|
||||||
pub const fn new() -> Self {
|
pub const fn new() -> Self {
|
||||||
KlondikeStats {
|
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,
|
recycle_count: 0,
|
||||||
|
moves: 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) {
|
const fn increment_recycle_count(&mut self) {
|
||||||
self.recycle_count += 1;
|
self.recycle_count += 1;
|
||||||
}
|
}
|
||||||
@@ -164,38 +79,6 @@ impl Tableau {
|
|||||||
})
|
})
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
pub struct TableauIter {
|
|
||||||
tableau: Option<Tableau>,
|
|
||||||
}
|
|
||||||
impl TableauIter {
|
|
||||||
pub const fn new() -> Self {
|
|
||||||
Self {
|
|
||||||
tableau: Some(Tableau::ITER_BEGIN),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl Default for TableauIter {
|
|
||||||
fn default() -> Self {
|
|
||||||
Self::new()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl Iterator for TableauIter {
|
|
||||||
type Item = Tableau;
|
|
||||||
fn next(&mut self) -> Option<Self::Item> {
|
|
||||||
let tableau = self.tableau?;
|
|
||||||
self.tableau = tableau.next();
|
|
||||||
Some(tableau)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl IntoIterator for Tableau {
|
|
||||||
type Item = Self;
|
|
||||||
type IntoIter = TableauIter;
|
|
||||||
fn into_iter(self) -> Self::IntoIter {
|
|
||||||
TableauIter {
|
|
||||||
tableau: Some(self),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
|
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
|
||||||
pub enum Foundation {
|
pub enum Foundation {
|
||||||
@@ -216,38 +99,6 @@ impl Foundation {
|
|||||||
})
|
})
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
pub struct FoundationIter {
|
|
||||||
foundation: Option<Foundation>,
|
|
||||||
}
|
|
||||||
impl FoundationIter {
|
|
||||||
pub const fn new() -> Self {
|
|
||||||
Self {
|
|
||||||
foundation: Some(Foundation::ITER_BEGIN),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl Default for FoundationIter {
|
|
||||||
fn default() -> Self {
|
|
||||||
Self::new()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl Iterator for FoundationIter {
|
|
||||||
type Item = Foundation;
|
|
||||||
fn next(&mut self) -> Option<Self::Item> {
|
|
||||||
let foundation = self.foundation?;
|
|
||||||
self.foundation = foundation.next();
|
|
||||||
Some(foundation)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
impl IntoIterator for Foundation {
|
|
||||||
type Item = Self;
|
|
||||||
type IntoIter = FoundationIter;
|
|
||||||
fn into_iter(self) -> Self::IntoIter {
|
|
||||||
FoundationIter {
|
|
||||||
foundation: Some(self),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
|
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
|
||||||
pub enum KlondikePile {
|
pub enum KlondikePile {
|
||||||
@@ -282,6 +133,7 @@ impl From<Foundation> for KlondikePile {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
#[repr(u8)]
|
||||||
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
|
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
|
||||||
pub enum SkipCards {
|
pub enum SkipCards {
|
||||||
Skip0,
|
Skip0,
|
||||||
@@ -443,16 +295,6 @@ impl KlondikeInstruction {
|
|||||||
Self::RotateStock => return None,
|
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 TABLEAUS: usize = 7;
|
||||||
@@ -460,81 +302,65 @@ const fn sum(n: usize) -> usize {
|
|||||||
n * (n + 1) / 2
|
n * (n + 1) / 2
|
||||||
}
|
}
|
||||||
const STOCK: usize = 52 - sum(TABLEAUS);
|
const STOCK: usize = 52 - sum(TABLEAUS);
|
||||||
const NUM_RANKS: usize = Rank::RANKS.len();
|
|
||||||
|
|
||||||
#[cfg_attr(
|
|
||||||
feature = "serde",
|
|
||||||
derive(serde_derive::Deserialize, serde_derive::Serialize)
|
|
||||||
)]
|
|
||||||
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
|
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
|
||||||
pub struct KlondikeState {
|
pub struct KlondikeState {
|
||||||
stock: Pile<STOCK, STOCK>,
|
stock: Pile<STOCK, STOCK>,
|
||||||
foundations: [Stack<NUM_RANKS>; 4],
|
foundations: [Stack<13>; 4],
|
||||||
tableau1: Pile<0, NUM_RANKS>,
|
tableau1: Pile<0, 13>,
|
||||||
tableau2: Pile<1, NUM_RANKS>,
|
tableau2: Pile<1, 13>,
|
||||||
tableau3: Pile<2, NUM_RANKS>,
|
tableau3: Pile<2, 13>,
|
||||||
tableau4: Pile<3, NUM_RANKS>,
|
tableau4: Pile<3, 13>,
|
||||||
tableau5: Pile<4, NUM_RANKS>,
|
tableau5: Pile<4, 13>,
|
||||||
tableau6: Pile<5, NUM_RANKS>,
|
tableau6: Pile<5, 13>,
|
||||||
tableau7: Pile<6, NUM_RANKS>,
|
tableau7: Pile<6, 13>,
|
||||||
}
|
}
|
||||||
impl KlondikeState {
|
impl KlondikeState {
|
||||||
pub const fn stock(&self) -> &Pile<STOCK, STOCK> {
|
pub const fn stock(&self) -> &Pile<STOCK, STOCK> {
|
||||||
&self.stock
|
&self.stock
|
||||||
}
|
}
|
||||||
pub const fn foundation1(&self) -> &Stack<NUM_RANKS> {
|
pub const fn foundation1(&self) -> &Stack<13> {
|
||||||
&self.foundations[Foundation::Foundation1 as usize]
|
&self.foundations[Foundation::Foundation1 as usize]
|
||||||
}
|
}
|
||||||
pub const fn foundation2(&self) -> &Stack<NUM_RANKS> {
|
pub const fn foundation2(&self) -> &Stack<13> {
|
||||||
&self.foundations[Foundation::Foundation2 as usize]
|
&self.foundations[Foundation::Foundation2 as usize]
|
||||||
}
|
}
|
||||||
pub const fn foundation3(&self) -> &Stack<NUM_RANKS> {
|
pub const fn foundation3(&self) -> &Stack<13> {
|
||||||
&self.foundations[Foundation::Foundation3 as usize]
|
&self.foundations[Foundation::Foundation3 as usize]
|
||||||
}
|
}
|
||||||
pub const fn foundation4(&self) -> &Stack<NUM_RANKS> {
|
pub const fn foundation4(&self) -> &Stack<13> {
|
||||||
&self.foundations[Foundation::Foundation4 as usize]
|
&self.foundations[Foundation::Foundation4 as usize]
|
||||||
}
|
}
|
||||||
pub const fn tableau1(&self) -> &Pile<0, NUM_RANKS> {
|
pub const fn tableau1(&self) -> &Pile<0, 13> {
|
||||||
&self.tableau1
|
&self.tableau1
|
||||||
}
|
}
|
||||||
pub const fn tableau2(&self) -> &Pile<1, NUM_RANKS> {
|
pub const fn tableau2(&self) -> &Pile<1, 13> {
|
||||||
&self.tableau2
|
&self.tableau2
|
||||||
}
|
}
|
||||||
pub const fn tableau3(&self) -> &Pile<2, NUM_RANKS> {
|
pub const fn tableau3(&self) -> &Pile<2, 13> {
|
||||||
&self.tableau3
|
&self.tableau3
|
||||||
}
|
}
|
||||||
pub const fn tableau4(&self) -> &Pile<3, NUM_RANKS> {
|
pub const fn tableau4(&self) -> &Pile<3, 13> {
|
||||||
&self.tableau4
|
&self.tableau4
|
||||||
}
|
}
|
||||||
pub const fn tableau5(&self) -> &Pile<4, NUM_RANKS> {
|
pub const fn tableau5(&self) -> &Pile<4, 13> {
|
||||||
&self.tableau5
|
&self.tableau5
|
||||||
}
|
}
|
||||||
pub const fn tableau6(&self) -> &Pile<5, NUM_RANKS> {
|
pub const fn tableau6(&self) -> &Pile<5, 13> {
|
||||||
&self.tableau6
|
&self.tableau6
|
||||||
}
|
}
|
||||||
pub const fn tableau7(&self) -> &Pile<6, NUM_RANKS> {
|
pub const fn tableau7(&self) -> &Pile<6, 13> {
|
||||||
&self.tableau7
|
&self.tableau7
|
||||||
}
|
}
|
||||||
pub fn tableau_face_down_cards(&self, tableau: Tableau) -> &[Card] {
|
pub fn is_tableau_face_down_empty(&self, tableau: Tableau) -> bool {
|
||||||
match tableau {
|
match tableau {
|
||||||
Tableau::Tableau1 => self.tableau1.face_down(),
|
Tableau::Tableau1 => self.tableau1.face_down().is_empty(),
|
||||||
Tableau::Tableau2 => self.tableau2.face_down(),
|
Tableau::Tableau2 => self.tableau2.face_down().is_empty(),
|
||||||
Tableau::Tableau3 => self.tableau3.face_down(),
|
Tableau::Tableau3 => self.tableau3.face_down().is_empty(),
|
||||||
Tableau::Tableau4 => self.tableau4.face_down(),
|
Tableau::Tableau4 => self.tableau4.face_down().is_empty(),
|
||||||
Tableau::Tableau5 => self.tableau5.face_down(),
|
Tableau::Tableau5 => self.tableau5.face_down().is_empty(),
|
||||||
Tableau::Tableau6 => self.tableau6.face_down(),
|
Tableau::Tableau6 => self.tableau6.face_down().is_empty(),
|
||||||
Tableau::Tableau7 => self.tableau7.face_down(),
|
Tableau::Tableau7 => self.tableau7.face_down().is_empty(),
|
||||||
}
|
|
||||||
}
|
|
||||||
pub fn tableau_face_up_cards(&self, tableau: Tableau) -> &[Card] {
|
|
||||||
match tableau {
|
|
||||||
Tableau::Tableau1 => self.tableau1.face_up(),
|
|
||||||
Tableau::Tableau2 => self.tableau2.face_up(),
|
|
||||||
Tableau::Tableau3 => self.tableau3.face_up(),
|
|
||||||
Tableau::Tableau4 => self.tableau4.face_up(),
|
|
||||||
Tableau::Tableau5 => self.tableau5.face_up(),
|
|
||||||
Tableau::Tableau6 => self.tableau6.face_up(),
|
|
||||||
Tableau::Tableau7 => self.tableau7.face_up(),
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
pub fn stack_bottom_card(&self, src: KlondikePileStack) -> Option<&Card> {
|
pub fn stack_bottom_card(&self, src: KlondikePileStack) -> Option<&Card> {
|
||||||
@@ -542,27 +368,37 @@ impl KlondikeState {
|
|||||||
KlondikePileStack::Tableau(TableauStack {
|
KlondikePileStack::Tableau(TableauStack {
|
||||||
tableau,
|
tableau,
|
||||||
skip_cards,
|
skip_cards,
|
||||||
}) => self.tableau_face_up_cards(tableau).get(skip_cards as usize),
|
}) => match tableau {
|
||||||
|
Tableau::Tableau1 => self.tableau1.face_up().get(skip_cards as usize),
|
||||||
|
Tableau::Tableau2 => self.tableau2.face_up().get(skip_cards as usize),
|
||||||
|
Tableau::Tableau3 => self.tableau3.face_up().get(skip_cards as usize),
|
||||||
|
Tableau::Tableau4 => self.tableau4.face_up().get(skip_cards as usize),
|
||||||
|
Tableau::Tableau5 => self.tableau5.face_up().get(skip_cards as usize),
|
||||||
|
Tableau::Tableau6 => self.tableau6.face_up().get(skip_cards as usize),
|
||||||
|
Tableau::Tableau7 => self.tableau7.face_up().get(skip_cards as usize),
|
||||||
|
},
|
||||||
KlondikePileStack::Foundation(foundation) => {
|
KlondikePileStack::Foundation(foundation) => {
|
||||||
self.foundations[foundation as usize].last()
|
self.foundations[foundation as usize].last()
|
||||||
}
|
}
|
||||||
KlondikePileStack::Stock => self.stock.face_up().last(),
|
KlondikePileStack::Stock => self.stock.face_up().last(),
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
pub fn tableau_top_card(&self, tableau: Tableau) -> Option<&Card> {
|
pub fn top_card<S: Into<KlondikePile>>(&self, src: S) -> Option<&Card> {
|
||||||
self.tableau_face_up_cards(tableau).last()
|
match src.into() {
|
||||||
}
|
KlondikePile::Tableau(tableau) => match tableau {
|
||||||
pub fn foundation_top_card(&self, foundation: Foundation) -> Option<&Card> {
|
Tableau::Tableau1 => self.tableau1.face_up().last(),
|
||||||
self.foundations[foundation as usize].last()
|
Tableau::Tableau2 => self.tableau2.face_up().last(),
|
||||||
}
|
Tableau::Tableau3 => self.tableau3.face_up().last(),
|
||||||
pub fn top_card(&self, pile: KlondikePile) -> Option<&Card> {
|
Tableau::Tableau4 => self.tableau4.face_up().last(),
|
||||||
match pile {
|
Tableau::Tableau5 => self.tableau5.face_up().last(),
|
||||||
KlondikePile::Tableau(tableau) => self.tableau_top_card(tableau),
|
Tableau::Tableau6 => self.tableau6.face_up().last(),
|
||||||
KlondikePile::Foundation(foundation) => self.foundation_top_card(foundation),
|
Tableau::Tableau7 => self.tableau7.face_up().last(),
|
||||||
|
},
|
||||||
|
KlondikePile::Foundation(foundation) => self.foundations[foundation as usize].last(),
|
||||||
KlondikePile::Stock => self.stock.face_up().last(),
|
KlondikePile::Stock => self.stock.face_up().last(),
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
fn take_stack_flip_up(&mut self, src: KlondikePileStack) -> (Stack<NUM_RANKS>, bool) {
|
fn take_stack(&mut self, src: KlondikePileStack) -> Stack<13> {
|
||||||
match src {
|
match src {
|
||||||
KlondikePileStack::Tableau(TableauStack {
|
KlondikePileStack::Tableau(TableauStack {
|
||||||
tableau,
|
tableau,
|
||||||
@@ -576,15 +412,14 @@ impl KlondikeState {
|
|||||||
Tableau::Tableau6 => self.tableau6.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..),
|
Tableau::Tableau7 => self.tableau7.take_range_flip_up(skip_cards as usize..),
|
||||||
},
|
},
|
||||||
KlondikePileStack::Foundation(foundation) => (
|
KlondikePileStack::Foundation(foundation) => {
|
||||||
Stack::from_iter(self.foundations[foundation as usize].pop()),
|
Stack::from_iter(self.foundations[foundation as usize].pop())
|
||||||
false,
|
}
|
||||||
),
|
KlondikePileStack::Stock => Stack::from_iter(self.stock.pop()),
|
||||||
KlondikePileStack::Stock => (Stack::from_iter(self.stock.pop()), false),
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
fn take_top_card_flip_up(&mut self, pile: KlondikePile) -> (Option<Card>, bool) {
|
fn take_top_card<S: Into<KlondikePile>>(&mut self, src: S) -> Option<Card> {
|
||||||
match pile {
|
match src.into() {
|
||||||
KlondikePile::Tableau(tableau) => match tableau {
|
KlondikePile::Tableau(tableau) => match tableau {
|
||||||
Tableau::Tableau1 => self.tableau1.pop_flip_up(),
|
Tableau::Tableau1 => self.tableau1.pop_flip_up(),
|
||||||
Tableau::Tableau2 => self.tableau2.pop_flip_up(),
|
Tableau::Tableau2 => self.tableau2.pop_flip_up(),
|
||||||
@@ -594,10 +429,8 @@ impl KlondikeState {
|
|||||||
Tableau::Tableau6 => self.tableau6.pop_flip_up(),
|
Tableau::Tableau6 => self.tableau6.pop_flip_up(),
|
||||||
Tableau::Tableau7 => self.tableau7.pop_flip_up(),
|
Tableau::Tableau7 => self.tableau7.pop_flip_up(),
|
||||||
},
|
},
|
||||||
KlondikePile::Foundation(foundation) => {
|
KlondikePile::Foundation(foundation) => self.foundations[foundation as usize].pop(),
|
||||||
(self.foundations[foundation as usize].pop(), false)
|
KlondikePile::Stock => self.stock.pop(),
|
||||||
}
|
|
||||||
KlondikePile::Stock => (self.stock.pop(), false),
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
fn extend_foundation<I: IntoIterator<Item = Card>>(
|
fn extend_foundation<I: IntoIterator<Item = Card>>(
|
||||||
@@ -618,11 +451,7 @@ impl KlondikeState {
|
|||||||
Tableau::Tableau7 => self.tableau7.extend(cards),
|
Tableau::Tableau7 => self.tableau7.extend(cards),
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
pub fn is_instruction_valid(
|
pub fn is_instruction_valid(&self, instruction: KlondikeInstruction) -> bool {
|
||||||
&self,
|
|
||||||
config: &KlondikeConfig,
|
|
||||||
instruction: KlondikeInstruction,
|
|
||||||
) -> bool {
|
|
||||||
match instruction {
|
match instruction {
|
||||||
// Stock -> Stock draws a card or resets the stock
|
// Stock -> Stock draws a card or resets the stock
|
||||||
KlondikeInstruction::RotateStock => {
|
KlondikeInstruction::RotateStock => {
|
||||||
@@ -634,16 +463,16 @@ impl KlondikeState {
|
|||||||
KlondikeInstruction::DstFoundation(dst_foundation) => {
|
KlondikeInstruction::DstFoundation(dst_foundation) => {
|
||||||
// get the top cards
|
// get the top cards
|
||||||
if let Some(src_card) = self.top_card(dst_foundation.src) {
|
if let Some(src_card) = self.top_card(dst_foundation.src) {
|
||||||
match self.foundation_top_card(dst_foundation.foundation) {
|
match self.top_card(dst_foundation.foundation) {
|
||||||
// destination card exists
|
// destination card exists
|
||||||
Some(dst_card) => {
|
Some(dst_card) => {
|
||||||
// suit matches?
|
// suit matches?
|
||||||
src_card.suit() == dst_card.suit()
|
src_card.suit() == dst_card.suit()
|
||||||
// value is +1?
|
// value is +1?
|
||||||
&& dst_card.rank().checked_add(1) == Some(src_card.rank())
|
&& dst_card.value().checked_add(1) == Some(src_card.value())
|
||||||
}
|
}
|
||||||
// only ace is allowed to go onto empty foundation
|
// only ace is allowed to go onto empty foundation
|
||||||
None => src_card.rank() == Rank::Ace,
|
None => src_card.value() == CardValue::ACE,
|
||||||
}
|
}
|
||||||
} else {
|
} else {
|
||||||
false
|
false
|
||||||
@@ -651,23 +480,18 @@ impl KlondikeState {
|
|||||||
}
|
}
|
||||||
// other = move to tableau
|
// other = move to tableau
|
||||||
KlondikeInstruction::DstTableau(dst_tableau) => {
|
KlondikeInstruction::DstTableau(dst_tableau) => {
|
||||||
if config.move_from_foundation == MoveFromFoundationConfig::Disallowed
|
|
||||||
&& let KlondikePileStack::Foundation(_) = dst_tableau.src
|
|
||||||
{
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
// get the cards
|
// get the cards
|
||||||
if let Some(src_card) = self.stack_bottom_card(dst_tableau.src) {
|
if let Some(src_card) = self.stack_bottom_card(dst_tableau.src) {
|
||||||
match self.tableau_top_card(dst_tableau.tableau) {
|
match self.top_card(dst_tableau.tableau) {
|
||||||
// destination card exists
|
// destination card exists
|
||||||
Some(dst_card) => {
|
Some(dst_card) => {
|
||||||
// red-ness is opposite?
|
// red-ness is opposite?
|
||||||
src_card.is_red() != dst_card.is_red()
|
src_card.is_red() != dst_card.is_red()
|
||||||
// value is -1?
|
// value is -1?
|
||||||
&& dst_card.rank().checked_sub(1) == Some(src_card.rank())
|
&& dst_card.value().checked_sub(1) == Some(src_card.value())
|
||||||
}
|
}
|
||||||
// only king is allowed to go onto empty tableau
|
// only king is allowed to go onto empty tableau
|
||||||
None => src_card.rank() == Rank::King,
|
None => src_card.value() == CardValue::KING,
|
||||||
}
|
}
|
||||||
} else {
|
} else {
|
||||||
false
|
false
|
||||||
@@ -695,37 +519,24 @@ impl Iterator for KlondikeIter {
|
|||||||
instruction
|
instruction
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
#[test]
|
|
||||||
fn test_klondike_iter() {
|
|
||||||
assert_eq!(KlondikeIter::new().count(), 721);
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg_attr(
|
|
||||||
feature = "serde",
|
|
||||||
derive(serde_derive::Deserialize, serde_derive::Serialize),
|
|
||||||
serde(transparent)
|
|
||||||
)]
|
|
||||||
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
|
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
|
||||||
pub struct Klondike {
|
pub struct Klondike {
|
||||||
state: KlondikeState,
|
state: KlondikeState,
|
||||||
}
|
}
|
||||||
impl Klondike {
|
impl Klondike {
|
||||||
pub fn with_seed(seed: u64) -> Self {
|
pub fn new_random() -> Self {
|
||||||
use rand::SeedableRng;
|
Self::new(Rng::default())
|
||||||
let mut rng = Rng::seed_from_u64(seed);
|
|
||||||
Self::with_rng(&mut rng)
|
|
||||||
}
|
}
|
||||||
pub fn with_rng(rng: &mut Rng) -> Self {
|
pub fn new(mut seed: Rng) -> Self {
|
||||||
// shuffle a new deck
|
// shuffle a new deck
|
||||||
let mut deck = Stack::full_deck(card_game::Deck::Deck1);
|
let mut deck = Stack::full_deck(0);
|
||||||
use rand::seq::SliceRandom;
|
use rand::seq::SliceRandom;
|
||||||
deck.shuffle(rng);
|
deck.shuffle(&mut seed);
|
||||||
let mut deck = deck.into_iter();
|
let mut deck = deck.into_iter();
|
||||||
|
|
||||||
// generate tableaus
|
// generate tableaus
|
||||||
fn pile<const DN: usize>(
|
fn pile<const DN: usize>(deck: &mut <Stack<52> as IntoIterator>::IntoIter) -> Pile<DN, 13> {
|
||||||
deck: &mut <Stack<52> as IntoIterator>::IntoIter,
|
|
||||||
) -> Pile<DN, NUM_RANKS> {
|
|
||||||
let stack = Stack::from_iter(deck.take(DN));
|
let stack = Stack::from_iter(deck.take(DN));
|
||||||
let mut pile = Pile::new_face_down(stack);
|
let mut pile = Pile::new_face_down(stack);
|
||||||
pile.push(deck.next().unwrap());
|
pile.push(deck.next().unwrap());
|
||||||
@@ -758,82 +569,18 @@ impl Klondike {
|
|||||||
pub const fn state(&self) -> &KlondikeState {
|
pub const fn state(&self) -> &KlondikeState {
|
||||||
&self.state
|
&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 {
|
impl Game for Klondike {
|
||||||
type Score = i32;
|
|
||||||
type Stats = KlondikeStats;
|
type Stats = KlondikeStats;
|
||||||
type Config = KlondikeConfig;
|
type Config = KlondikeConfig;
|
||||||
type Instruction = KlondikeInstruction;
|
type Instruction = KlondikeInstruction;
|
||||||
fn score(&self, stats: &Self::Stats, config: &Self::Config) -> Self::Score {
|
fn possible_instructions(&self) -> impl Iterator<Item = Self::Instruction> + use<> {
|
||||||
stats.score(&config.scoring)
|
|
||||||
}
|
|
||||||
fn possible_instructions(
|
|
||||||
&self,
|
|
||||||
config: &Self::Config,
|
|
||||||
) -> impl Iterator<Item = Self::Instruction> + use<> {
|
|
||||||
let state = self.state.clone();
|
let state = self.state.clone();
|
||||||
let config = config.clone();
|
KlondikeIter::new().filter(move |&instruction| state.is_instruction_valid(instruction))
|
||||||
KlondikeIter::new()
|
|
||||||
.filter(move |&instruction| state.is_instruction_valid(&config, instruction))
|
|
||||||
}
|
}
|
||||||
fn is_instruction_valid(&self, config: &Self::Config, instruction: Self::Instruction) -> bool {
|
fn is_instruction_valid(&self, _config: &Self::Config, instruction: Self::Instruction) -> bool {
|
||||||
self.state.is_instruction_valid(config, instruction)
|
self.state.is_instruction_valid(instruction)
|
||||||
}
|
}
|
||||||
fn process_instruction(
|
fn process_instruction(
|
||||||
&mut self,
|
&mut self,
|
||||||
@@ -841,7 +588,6 @@ impl Game for Klondike {
|
|||||||
config: &Self::Config,
|
config: &Self::Config,
|
||||||
instruction: Self::Instruction,
|
instruction: Self::Instruction,
|
||||||
) {
|
) {
|
||||||
stats.increment_moves();
|
|
||||||
match instruction {
|
match instruction {
|
||||||
// Reset the stock if it's empty
|
// Reset the stock if it's empty
|
||||||
KlondikeInstruction::RotateStock => {
|
KlondikeInstruction::RotateStock => {
|
||||||
@@ -856,61 +602,27 @@ impl Game for Klondike {
|
|||||||
}
|
}
|
||||||
// Move a card from anywhere to a foundation
|
// Move a card from anywhere to a foundation
|
||||||
KlondikeInstruction::DstFoundation(DstFoundation { src, foundation }) => {
|
KlondikeInstruction::DstFoundation(DstFoundation { src, foundation }) => {
|
||||||
stats.increment_move_to_foundation();
|
stats.increment_moves();
|
||||||
let (card, did_flip_up) = self.state.take_top_card_flip_up(src);
|
let card = self.state.take_top_card(src);
|
||||||
if did_flip_up {
|
|
||||||
stats.increment_flip_up_bonus();
|
|
||||||
}
|
|
||||||
self.state.extend_foundation(foundation, card);
|
self.state.extend_foundation(foundation, card);
|
||||||
}
|
}
|
||||||
// Move a stack of cards from anywhere to a tableau
|
// Move a stack of cards from anywhere to a tableau
|
||||||
KlondikeInstruction::DstTableau(DstTableau { src, tableau }) => {
|
KlondikeInstruction::DstTableau(DstTableau { src, tableau }) => {
|
||||||
match src {
|
stats.increment_moves();
|
||||||
KlondikePileStack::Stock => stats.increment_move_to_tableau(),
|
let cards = self.state.take_stack(src);
|
||||||
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);
|
self.state.extend_tableau(tableau, cards);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
fn is_win(&self) -> bool {
|
fn is_win(&self) -> bool {
|
||||||
// all foundations contain all ranks
|
// all face down cards empty means win
|
||||||
self.state.foundations.iter().all(|foundation| {
|
self.state.stock.face_down().is_empty()
|
||||||
foundation.len() == Rank::RANKS.len()
|
&& self.state.tableau1.face_down().is_empty()
|
||||||
&& foundation
|
&& self.state.tableau2.face_down().is_empty()
|
||||||
.iter()
|
&& self.state.tableau3.face_down().is_empty()
|
||||||
.zip(Rank::RANKS)
|
&& self.state.tableau4.face_down().is_empty()
|
||||||
.all(|(card, rank)| card.rank() == rank)
|
&& self.state.tableau5.face_down().is_empty()
|
||||||
})
|
&& self.state.tableau6.face_down().is_empty()
|
||||||
}
|
&& self.state.tableau7.face_down().is_empty()
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg(feature = "serde")]
|
|
||||||
impl serde::Serialize for KlondikeInstruction {
|
|
||||||
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
|
|
||||||
where
|
|
||||||
S: serde::Serializer,
|
|
||||||
{
|
|
||||||
// There is 721 klondike instructions
|
|
||||||
let instruction_id = KlondikeIter::new()
|
|
||||||
.position(|instruction| &instruction == self)
|
|
||||||
.unwrap();
|
|
||||||
serializer.serialize_u16(instruction_id as u16)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
#[cfg(feature = "serde")]
|
|
||||||
impl<'de> serde::Deserialize<'de> for KlondikeInstruction {
|
|
||||||
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
|
|
||||||
where
|
|
||||||
D: serde::Deserializer<'de>,
|
|
||||||
{
|
|
||||||
let instruction_id = u16::deserialize(deserializer)?;
|
|
||||||
let instruction = KlondikeIter::new().nth(instruction_id as usize).unwrap();
|
|
||||||
Ok(instruction)
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -1,5 +0,0 @@
|
|||||||
---
|
|
||||||
source: klondike/src/test.rs
|
|
||||||
expression: serialized
|
|
||||||
---
|
|
||||||
{"config":{"inner":{"draw_stock":"DrawOne","move_from_foundation":"Allowed","scoring":{"move_to_foundation":10,"flip_up_bonus":5,"move_to_tableau":5,"move_from_foundation":-15,"recycle":0}},"undo_penalty":-15,"solve_moves_budget":100000,"solve_states_budget":100000},"initial_state":{"stock":{"face_down":[52,51,21,59,36,45,49,50,22,3,58,39,41,61,13,57,34,56,28,1,19,12,17,5],"face_up":[]},"foundations":[[],[],[],[]],"tableau1":{"face_down":[],"face_up":[40]},"tableau2":{"face_down":[9],"face_up":[4]},"tableau3":{"face_down":[35,8],"face_up":[60]},"tableau4":{"face_down":[11,27,44],"face_up":[25]},"tableau5":{"face_down":[6,7,23,18],"face_up":[29]},"tableau6":{"face_down":[2,55,10,42,24],"face_up":[54]},"tableau7":{"face_down":[26,43,38,53,37,33],"face_up":[20]}},"instructions":[336,100,720,619,606,6,720,19,16,388,497,580,388,720,139,720,19,720,17,31,720,720,720,7,720,720,523,458,720,720,720,720,720,720,720,720,43,43,720,720,720,139,720,19,720,43,720,43,720,720,720,720,720,720,720,720,720,623,619,720,720,720,720,720,720,720,720,720,720,693,281,333,253,209,113,87,720,720,720,720,720,720,720,720,75,223,619,533,74,2,720,116,331,279,279,305,305,29,25,24,12,37,25,222,24,42,126,471,720,720,720,362,292,331,253,720,19,720,183,151,12,67,336,61,93,235,720,7,2,0,7,38,26,14,27,15,26,36,0,7,3,6,18,43,36,24,12,0,1,19,38,26,39,27,15,38,26,36]}
|
|
||||||
@@ -1,6 +0,0 @@
|
|||||||
---
|
|
||||||
source: klondike/src/test.rs
|
|
||||||
expression: serialized
|
|
||||||
extension: bin
|
|
||||||
snapshot_kind: binary
|
|
||||||
---
|
|
||||||
Binary file not shown.
+21
-43
@@ -1,55 +1,33 @@
|
|||||||
use crate::Klondike;
|
use crate::Klondike;
|
||||||
use card_game::Session;
|
use card_game::{Game, Session};
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn test_is_winnable() {
|
fn test_is_winnable() {
|
||||||
// is winnable
|
// is winnable
|
||||||
let solution_result = Session::new_default(Klondike::with_seed(124)).solve();
|
let is_winnable = Session::new_default(Klondike::new_random()).is_winnable();
|
||||||
if let Ok(Some(solution)) = solution_result {
|
println!("is_winnable = {is_winnable:?}");
|
||||||
let win_moves = solution.clean_solution();
|
|
||||||
// for (i, ins) in win_moves.into_iter().enumerate() {
|
|
||||||
// println!("{i} = {:?}", ins.instruction());
|
|
||||||
// }
|
|
||||||
println!("Game is winnable with {} moves", win_moves.len());
|
|
||||||
} else {
|
|
||||||
println!("Game is not winnable");
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
#[cfg(feature = "serde")]
|
|
||||||
#[test]
|
#[test]
|
||||||
fn test_json() {
|
fn test_klondike() {
|
||||||
let mut session = Session::new_default(Klondike::with_seed(124));
|
// create game session
|
||||||
let solution_result = session.solve();
|
let game = Klondike::new_random();
|
||||||
if let Ok(Some(solution)) = solution_result {
|
let mut session = Session::new_default(game);
|
||||||
for snapshot in solution.clean_solution() {
|
|
||||||
session.process_instruction(snapshot.instruction().clone());
|
// 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);
|
||||||
}
|
}
|
||||||
let serialized = serde_json::to_string(&session).unwrap();
|
|
||||||
println!("serialized = {serialized}");
|
|
||||||
let round_trip_session: Session<Klondike> = serde_json::from_str(&serialized).unwrap();
|
|
||||||
let serialized2 = serde_json::to_string(&round_trip_session).unwrap();
|
|
||||||
assert_eq!(serialized, serialized2);
|
|
||||||
|
|
||||||
insta::assert_snapshot!(serialized);
|
// did win
|
||||||
}
|
let is_win = session.is_win();
|
||||||
|
|
||||||
#[cfg(feature = "serde")]
|
// print session history
|
||||||
#[test]
|
for (i, instruction) in session.history().iter().enumerate() {
|
||||||
fn test_rmp() {
|
println!("move {i} = {instruction:?}");
|
||||||
let mut session = Session::new_default(Klondike::with_seed(124));
|
|
||||||
let solution_result = session.solve();
|
|
||||||
if let Ok(Some(solution)) = solution_result {
|
|
||||||
for snapshot in solution.clean_solution() {
|
|
||||||
session.process_instruction(snapshot.instruction().clone());
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
let serialized = rmp_serde::to_vec(&session).unwrap();
|
|
||||||
println!("serialized.len() = {}", serialized.len());
|
|
||||||
let round_trip_session: Session<Klondike> = rmp_serde::from_slice(&serialized).unwrap();
|
|
||||||
let serialized2 = rmp_serde::to_vec(&round_trip_session).unwrap();
|
|
||||||
assert_eq!(serialized, serialized2);
|
|
||||||
|
|
||||||
insta::assert_binary_snapshot!("save_rmp.bin", serialized);
|
println!("is_win = {is_win}");
|
||||||
}
|
}
|
||||||
|
|||||||
Reference in New Issue
Block a user