feat: zener & play

Author: tristan-f-r

Cargo.lock

@@ -11,7 +11,6 @@ edition = "2021"
 [features]
 "xxhash" = ["dep:twox-hash"]
 "rayon" = ["dep:rayon", "xxhash", "dep:sysinfo", "dep:moka"]
-# "reinforcement" = ["dep:rand", "dep:dfdx", "dep:itertools"]
 "js" = ["moka/js"]
 
 [dependencies]
@@ -21,7 +20,7 @@ rand = { version = "0.8", optional = true }
 rayon = { version = "1.8", optional = true }
 sysinfo = { version = "0.30", optional = true }
 twox-hash = { version = "1.6", optional = true }
-itertools = { version = "0.13", optional = true }
+itertools = { version = "0.13" }
 futures = "0.3.30"
 thiserror = "1.0"
 castaway = "0.2.3"

crates/game-solver/Cargo.toml

@@ -1,52 +1,54 @@
 use itertools::{Interleave, Itertools};
 use thiserror::Error;
 
+use crate::{
+    game::{Game, Normal, NormalImpartial},
+    player::ImpartialPlayer,
+};
 use std::{fmt::Debug, iter::Map};
-use crate::{game::{Game, Normal, NormalImpartial}, player::ImpartialPlayer};
 
 /// Represents the disjoint sum of
 /// two impartial normal combinatorial games.
-/// 
+///
 /// Since `Game` isn't object safe, we use `dyn Any` internally with downcast safety.
-/// 
+///
 /// We restrict games to being normal impartial to force implementation of the marker trait.
 #[derive(Clone)]
 pub struct DisjointImpartialNormalGame<L: Game + NormalImpartial, R: Game + NormalImpartial> {
     left: L,
-    right: R
+    right: R,
 }
 
 #[derive(Clone)]
 pub enum DisjointMove<L: Game, R: Game> {
     LeftMove(L::Move),
-    RightMove(R::Move)
+    RightMove(R::Move),
 }
 
 #[derive(Debug, Error, Clone)]
 pub enum DisjointMoveError<L: Game, R: Game> {
     #[error("Could not make the move on left: {0}")]
     LeftError(L::MoveError),
     #[error("Could not make the move on right: {0}")]
-    RightError(R::MoveError)
+    RightError(R::MoveError),
 }
 
 type LeftMoveMap<L, R> = Box<dyn Fn(<L as Game>::Move) -> DisjointMove<L, R>>;
 type RightMoveMap<L, R> = Box<dyn Fn(<R as Game>::Move) -> DisjointMove<L, R>>;
 
-impl<
-    L: Game + Debug + NormalImpartial + 'static,
-    R: Game + Debug + NormalImpartial + 'static
-> Normal for DisjointImpartialNormalGame<L, R> {}
+impl<L: Game + Debug + NormalImpartial + 'static, R: Game + Debug + NormalImpartial + 'static>
+    Normal for DisjointImpartialNormalGame<L, R>
+{
+}
 
-impl<
-    L: Game + Debug + NormalImpartial + 'static,
-    R: Game + Debug + NormalImpartial + 'static
-> NormalImpartial for DisjointImpartialNormalGame<L, R> {}
+impl<L: Game + Debug + NormalImpartial + 'static, R: Game + Debug + NormalImpartial + 'static>
+    NormalImpartial for DisjointImpartialNormalGame<L, R>
+{
+}
 
