wip rng seed

store/src/dice.rs

@@ -1,34 +1,56 @@
 use crate::Error;
 use rand::distributions::{Distribution, Uniform};
+use rand::{rngs::StdRng, SeedableRng};
 use serde::{Deserialize, Serialize};
 
-/// Represents the two dices
+pub struct DiceRoller {
+    rng: StdRng,
+}
+
+impl Default for DiceRoller {
+    fn default() -> Self {
+        Self::new(None)
+    }
+}
+
+impl DiceRoller {
+    fn new(opt_seed: Option<u64>) -> Self {
+        Self {
+            rng: match opt_seed {
+                None => StdRng::from_rng(rand::thread_rng()).unwrap(),
+                Some(seed) => SeedableRng::seed_from_u64(seed),
+            },
+        }
+    }
+
+    /// Roll the dices which generates two random numbers between 1 and 6, replicating a perfect
+    /// dice. We use the operating system's random number generator.
+    pub fn roll(&mut self) -> Dice {
+        let between = Uniform::new_inclusive(1, 6);
+
+        let v = (between.sample(&mut self.rng), between.sample(&mut self.rng));
+
+        Dice { values: (v.0, v.1) }
+    }
+
+    // Heads or tails
+    // pub fn coin(self) -> bool {
+    //     let between = Uniform::new_inclusive(1, 2);
+    //     let mut rng = rand::thread_rng();
+    //     between.sample(&mut rng) == 1
+    // }
+}
+
+/// Represents the two dice
 ///
-/// Trictrac is always played with two dices.
+/// Trictrac is always played with two dice.
 #[derive(Debug, Clone, Copy, Serialize, PartialEq, Deserialize, Default)]
