add switching sides

engine/engine.rs

@@ -5,13 +5,14 @@ pub struct Engine {
     players: Vec<Box<dyn Player>>,
     turn: usize,
     board: Board,
+    x: usize,
 }
 
 impl Engine {
     pub fn new() -> Engine {
         // TODO: accept players as args
-        let p1 = PlayerConsole::new("P1", Cell::CellX);
+        let p1 = PlayerConsole::new("Gopher");
-        let p2 = PlayerConsole::new("P2", Cell::CellO);
+        let p2 = PlayerConsole::new("Rustacean");
 
         let board = Board::new();
 
@@ -19,18 +20,25 @@ impl Engine {
             players: vec![Box::new(p1), Box::new(p2)],
             turn: 0,
             board: board,
+            x: 0,
         }
     }
 
     pub fn run(&mut self) -> Result<(), Box<dyn std::error::Error>> {
         loop {
-            self.board.reset();
+            // setup new game for players
-            match self.run_single_game() {
+            self.players[self.x].start_new_game(Cell::CellX)?;
-                Ok(_) => {}
+            self.players[(self.x + 1) % 2].start_new_game(Cell::CellO)?;
-                Err(e) => break Err(e),
-            }
 
-            // TODO: switch sides
+            // reset board
+            self.board.reset();
+            self.turn = self.x;
+
+            // run game
+            self.run_single_game()?;
+
+            // switch sides
+            self.x = (self.x + 1) % 2
         }
     }
 

player/human.rs

@@ -8,10 +8,10 @@ pub struct PlayerConsole {
 }
 
 impl PlayerConsole {
-    pub fn new(name: &str, p: Cell) -> impl Player {
+    pub fn new(name: &str) -> impl Player {
         PlayerConsole {
             name: name.to_owned(),
-            piece: p,
+            piece: Cell::CellEmpty,
         }
     }
 
@@ -19,6 +19,13 @@ impl PlayerConsole {
         return self.name.as_str();
     }
 
+    pub fn start_new_game(&mut self, p: Cell) -> Result<(), Box<dyn std::error::Error>> {
+        self.piece = p;
+        println!("{}, you are now playing {}", self.name, p);
+
+        Ok(())
+    }
+
     pub fn request_move(&self, _: &Board) -> Result<Move, Box<dyn std::error::Error>> {
         let mut x: usize = 0;
         let mut y: usize = 0;
@@ -65,6 +72,10 @@ impl PlayerConsole {
 }
 
 impl Player for PlayerConsole {
+    fn start_new_game(&mut self, p: Cell) -> Result<(), Box<dyn std::error::Error>> {
+        return self.start_new_game(p);
+    }
+
     fn request_move(&self, b: &Board) -> Result<Move, Box<dyn std::error::Error>> {
         self.request_move(b)
     }

player/mod.rs

@@ -1,9 +1,10 @@
 mod human;
-use crate::game::{Board, Move};
+use crate::game::{Board, Cell, Move};
 
 pub use human::PlayerConsole;
 
 pub trait Player {
+    fn start_new_game(&mut self, p: Cell) -> Result<(), Box<dyn std::error::Error>>;
     fn request_move(&self, b: &Board) -> Result<Move, Box<dyn std::error::Error>>;
     fn name(&self) -> &str;
 }