-impl<
-    L: Game + Debug + NormalImpartial + 'static,
-    R: Game + Debug + NormalImpartial + 'static
-> Game for DisjointImpartialNormalGame<L, R> {
+impl<L: Game + Debug + NormalImpartial + 'static, R: Game + Debug + NormalImpartial + 'static> Game
+    for DisjointImpartialNormalGame<L, R>
+{
     type Move = DisjointMove<L, R>;
     type Iter<'a> = Interleave<
         Map<<L as Game>::Iter<'a>, LeftMoveMap<L, R>>,
@@ -61,36 +63,41 @@ impl<
     }
 
     fn max_moves(&self) -> Option<usize> {
-        self.left.max_moves()
-            .map(
-                |l| self.right.max_moves()
-                    .map(|r| l + r)
-            ).flatten()
+        self.left
+            .max_moves()
+            .map(|l| self.right.max_moves().map(|r| l + r))
+            .flatten()
     }
 
     fn make_move(&mut self, m: &Self::Move) -> Result<(), Self::MoveError> {
         match m {
-            DisjointMove::LeftMove(l) => 
-                self.left.make_move(l).map_err(|err| DisjointMoveError::LeftError(err)),
-            DisjointMove::RightMove(r) => 
-                self.right.make_move(r).map_err(|err| DisjointMoveError::RightError(err))
+            DisjointMove::LeftMove(l) => self
+                .left
+                .make_move(l)
+                .map_err(|err| DisjointMoveError::LeftError(err)),
+            DisjointMove::RightMove(r) => self
+                .right
+                .make_move(r)
+                .map_err(|err| DisjointMoveError::RightError(err)),
         }
     }
 
     fn possible_moves(&self) -> Self::Iter<'_> {
         fn as_left<L: Game, R: Game>(m: L::Move) -> DisjointMove<L, R> {
             DisjointMove::LeftMove(m)
         }
-    
+
         fn as_right<L: Game, R: Game>(m: R::Move) -> DisjointMove<L, R> {
             DisjointMove::RightMove(m)
         }
 
-        self.left.possible_moves()
+        self.left
+            .possible_moves()
             .map(Box::new(as_left) as LeftMoveMap<L, R>)
             .interleave(
-                self.right.possible_moves()
-                .map(Box::new(as_right) as RightMoveMap<L, R>)
+                self.right
+                    .possible_moves()
+                    .map(Box::new(as_right) as RightMoveMap<L, R>),
             )
     }
 

crates/game-solver/src/disjoint_game.rs

@@ -17,7 +17,7 @@ pub enum GameState<P: Player> {
 }
 
 /// Marks a game as being 'normal' (a game has the 'normal play' convention).
-/// 
+///
 /// Rather, this means that the game is won by whoever plays last.
 /// Under this convention, no ties are possible: there has to exist a strategy
 /// for players to be able to force a win.