-pub struct Dices {
+pub struct Dice {
     /// The two dice values
     pub values: (u8, u8),
 }
-impl Dices {
-    /// Roll the dices which generates two random numbers between 1 and 6, replicating a perfect
-    /// dice. We use the operating system's random number generator.
-    pub fn roll(self) -> Self {
-        let between = Uniform::new_inclusive(1, 6);
-        let mut rng = rand::thread_rng();
-
-        let v = (between.sample(&mut rng), between.sample(&mut rng));
-
-        Dices { values: (v.0, v.1) }
-    }
-
-    /// Heads or tails
-    pub fn coin(self) -> bool {
-        let between = Uniform::new_inclusive(1, 2);
-        let mut rng = rand::thread_rng();
-        between.sample(&mut rng) == 1
-    }
 
+impl Dice {
     pub fn to_bits_string(self) -> String {
         format!("{:0>3b}{:0>3b}", self.values.0, self.values.1)
     }
@@ -61,14 +83,21 @@ mod tests {
 
     #[test]
     fn test_roll() {
-        let dices = Dices::default().roll();
-        assert!(dices.values.0 >= 1 && dices.values.0 <= 6);
-        assert!(dices.values.1 >= 1 && dices.values.1 <= 6);
+        let dice = DiceRoller::default().roll();
+        assert!(dice.values.0 >= 1 && dice.values.0 <= 6);
+        assert!(dice.values.1 >= 1 && dice.values.1 <= 6);
+    }
+
+    #[test]
+    fn test_seed() {
+        let dice = DiceRoller::new(Some(123)).roll();
+        assert!(dice.values.0 == 3);
+        assert!(dice.values.1 == 2);
     }
 
     #[test]
     fn test_to_bits_string() {
-        let dices = Dices { values: (4, 2) };
-        assert!(dices.to_bits_string() == "100010");
+        let dice = Dice { values: (4, 2) };
+        assert!(dice.to_bits_string() == "100010");
     }
 }

store/src/game.rs

@@ -1,6 +1,6 @@
 //! # Play a TricTrac Game
 use crate::board::{Board, CheckerMove, Field, Move};
-use crate::dice::{Dices, Roll};
+use crate::dice::{Dice, DiceRoller, Roll};
 use crate::player::{Color, Player, PlayerId};
 use crate::Error;
 use log::{error, info};
@@ -39,7 +39,7 @@ pub struct GameState {
     pub players: HashMap<PlayerId, Player>,
     pub history: Vec<GameEvent>,
     /// last dice pair rolled
-    pub dices: Dices,
+    pub dice: Dice,
     /// true if player needs to roll first
     roll_first: bool,
 }
@@ -48,7 +48,7 @@ pub struct GameState {
 impl fmt::Display for GameState {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let mut s = String::new();
-        s.push_str(&format!("Dices: {:?}\n", self.dices));
+        s.push_str(&format!("Dice: {:?}\n", self.dice));
         // s.push_str(&format!("Who plays: {}\n", self.who_plays().map(|player| &player.name ).unwrap_or("")));
         s.push_str(&format!("Board: {:?}\n", self.board));
         write!(f, "{}", s)
@@ -64,7 +64,7 @@ impl Default for GameState {
             active_player_id: 0,
             players: HashMap::new(),
             history: Vec::new(),
-            dices: Dices::default(),
+            dice: Dice::default(),
             roll_first: true,
         }
     }
@@ -109,7 +109,7 @@ impl GameState {
         pos_bits.push_str(step_bits);
 
         // dice roll -> 6 bits
-        let dice_bits = self.dices.to_bits_string();
+        let dice_bits = self.dice.to_bits_string();
         pos_bits.push_str(&dice_bits);
 
         // points 10bits x2 joueurs = 20bits
@@ -243,7 +243,7 @@ impl GameState {
                     return false;
                 }
 
-                // Check moves conforms to the dices
+                // Check moves conforms to the dice
                 if !self.moves_follows_dices(color, moves) {
                     return false;
                 }
@@ -278,7 +278,7 @@ impl GameState {
     }
 
     fn moves_follows_dices(&self, color: &Color, moves: &(CheckerMove, CheckerMove)) -> bool {
-        let (dice1, dice2) = self.dices.values;
+        let (dice1, dice2) = self.dice.values;
         let (move1, move2): &(CheckerMove, CheckerMove) = moves.into();
         let dist1 = (move1.get_to() - move1.get_from()) as u8;
         let dist2 = (move2.get_to() - move2.get_from()) as u8;
@@ -473,9 +473,9 @@ pub enum GameEvent {
 
 impl Roll for GameState {
     fn roll(&mut self) -> &mut Self {
-        self.dices = self.dices.roll();
+        self.dice = self.dice.roll();
         if self.who_plays().is_none() {
-            let active_color = match self.dices.coin() {
+            let active_color = match self.dice.coin() {
                 false => Color::Black,
                 true => Color::White,
             };
@@ -504,7 +504,7 @@ impl Move for GameState {
             // self.board.set(player, new_position as usize, 1)?;
         }
 
-        // switch to other player if all dices have been consumed
+        // switch to other player if all dice have been consumed
         self.switch_active_player();
         self.roll_first = true;
 
@@ -530,7 +530,7 @@ impl Move for GameState {
         }
 
         // check if dice value has actually been rolled
-        if dice != self.dices.values.0 && dice != self.dices.values.1 {
+        if dice != self.dice.values.0 && dice != self.dice.values.1 {
             return Err(Error::DiceInvalid);
         }
 
@@ -589,16 +589,16 @@ mod tests {
             goes_first: player_id,
         });
         state.consume(&GameEvent::Roll { player_id });
-        let dices = state.dices.values;
+        let dice = state.dice.values;
         let moves = (
-            CheckerMove::new(1, (1 + dices.0).into()).unwrap(),
-            CheckerMove::new((1 + dices.0).into(), (1 + dices.0 + dices.1).into()).unwrap(),
+            CheckerMove::new(1, (1 + dice.0).into()).unwrap(),
+            CheckerMove::new((1 + dice.0).into(), (1 + dice.0 + dice.1).into()).unwrap(),
         );
         assert!(state.moves_follows_dices(&Color::White, &moves));
 
         let badmoves = (
-            CheckerMove::new(1, (2 + dices.0).into()).unwrap(),
-            CheckerMove::new((1 + dices.0).into(), (1 + dices.0 + dices.1).into()).unwrap(),
+            CheckerMove::new(1, (2 + dice.0).into()).unwrap(),
+            CheckerMove::new((1 + dice.0).into(), (1 + dice.0 + dice.1).into()).unwrap(),
         );
         assert!(!state.moves_follows_dices(&Color::White, &badmoves));
     }