feat: zener possible moves

Author: tristan-f-r

crates/game-solver/src/disjoint_game.rs

@@ -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/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.

crates/game-solver/src/lib.rs

@@ -4,8 +4,8 @@
 //! [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;
 // TODO: reinforcement

crates/games/src/zener/gui.rs

@@ -0,0 +1 @@
+

crates/games/src/zener/mod.rs

@@ -4,7 +4,10 @@
 pub mod gui;
 
 use array2d::Array2D;
-use game_solver::{game::{Game, GameState}, player::PartizanPlayer};
+use game_solver::{
+    game::{Game, GameState},
+    player::PartizanPlayer,
+};
 use thiserror::Error;
 
 #[derive(Clone, Copy, Hash, Eq, PartialEq, Debug)]
@@ -13,7 +16,7 @@ pub enum InnerCellType {
     Cross,
     Circle,
     Square,
-    Star
+    Star,
 }
 
 #[derive(Clone, Copy, Hash, Eq, PartialEq, Debug)]
@@ -46,32 +49,43 @@ impl Default for Zener {
         board[(NUM_ROWS - 1, 3)] = vec![CellType(InnerCellType::Square, PartizanPlayer::Right)];
         board[(NUM_ROWS - 1, 2)] = vec![CellType(InnerCellType::Wave, PartizanPlayer::Right)];
         board[(NUM_ROWS - 1, 1)] = vec![CellType(InnerCellType::Cross, PartizanPlayer::Right)];
-        board[(NUM_ROWS - 1, 0)] = vec![CellType(InnerCellType::Circle, PartizanPlayer::Right)];        
+        board[(NUM_ROWS - 1, 0)] = vec![CellType(InnerCellType::Circle, PartizanPlayer::Right)];
 
         Self {
             board,
             player: PartizanPlayer::Left,
             compulsory: None,
             move_count: 0,
 
-            gutter: None
+            gutter: None,
         }
     }
 }
 
+#[derive(Clone, Copy, Debug)]
+pub enum ZenerPosition {
+    Position(usize, usize),
+    Gutter,
+}
+
 #[derive(Error, Clone, Debug)]
 pub enum ZenerMoveError {
-    #[error("can not move at {0:?} since there's no piece!")]
-    NoPiece(ZenerPosition)
+    #[error("can not move from {0:?} since there's no piece!")]
+    NoPiece((usize, usize)),
+    #[error("can not move a piece 'from' a non-existent position {0:?}")]
+    FromOutOfBounds((usize, usize)),
+    #[error("can not move a piece 'to' a non-existent position {0:?}")]
+    ToOutOfBounds((usize, usize)),
+    #[error("the gutter is filled - the game is already won!")]
+    GutterFilled,
+    #[error("can't move {want:?}: need to move {need:?}")]
+    Compulsory { want: CellType, need: InnerCellType },
 }
 
-/// (row, col)
-pub type ZenerPosition = (usize, usize);
-
 #[derive(Clone, Copy)]
 pub struct ZenerMove {
-    from: ZenerPosition,
-    to: ZenerPosition
+    from: (usize, usize),
+    to: ZenerPosition,
 }
 
 impl Game for Zener {
@@ -82,7 +96,6 @@ impl Game for Zener {
     type MoveError = ZenerMoveError;
 
     fn max_moves(&self) -> Option<usize> {
-        // TODO
         None
     }
 
@@ -91,19 +104,91 @@ impl Game for Zener {
     }
 
     fn make_move(&mut self, m: &Self::Move) -> Result<(), Self::MoveError> {
+        if self.gutter.is_some() {
+            return Err(ZenerMoveError::GutterFilled);
+        }
+
+        // check that to is in bounds
+        if let ZenerPosition::Position(row, col) = m.to {
+            if self.board.get(row, col).is_none() {
+                return Err(ZenerMoveError::ToOutOfBounds((row, col)));
+            }
+        }
+
         // get the piece to move
-        let from_piece = self.board[m.from]
-            .last()
-            .ok_or(ZenerMoveError::NoPiece(m.from))?.clone();
-        
+        let from_piece = self
+            .board
+            .get_mut(m.from.0, m.from.1)
+            .ok_or(ZenerMoveError::FromOutOfBounds(m.from))?
+            .pop()
+            .ok_or(ZenerMoveError::NoPiece(m.from))?
+            .clone();
+
+        if let Some(compulsory) = self.compulsory {
+            if from_piece.0 != compulsory {
+                return Err(ZenerMoveError::Compulsory {
+                    want: from_piece,
+                    need: compulsory,
+                });
+            }
+        }
+
         // add it on the 'to' stack.
-        self.board[m.to].push(from_piece);
-        
+        match m.to {
+            ZenerPosition::Position(row, col) => self
+                .board
+                .get_mut(row, col)
+                .expect("Guard check failed - this shouldn't happen.") // guaranteed with the guard check
+                .push(from_piece),
+            ZenerPosition::Gutter => unimplemented!(),
+        }
+
         Ok(())
     }
 
     fn possible_moves(&self) -> Self::Iter<'_> {
-        unimplemented!()
+        if self.gutter.is_some() {
+            return vec![].into_iter();
+        }
+
+        let mut moves = Vec::new();
+
+        for (row, col) in self.board.indices_row_major() {
+            if self.board.get(row, col).map(|cell| cell.last()).flatten().is_none() {
+                continue;
+            };
+
+            let offsets: Vec<(isize, isize)> = vec![(1, 0), (-1, 0), (0, 1), (0, -1)];
+            for offset in offsets {
+                let new_row = (row as isize) + offset.0;
+                let new_col = (col as isize) + offset.1;
+
+                if new_row == -1 || new_row == (NUM_ROWS as isize) {
+                    moves.push(ZenerMove {
+                        from: (row, col),
+                        to: ZenerPosition::Gutter,
+                    });
+                    continue;
+                }
+
+                let Ok(new_col) = new_col.try_into() else {
+                    continue;
+                };
+
+                if self
+                    .board
+                    .get(new_row.try_into().unwrap(), new_col)
+                    .is_some()
+                {
+                    moves.push(ZenerMove {
+                        from: (row, col),
+                        to: ZenerPosition::Position(new_row.try_into().unwrap(), new_col),
+                    });
+                }
+            }
+        }
+
+        return moves.into_iter();
     }
 
     fn player(&self) -> Self::Player {
@@ -113,7 +198,7 @@ impl Game for Zener {
     fn state(&self) -> GameState<Self::Player> {
         match self.gutter {
             None => GameState::Playable,
-            Some(CellType(_, player)) => GameState::Win(player)
+            Some(CellType(_, player)) => GameState::Win(player),
         }
     }
 }

crates/nimnim/src/lib.rs

@@ -1,9 +1,9 @@
 use std::{collections::HashSet, ops::Add};
 
 /// A nimber is the size of a heap in a single-stack nim game.
-/// 
+///
 /// Nim is crucial for loop-free* impartial combinatorial game theory analysis.
-/// 
+///
 /// *This structure does not define utilities for loopy nimbers.
 #[derive(Copy, Clone, PartialEq, PartialOrd, Eq, Ord, Debug, Hash)]
 pub struct Nimber(pub usize);
@@ -22,7 +22,7 @@ impl Add for Nimber {
 pub fn mex(list: &[Nimber]) -> Option<Nimber> {
     let mut mex: Option<Nimber> = None;
     let mut set: HashSet<Nimber> = HashSet::with_capacity(list.len());
-    
+
     for item in list {
         if set.insert(*item) {
             if item > &mex.unwrap_or(Nimber(0)) {