wip mirror

bot/src/lib.rs

@@ -64,6 +64,7 @@ impl Bot {
 
     pub fn handle_event(&mut self, event: &GameEvent) -> Option<GameEvent> {
         let game = self.strategy.get_mut_game();
+        // println!("----- before  : {:?}", game);
         let internal_event = if self.color == Color::Black {
             &event.get_mirror()
         } else {
@@ -74,42 +75,53 @@ impl Bot {
         if game.stage == Stage::Ended {
             return None;
         }
-        // TODO mirror
+        let active_player_id = if self.color == Color::Black {
-        if game.active_player_id == self.player_id {
+            if game.active_player_id == 1 {
-            return match game.turn_stage {
+                2
+            } else {
+                1
+            }
+        } else {
+            game.active_player_id
+        };
+        if active_player_id == self.player_id {
+            let internal_event = match game.turn_stage {
                 TurnStage::MarkAdvPoints => Some(GameEvent::Mark {
-                    player_id: self.player_id,
+                    player_id: 1,
                     points: self.strategy.calculate_adv_points(),
                 }),
-                TurnStage::RollDice => Some(GameEvent::Roll {
+                TurnStage::RollDice => Some(GameEvent::Roll { player_id: 1 }),
-                    player_id: self.player_id,
-                }),
                 TurnStage::MarkPoints => Some(GameEvent::Mark {
-                    player_id: self.player_id,
+                    player_id: 1,
                     points: self.strategy.calculate_points(),
                 }),
                 TurnStage::Move => Some(GameEvent::Move {
-                    player_id: self.player_id,
+                    player_id: 1,
                     moves: self.strategy.choose_move(),
                 }),
                 TurnStage::HoldOrGoChoice => {
                     if self.strategy.choose_go() {
-                        Some(GameEvent::Go {
+                        Some(GameEvent::Go { player_id: 1 })
-                            player_id: self.player_id,
-                        })
                     } else {
                         Some(GameEvent::Move {
-                            player_id: self.player_id,
+                            player_id: 1,
                             moves: self.strategy.choose_move(),
                         })
                     }
                 }
                 _ => None,
             };
+            return if self.color == Color::Black {
+                println!("       evt    : {:?}", internal_event);
+                internal_event.map(|evt| evt.get_mirror())
+            } else {
+                internal_event
+            };
         }
         None
     }
 
+    // Only used in tests below
     pub fn get_state(&self) -> &GameState {
         self.strategy.get_game()
     }
@@ -128,17 +140,31 @@ mod tests {
     }
 
     #[test]
-    fn test_consume() {
+    fn test_handle_event() {
         let mut bot = Bot::new(Box::new(DefaultStrategy::default()), Color::Black);
         // let mut bot = Bot::new(Box::new(DefaultStrategy::default()), Color::Black, false);
         let mut event = bot.handle_event(&GameEvent::BeginGame { goes_first: 2 });
         assert_eq!(event, Some(GameEvent::Roll { player_id: 2 }));
-        assert_eq!(bot.get_state().active_player_id, 2);
+        assert_eq!(bot.get_state().active_player_id, 1); // bot internal active_player_id for black
+        event = bot.handle_event(&GameEvent::RollResult {
+            player_id: 2,
+            dice: Dice { values: (2, 3) },
+        });
+        assert_eq!(
+            event,
+            Some(GameEvent::Move {
+                player_id: 2,
+                moves: (
+                    CheckerMove::new(24, 21).unwrap(),
+                    CheckerMove::new(24, 22).unwrap()
+                )
+            })
+        );
 
         event = bot.handle_event(&GameEvent::BeginGame { goes_first: 1 });
         assert_eq!(event, None);
 
-        assert_eq!(bot.get_state().active_player_id, 1);
+        assert_eq!(bot.get_state().active_player_id, 2); //internal active_player_id
         bot.handle_event(&GameEvent::RollResult {
             player_id: 1,
             dice: Dice { values: (2, 3) },

client_cli/src/game_runner.rs

@@ -67,6 +67,7 @@ impl GameRunner {
         } else {
             println!("{}", self.state);
             println!("event not valid : {:?}", event);
+            panic!("crash and burn");
             &GameEvent::PlayError
         };
 

justfile

@@ -9,8 +9,8 @@ shell:
 runcli:
 	RUST_LOG=info cargo run --bin=client_cli
 runclibots:
-	#RUST_LOG=info cargo run --bin=client_cli -- --bot dqn,dummy
+	RUST_LOG=info cargo run --bin=client_cli -- --bot dqn,dummy
-	RUST_LOG=info cargo run --bin=client_cli -- --bot dummy,dqn
+	# RUST_LOG=info cargo run --bin=client_cli -- --bot dummy,dqn
 match:
   cargo build --release --bin=client_cli
   LD_LIBRARY_PATH=./target/release  ./target/release/client_cli -- --bot dummy,dqn