@@ -37,19 +37,19 @@ pub trait Normal: Game {
 /// the disjunctive sum of two games is equal to another normal-play game.
 pub trait NormalImpartial: Normal {
     /// Splits a game into multiple separate games.
-    /// 
+    ///
     /// This function doesn't have to be necessarily optimal, but
     /// it makes normal impartial game analysis much quicker,
     /// using the technique described in [Nimbers Are Inevitable](https://arxiv.org/abs/1011.5841).
-    /// 
+    ///
     /// Returns `Option::None`` if the game currently can not be split.
     fn split(&self) -> Option<Vec<Self>> {
         None
     }
 }
 
 /// Marks a game as being 'misere' (a game has the 'misere play' convention).
-/// 
+///
 /// Rather, this means that the game is lost by whoever plays last.
 /// Under this convention, no ties are possible: there has to exist a strategy
 /// for players to be able to force a win.
@@ -192,7 +192,11 @@ pub trait Game: Clone {
 ///
 /// Note: Despite this returning isize, this function will always be positive.
 pub fn upper_bound<T: Game>(game: &T) -> isize {
-    game.max_moves().map_or(isize::MAX, |m| m as isize)
+    game.max_moves().map_or(
+        // TODO(HACKY): theres probably nicer ways of handling upper bounds for
+        // loopy games
+        isize::MAX / 2, |m| m as isize
+    )
 }
 
 /// Represents an outcome of a game derived by a score and a valid instance of a game.

crates/game-solver/src/game.rs

@@ -4,10 +4,11 @@
 //! [the book](https://leodog896.github.io/game-solver/book) is
 //! a great place to start.
 
-pub mod game;
 pub mod disjoint_game;
+pub mod game;
 pub mod player;
 pub mod stats;
+pub mod loopy;
 // TODO: reinforcement
 // #[cfg(feature = "reinforcement")]
 // pub mod reinforcement;

crates/game-solver/src/lib.rs

@@ -0,0 +1,60 @@
+use std::fmt::Debug;
+use std::hash::Hash;
+use std::collections::HashSet;
+
+/// We handle loopy games with a custom struct, `LoopyTracker`, which is a
+/// HashSet of some state T. This is used to keep track of the states that
+/// have been visited, and if a state has been visited, we can handle it appropriately.
+/// 
+/// `LoopyTracker` should be updated at `Game::make_move` and checked in `Game::state`.
+
+#[derive(Debug, Clone)]
+pub struct LoopyTracker<T: Eq + Hash> {
+    visited: HashSet<T>,
+}
+
+impl<T: Eq + Hash> LoopyTracker<T> {
+    /// Create a new `LoopyTracker`.
+    pub fn new() -> Self {
+        Self {
+            visited: HashSet::new(),
+        }
+    }
+
+    /// Check if a state has been visited.
+    pub fn has_visited(&self, state: &T) -> bool {
+        self.visited.contains(state)
+    }
+
+    /// Mark a state as visited.
+    pub fn mark_visited(&mut self, state: T) {
+        self.visited.insert(state);
+    }
+
+    /// The number of states visited.
+    pub fn age(&self) -> usize {
+        self.visited.len()
+    }
+}
+
+impl<T: Eq + Hash> Default for LoopyTracker<T> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<T: Eq + Hash> PartialEq for LoopyTracker<T> {
+    fn eq(&self, _: &Self) -> bool {
+        true
+    }
+}
+
+impl<T: Eq + Hash> Eq for LoopyTracker<T> {}
+
+impl<T: Eq + Hash> Hash for LoopyTracker<T> {
+    fn hash<H: std::hash::Hasher>(&self, hasher: &mut H) {
+        for item in self.visited.iter() {
+            item.hash(hasher);
+        }
+    }
+}

crates/game-solver/src/loopy.rs

@@ -9,3 +9,6 @@ game-solver = { path = "../game-solver", features = ["rayon"] }
 games = { path = "../games" }
 anyhow = "1.0.86"
 clap = { version = "4.5.15", features = ["derive"] }
+dialoguer = "0.11.0"
+clearscreen = "4.0.1"
+owo-colors = "4.1.0"

crates/games-cli/Cargo.toml

@@ -0,0 +1,44 @@
+use std::{fmt::{Debug, Display}, str::FromStr};
+
+use game_solver::{game::Game, player::TwoPlayer};
+use games::util::cli::{move_failable, robot::announce_player};
+
+use owo_colors::OwoColorize;
+
+use dialoguer::{theme::ColorfulTheme, Input};
+
+pub fn play_interactive<
+    T: Game<Player = impl TwoPlayer + Debug + 'static>
+        + Display
+>(
+    mut game: T
+) where <T as Game>::Move: FromStr + Debug, <<T as Game>::Move as FromStr>::Err: Debug {
+    loop {
+        print!("{}", game);
+        println!();
+
+        announce_player(&game);
+
+        let game_move: String = Input::with_theme(&ColorfulTheme::default())
+            .with_prompt("Move")
+            .interact_text()
+            .unwrap();
+
+        match FromStr::from_str(&game_move) {
+            Ok(game_move) => {
+                if let Err(err) = move_failable(&mut game, &game_move) {
+                    clearscreen::clear().expect("failed to clear screen");
+                    println!("{}", format!("Failed to make move {game_move:?}: {err:?}").red());
+                    continue;
+                }
+            },
+            Err(err) => {
+                clearscreen::clear().expect("failed to clear screen");
+                println!("{}", format!("Invalid move {game_move}: {err:?}").red());
+                continue;
+            }
+        }
+
+        clearscreen::clear().expect("failed to clear screen");
+    }
+}

crates/games-cli/src/interactive.rs

@@ -1,33 +1,54 @@
+mod interactive;
+
 use anyhow::Result;
 use clap::Parser;
 use games::{
     chomp::Chomp, domineering::Domineering, naive_nim::Nim, order_and_chaos::OrderAndChaos,
-    reversi::Reversi, sprouts::Sprouts, tic_tac_toe::TicTacToe, util::cli::play, Games,
+    reversi::Reversi, sprouts::Sprouts, tic_tac_toe::TicTacToe, util::cli::play, zener::Zener,
+    Games,
 };
+use interactive::play_interactive;
 
 /// `game-solver` is a solving utility that helps analyze various combinatorial games.
 #[derive(Parser)]
 #[command(version, about, long_about = None)]
-struct Cli {
-    #[command(subcommand)]
-    command: Games,
-    #[arg(short, long)]
-    plain: bool,
+enum Cli {
+    Solve {
+        #[command(subcommand)]
+        command: Games,
+        #[arg(short, long)]
+        plain: bool,
+    },
+    Play {
+        #[command(subcommand)]
+        command: Games
+    }
 }
 
 fn main() -> Result<()> {
     let cli = Cli::parse();
 
-    match cli.command {
-        Games::Reversi(args) => play::<Reversi>(args.try_into().unwrap(), cli.plain),
-        Games::TicTacToe(args) => play::<TicTacToe>(args.try_into().unwrap(), cli.plain),
-        Games::OrderAndChaos(args) => {
-            play::<OrderAndChaos<6, 6, 5, 6>>(args.try_into().unwrap(), cli.plain)
+    match cli {
+        Cli::Solve { command, plain } => match command {
+            Games::Reversi(args) => play::<Reversi>(args.try_into().unwrap(), plain),
+            Games::TicTacToe(args) => play::<TicTacToe>(args.try_into().unwrap(), plain),
+            Games::OrderAndChaos(args) => play::<OrderAndChaos<6, 6, 5, 6>>(args.try_into().unwrap(), plain),
+            Games::NaiveNim(args) => play::<Nim>(args.try_into().unwrap(), plain),
+            Games::Domineering(args) => play::<Domineering<5, 5>>(args.try_into().unwrap(), plain),
+            Games::Chomp(args) => play::<Chomp>(args.try_into().unwrap(), plain),
+            Games::Sprouts(args) => play::<Sprouts>(args.try_into().unwrap(), plain),
+            Games::Zener(args) => play::<Zener>(args.try_into().unwrap(), plain),
+        },
+        Cli::Play { command } => match command {
+            Games::Reversi(args) => play_interactive::<Reversi>(args.try_into().unwrap()),
+            Games::TicTacToe(args) => play_interactive::<TicTacToe>(args.try_into().unwrap()),
+            Games::OrderAndChaos(args) => play_interactive::<OrderAndChaos<6, 6, 5, 6>>(args.try_into().unwrap()),
+            Games::NaiveNim(args) => play_interactive::<Nim>(args.try_into().unwrap()),
+            Games::Domineering(args) => play_interactive::<Domineering<5, 5>>(args.try_into().unwrap()),
+            Games::Chomp(args) => play_interactive::<Chomp>(args.try_into().unwrap()),
+            Games::Sprouts(args) => play_interactive::<Sprouts>(args.try_into().unwrap()),
+            Games::Zener(args) => play_interactive::<Zener>(args.try_into().unwrap()),
         }
-        Games::NaiveNim(args) => play::<Nim>(args.try_into().unwrap(), cli.plain),
-        Games::Domineering(args) => play::<Domineering<5, 5>>(args.try_into().unwrap(), cli.plain),
-        Games::Chomp(args) => play::<Chomp>(args.try_into().unwrap(), cli.plain),
-        Games::Sprouts(args) => play::<Sprouts>(args.try_into().unwrap(), cli.plain),
     };
 
     Ok(())

crates/games-cli/src/main.rs

@@ -21,7 +21,7 @@ thiserror = "1.0.63"
 petgraph = { version = "0.6.5", features = ["serde-1"] }
 castaway = "0.2.3"
 ratatui = "0.28.1"
-owo-colors = "4.1.0"
+owo-colors = { version = "4.1.0", features = ["supports-colors"] }
 
 [features]
 "egui" = ["dep:egui", "dep:egui_commonmark"]