remove 'Game' impls, since they are no longer needed, and fix tests.

Author: andysalerno

Diff for: game_runner/src/main.rs

@@ -1,4 +1,4 @@
-use lib_agents::{HumanAgent, MctsAgent, RandomAgent};
+use lib_agents::{HumanAgent, MctsAgent};
 use lib_boardgame::{GameRunner, GeneralGameRunner, PlayerColor};
 use lib_connect_four::ConnectFourState;
 use lib_reversi::ReversiState;

Diff for: lib_agents/src/mcts_agent/agent.rs

@@ -258,20 +258,12 @@ where
 mod tests {
     use super::*;
 
-    use lib_boardgame::{Game, GameState};
-    use lib_tic_tac_toe::tic_tac_toe::TicTacToe;
-    use lib_tic_tac_toe::tic_tac_toe_gamestate::{BoardPosition, TicTacToeAction};
+    use lib_boardgame::GameState;
+    use lib_tic_tac_toe::tic_tac_toe_gamestate::{BoardPosition, TicTacToeAction, TicTacToeState};
 
     #[test]
     fn tree_search_always_picks_winning_move() {
-        let black_agent: Box<MctsAgent<_, ArcNode<_>>> =
-            Box::new(MctsAgent::new(PlayerColor::Black));
-        let white_agent: Box<MctsAgent<_, ArcNode<_>>> =
-            Box::new(MctsAgent::new(PlayerColor::White));
-
-        let mut game = TicTacToe::new(white_agent, black_agent);
-
-        let state = game.game_state_mut();
+        let mut state = TicTacToeState::initial_state();
 
         // Start with black's turn
         assert_eq!(state.current_player_turn(), PlayerColor::Black);
@@ -310,7 +302,7 @@ mod tests {
         let legal_moves = state.legal_moves(PlayerColor::Black);
 
         let test_black_agent: MctsAgent<_, ArcNode<_>> = MctsAgent::new(PlayerColor::Black);
-        let mcts_chosen_move = test_black_agent.pick_move(state, &legal_moves);
+        let mcts_chosen_move = test_black_agent.pick_move(&state, &legal_moves);
 
         // The agent MUST pick the winning move:
         //  V

Diff for: lib_boardgame/src/lib.rs

@@ -133,86 +133,6 @@ pub trait GameState: Clone + Display {
     }
 }
 
-/// A trait that describes the high-level behavior of running a game,
-/// i.e. managing the underlying game state.
-pub trait Game {
-    /// The underlying game state for this game.
-    type State: GameState;
-
-    /// Returns a handle to the white player agent.
-    fn white_agent(&self) -> &dyn GameAgent<Self::State>;
-
-    /// Returns a handle to the black player agent.
-    fn black_agent(&self) -> &dyn GameAgent<Self::State>;
-
-    /// The game's current state.
-    fn game_state(&self) -> &Self::State;
-
-    /// The game's current state, mutable.
-    fn game_state_mut(&mut self) -> &mut Self::State;
-
-    /// True if the the game has ended, either due to a forced win,
-    /// draw, or forfeit.
-    fn is_game_over(&self) -> bool;
-
-    /// The GameResult, or None if the game is not yet over.
-    fn game_result(&self) -> Option<GameResult>;
-
-    /// Invokes the current player agent to pick a move,
-    /// then updates the game state with the result.
-    fn player_take_turn(&mut self, player: PlayerColor) {
-        let state = self.game_state();
-        let legal_moves = state.legal_moves(player);
-
-        let picked_action = match player {
-            PlayerColor::Black => self.black_agent().pick_move(state, legal_moves),
-            PlayerColor::White => self.white_agent().pick_move(state, legal_moves),
-        };
-
-        if legal_moves.iter().find(|&&m| m == picked_action).is_none() {
-            panic!("Agent provided a move that is illegal.");
-        }
-
-        if legal_moves.len() == 1 && legal_moves[0].is_forced_pass() {
-            out!(
-                "Player {:?} has no options, so they pass their turn.",
-                player
-            );
-        }
-
-        out!("Player {:?} picked move {:?}", player, picked_action);
-
-        let state = self.game_state_mut();
-
-        state.apply_move(picked_action);
-
-        // Now both players get a chance to observe the selected action and resulting state.
-        let state_copy = state.clone();
-        self.white_agent()
-            .observe_action(player, picked_action, &state_copy);
-        self.black_agent()
-            .observe_action(player, picked_action, &state_copy);
-    }
-
-    /// Applies each player's turn one at a time until the game is over,
-    /// and returns the game result.
-    fn play_to_end(&mut self) -> GameResult {
-        self.game_state_mut().initialize_board();
-        out!("Board initialized.");
-
-        while !self.is_game_over() {
-            out!("{}", self.game_state().human_friendly());
-            let cur_player_color = self.game_state().current_player_turn();
-            self.player_take_turn(cur_player_color);
-        }
-
-        out!("{}", self.game_state().human_friendly());
-
-        self.game_result()
-            .expect("The game is over, so there must be a game result.")
-    }
-}
-
 /// A trait representing the functionality of a GameAgent.
 /// Most importantly, given a GameState, a GameAgent must be able to decide a GameMove.
 pub trait GameAgent<TState: GameState> {

Diff for: lib_connect_four/src/connect_four.rs

@@ -1,4 +1,4 @@
-use lib_boardgame::{Game, GameAgent, GameResult, GameState, PlayerColor};
+use lib_boardgame::{GameResult, GameState, PlayerColor};
 use std::fmt::Display;
 
 const GAME_WIDTH: usize = 7;
@@ -307,58 +307,6 @@ impl GameState for ConnectFourState {
     }
 }
 
-pub struct ConnectFour {
-    white_agent: Box<dyn GameAgent<ConnectFourState>>,
-    black_agent: Box<dyn GameAgent<ConnectFourState>>,
-    game_state: ConnectFourState,
-}
-
-impl ConnectFour {
-    pub fn new(
-        white_agent: Box<dyn GameAgent<ConnectFourState>>,
-        black_agent: Box<dyn GameAgent<ConnectFourState>>,
-    ) -> Self {
-        Self {
-            white_agent,
-            black_agent,
-            game_state: ConnectFourState::initial_state(),
-        }
-    }
-}
-
-impl Game for ConnectFour {
-    type State = ConnectFourState;
-
-    fn white_agent(&self) -> &dyn GameAgent<ConnectFourState> {
-        &*self.white_agent
-    }
-
-    fn black_agent(&self) -> &dyn GameAgent<ConnectFourState> {
-        &*self.black_agent
-    }
-
-    /// The game's current state.
-    fn game_state(&self) -> &Self::State {
-        &self.game_state
-    }
-
-    /// The game's current state.
-    fn game_state_mut(&mut self) -> &mut Self::State {
-        &mut self.game_state
-    }
-
-    /// True if the the game has ended, either due to a forced win,
-    /// draw, or forfeit.
-    fn is_game_over(&self) -> bool {
-        self.game_state.is_game_over()
-    }
-
-    /// The GameResult, or None if the game is not yet over.
-    fn game_result(&self) -> Option<GameResult> {
-        self.game_state.game_result
-    }
-}
-
 struct Position {
     x: usize,
     y: usize,

Diff for: lib_reversi/src/lib.rs

@@ -1,12 +1,10 @@
 mod reversi_action;
 mod reversi_board;
-mod reversi_game;
 mod reversi_gamestate;
 mod util;
 
 use reversi_board::{Board, Directions, BOARD_SIZE};
 
 pub use reversi_action::ReversiPlayerAction;
 pub use reversi_board::{BoardPosition, ReversiPiece};
-pub use reversi_game::Reversi;
 pub use reversi_gamestate::ReversiState;

Diff for: lib_reversi/src/reversi_game.rs

@@ -1,4 +1,3 @@
-pub mod tic_tac_toe;
 pub mod tic_tac_toe_gamestate;
 
 use lib_boardgame::PlayerColor;