wip: releve

justfile

@@ -1,6 +1,11 @@
+#!/usr/bin/env -S just --justfile
+# ^ A shebang isn't required, but allows a justfile to be executed
+#   like a script, with `./justfile test`, for example.
+
+doc:
+  cargo doc --no-deps
 shell:
 	devenv shell
-	# nix develop
 startserver:
 	RUST_LOG=trictrac_server cargo run --bin trictrac-server
 startclient1:

store/src/game.rs

@@ -95,6 +95,10 @@ impl GameState {
         self.schools_enabled = schools_enabled;
     }
 
+    fn get_active_player(&self) -> Option<&Player> {
+        self.players.get(&self.active_player_id)
+    }
+
     fn get_opponent_id(&self) -> Option<PlayerId> {
         self.players
             .keys()
@@ -418,7 +422,7 @@ impl GameState {
                     // Schools are not enabled. We mark points automatically
                     // the points earned by the opponent will be marked on its turn
                     self.mark_points(self.active_player_id, self.dice_points.0);
-                    if self.stage != Stage::Ended {
+                    if self.stage != Stage::Ended && self.turn_stage != TurnStage::HoldOrGoChoice {
                         self.turn_stage = TurnStage::Move;
                     }
                 }
@@ -428,6 +432,8 @@ impl GameState {
                 if self.stage != Stage::Ended {
                     self.turn_stage = if self.turn_stage == TurnStage::MarkAdvPoints {
                         TurnStage::RollDice
+                    } else if self.turn_stage == TurnStage::HoldOrGoChoice {
+                        TurnStage::HoldOrGoChoice
                     } else {
                         TurnStage::Move
                     };
@@ -496,13 +502,17 @@ impl GameState {
         self.players.get_mut(&player_id).map(|p| {
             let sum_points = p.points + points;
             let jeux = sum_points / 12;
-
-            p.points = sum_points % 12;
-            p.holes += match (jeux, p.can_bredouille) {
+            let holes = match (jeux, p.can_bredouille) {
                 (0, _) => 0,
                 (_, false) => 2 * jeux - 1,
                 (_, true) => 2 * jeux,
             };
+
+            if holes > 0 && self.turn_stage == TurnStage::MarkPoints {
+                self.turn_stage = TurnStage::HoldOrGoChoice;
+            }
+            p.points = sum_points % 12;
+            p.holes += holes;
             p
         });
     }
@@ -557,13 +567,37 @@ pub enum GameEvent {
 mod tests {
     use super::*;
 
-    #[test]
-    fn to_string_id() {
+    fn init_test_gamestate(turn: TurnStage) -> GameState {
         let mut state = GameState::default();
         state.add_player(1, Player::new("player1".into(), Color::White));
         state.add_player(2, Player::new("player2".into(), Color::Black));
+        state.active_player_id = 1;
+        state.turn_stage = turn;
+        state
+    }
+
+    #[test]
+    fn to_string_id() {
+        let state = init_test_gamestate(TurnStage::RollDice);
         let string_id = state.to_string_id();
         // println!("string_id : {}", string_id);
-        assert!(string_id == "Hz88AAAAAz8/IAAAAAQAADAD");
+        assert_eq!(string_id, "Hz88AAAAAz8/IAAAAAQAADAD");
+    }
+
+    #[test]
+    fn points_for_hole() {
+        let mut game_state = init_test_gamestate(TurnStage::MarkPoints);
+        game_state.consume(
+            &(GameEvent::Mark {
+                player_id: game_state.active_player_id,
+                points: 13,
+            }),
+        );
+        // println!("{:?}", game_state);
+
+        let player = game_state.get_active_player().unwrap();
+        assert_eq!(player.points, 1);
+        assert_eq!(player.holes, 2); // because can bredouille
+        assert_eq!(game_state.turn_stage, TurnStage::HoldOrGoChoice);
     }
 }