update mockrooms so join emits join message

secert-hitler/src/controller/gamemaster/gamemaster.rs

@@ -1,32 +1,45 @@
-/*
 use super::super::super::model::state::room::Room;
+use super::lobby::Lobby;
 
 pub struct GameMaster {
    room: Box<dyn Room>,
+   lobby: Lobby,
 }
 
 impl GameMaster {
    fn new(room: Box<dyn Room>) -> GameMaster {
       GameMaster{
          room: room,
+         lobby: Lobby::new(),
       }
    }
 
-   fn run(&self) -> Result<String, String> {
+   fn run(&mut self) -> Result<String, String> {
       self.run_lobby()?;
       self.run_game_setup()?;
       self.run_game()
    }
 
-   fn run_lobby(&self) -> Result<String, String> {
+   fn run_lobby(&mut self) -> Result<String, String> {
+      println!(". run lobby");
+      loop {
+         let rollback = self.room.since();
+         let events = self.room.sync();
+         println!(". rollback: {:?}", rollback);
+         for e in &events {
+            println!("e: {:?}", e);
+         }
+         self.room.rollback(rollback);
+         break
+      }
       Err("not impl".to_string())
    }
 
-   fn run_game_setup(&self) -> Result<String, String> {
+   fn run_game_setup(&mut self) -> Result<String, String> {
       Err("not impl".to_string())
    }
 
-   fn run_game(&self) -> Result<String, String> {
+   fn run_game(&mut self) -> Result<String, String> {
       Err("not impl".to_string())
    }
 }
@@ -63,21 +76,25 @@ mod tests {
    }
 
    #[test]
-   fn gm_run_lobby_fail() {
+   fn run_lobby() {
+      let mut mrs = MockRooms::new();
+      let mut r1 = mrs.create();
+      let room_id = r1.room_id();
+      let mut gm = GameMaster::new(r1);
+      let mut r2 = mrs.join(room_id).unwrap();
+      gm.run_lobby();
+      assert!(gm.lobby.players.len() == 1, "players: {:?}, sync: {:?}", gm.lobby.players, gm.room.sync());
+   }
+
+   #[test]
+   fn run_game_setup_fail() {
       let gm = GameMaster::new(Box::new(MockRoom::create()));
       panic!("not impl");
    }
 
    #[test]
-   fn gm_run_game_setup_fail() {
-      let gm = GameMaster::new(Box::new(MockRoom::create()));
-      panic!("not impl");
-   }
-
-   #[test]
-   fn gm_run_game_fail() {
+   fn run_game_fail() {
       let gm = GameMaster::new(Box::new(MockRoom::create()));
       panic!("not impl");
    }
 }
-*/

secert-hitler/src/controller/gamemaster/lobby.rs

@@ -4,17 +4,22 @@ use super::super::super::model::state::event::Event;
 use std::collections::HashMap;
 
 pub struct Lobby {
-   players: HashMap<String, Player>,
+   pub players: HashMap<String, Player>,
+   locked: bool,
 }
 
 impl Lobby {
-   fn new() -> Lobby {
+   pub fn new() -> Lobby {
       Lobby{
          players: HashMap::new(),
+         locked: false,
       }
    }
-
-   fn eat(&mut self, message: Event) {
+   
+   pub fn eat(&mut self, message: Event) {
+      if self.locked {
+         return;
+      }
       let j = message.join();
       if j.is_none() {
          return;
@@ -22,6 +27,10 @@ impl Lobby {
       let id = j.unwrap();
       self.players.insert(id.clone(), Player::new(id));
    }
+
+   pub fn lock(&mut self) {
+      self.locked = true;
+   }
 }
 
 #[cfg(test)]
@@ -31,7 +40,7 @@ mod tests {
    fn _dummy_event(m: &str) -> Event {
       Event{
          body: m.to_string(),
-         next: "a".to_string(),
+         since: "a".to_string(),
          sender: "b".to_string(),
       }
    }

secert-hitler/src/controller/gamemaster/mod.rs

@@ -1,3 +1,4 @@
 pub mod gamemaster;
 pub mod player;
+pub mod role;
 pub mod lobby;

secert-hitler/src/controller/gamemaster/player.rs

@@ -1,14 +1,23 @@
+use super::role::Role;
+use super::role::Roles;
+
 #[derive(Clone, Debug)]
 pub struct Player {
    id: String,
+   role: Role,
 }
 
 impl Player {
    pub fn new(id: String) -> Player {
       Player {
          id: id,
+         role: Role::new(),
       }
    }
+
+   fn set_role(&mut self, role: Roles) {
+      self.role.set(role);
+   }
 }
 
 #[cfg(test)]

secert-hitler/src/controller/gamemaster/role.rs

@@ -3,8 +3,12 @@ pub struct Role {
    role: Roles,
 }
 
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub enum Roles {
    Null,
+   Facist,
+   Hitler,
+   Liberal,
 }
 
 impl Role {
@@ -13,6 +17,22 @@ impl Role {
          role: Roles::Null,
       }
    }
+
+   pub fn set(&mut self, role: Roles) {
+      self.role = role
+   }
+
+   pub fn is_hitler(&self) -> bool {
+      self.role == Roles::Hitler
+   }
+
+   pub fn is_facist(&self) -> bool {
+      self.role == Roles::Facist || self.is_hitler()
+   }
+
+   pub fn is_liberal(&self) -> bool {
+      self.role == Roles::Liberal
+   }
 }
 
 #[cfg(test)]
@@ -23,4 +43,74 @@ mod tests {
    fn new_role() {
       let _ = Role::new();
    }
+
+   #[test]
+   fn set() {
+      let mut r = Role::new();
+      r.set(Roles::Facist);
+      assert!(r.role == Roles::Facist);
+   }
+
+   #[test]
+   fn is_hitler_liberal() {
+      let mut r = Role::new();
+      r.set(Roles::Liberal);
+      assert!(!r.is_hitler());
+   }
+
+   #[test]
+   fn is_hitler_facist() {
+      let mut r = Role::new();
+      r.set(Roles::Facist);
+      assert!(!r.is_hitler());
+   }
+
+   #[test]
+   fn is_hitler_yes() {
+      let mut r = Role::new();
+      r.set(Roles::Hitler);
+      assert!(r.is_hitler());
+   }
+
+   #[test]
+   fn is_facist_liberal() {
+      let mut r = Role::new();
+      r.set(Roles::Liberal);
+      assert!(!r.is_facist());
+   }
+
+   #[test]
+   fn is_facist_facist() {
+      let mut r = Role::new();
+      r.set(Roles::Facist);
+      assert!(r.is_facist());
+   }
+
+   #[test]
+   fn is_facist_hitler() {
+      let mut r = Role::new();
+      r.set(Roles::Hitler);
+      assert!(r.is_facist());
+   }
+
+   #[test]
+   fn is_liberal_liberal() {
+      let mut r = Role::new();
+      r.set(Roles::Liberal);
+      assert!(r.is_liberal());
+   }
+
+   #[test]
+   fn is_liberal_facist() {
+      let mut r = Role::new();
+      r.set(Roles::Facist);
+      assert!(!r.is_liberal());
+   }
+
+   #[test]
+   fn is_liberal_hitler() {
+      let mut r = Role::new();
+      r.set(Roles::Hitler);
+      assert!(!r.is_liberal());
+   }
 }