Remove old stpuid roles

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

@@ -4,6 +4,7 @@ use json;
 #[derive(Clone, Debug)]
 pub struct GameEvent {
    d: json::JsonValue,
+   sender: String,
 }
 
 #[derive(PartialEq, Eq, Debug, Clone)]
@@ -51,35 +52,31 @@ impl GameEventType {
    }
 
    fn build(&self) -> GameEvent {
-      let mut d = json::object!{
-         GameEventType: format!("{:?}", self),
-         sources: [],
-         targets: [],
-         params: [],
-      };
-      match self {
-         _ => {},
-      };
-      let s = d.dump();
       let d = json::object!{
-         "body": s,
+         "body": json::object!{
+            GameEventType: format!("{:?}", self),
+            sources: [],
+            targets: [],
+            params: [],
+         }.dump(),
       };
-      GameEvent::new(d.dump())
+      GameEvent::new(Event{sender: "<generated>".to_string(), body: d.dump(), since: "".to_string()})
    }
 }
 
 impl GameEvent {
-   pub fn new(body: String) -> GameEvent {
+   pub fn new(event: Event) -> GameEvent {
-      let top_level = json::parse(&body);
+      let top_level = json::parse(&event.body.clone());
       if top_level.is_err() {
-         return GameEvent{d: json::Null};
+         return GameEvent{d: json::Null, sender: event.sender.clone()};
       }
       let top_level = top_level.unwrap();
       if !top_level["body"].is_string() {
-         return GameEvent{d: json::Null};
+         return GameEvent{d: json::Null, sender: event.sender.clone()};
       }
       GameEvent{
          d: json::parse(&top_level["body"].as_str().unwrap()).unwrap_or(json::Null),
+         sender: event.sender.clone(),
       }
    }
 
@@ -132,10 +129,10 @@ mod tests {
 
    #[test]
    fn new() {
-      let ge = GameEvent::new("\"a\"".to_string());
+      let ge = GameEvent::new(Event{sender: "".to_string(), body: "\"a\"".to_string(), since: "".to_string()});
       assert!(ge.d.is_null());
 
-      let ge = GameEvent::new("a".to_string());
+      let ge = GameEvent::new(Event{sender: "".to_string(), body: "a".to_string(), since: "".to_string()});
       assert!(ge.d.is_null());
       assert!(ge.mode() == GameEventType::Null);
    }
@@ -184,28 +181,42 @@ mod tests {
 
    #[test]
    fn sources() {
-      let d = json::object!{
+      let d = json::object!{"body": json::object!{"sources": ["a", "b"]}.dump()};
-         "sources": ["a", "b"],
+      let ge = GameEvent::new(Event{sender: "".to_string(), body: d.dump(), since: "".to_string()});
-      };
-      let ge = GameEvent::new(d.dump());
       assert!(ge.sources() == vec!["a", "b"]);
+      assert!(ge.params().len() == 0);
+      assert!(ge.targets().len() == 0);
    }
 
    #[test]
    fn targets() {
-      let ge = GameEvent::new(r#"{"body": "{\"targets\": [\"a\", \"b\"]}"}"#.to_string());
+      let d = json::object!{"body": json::object!{"targets": ["a", "b"]}.dump()};
+      let ge = GameEvent::new(Event{sender: "".to_string(), body: d.dump(), since: "".to_string()});
       assert!(ge.targets() == vec!["a", "b"]);
+      assert!(ge.params().len() == 0);
+      assert!(ge.sources().len() == 0);
    }
 
    #[test]
    fn params() {
-      let ge = GameEvent::new(r#"{"body": "{\"params\": [\"a\", \"b\"]}"}"#.to_string());
+      let empty: Vec<String> = vec![];
+
+      let d = json::object!{"body": json::object!{"params": ["a", "b"]}.dump()};
+      let ge = GameEvent::new(Event{sender: "".to_string(), body: d.dump(), since: "".to_string()});
       assert!(ge.params() == vec!["a", "b"]);
+      assert!(ge.targets().len() == 0);
+      assert!(ge.sources().len() == 0);
 
-      let ge = GameEvent::new(r#"{"body": "{\"params\": []}"}"#.to_string());
+      let d = json::object!{"body": json::object!{"params": []}.dump()};
-      assert!(ge.params().len() == 0);
+      let ge = GameEvent::new(Event{sender: "".to_string(), body: d.dump(), since: "".to_string()});
+      assert!(ge.params() == empty);
+      assert!(ge.targets().len() == 0);
+      assert!(ge.sources().len() == 0);
 
-      let ge = GameEvent::new(r#"{"body": "{}"}"#.to_string());
+      let d = json::object!{"body": json::object!{}.dump()};
-      assert!(ge.params().len() == 0);
+      let ge = GameEvent::new(Event{sender: "".to_string(), body: d.dump(), since: "".to_string()});
+      assert!(ge.params() == empty);
+      assert!(ge.targets().len() == 0);
+      assert!(ge.sources().len() == 0);
    }
 }

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

@@ -1,11 +1,12 @@
 use super::super::super::model::state::room::Room;
 use super::lobby::Lobby;
+use super::player::Player;
 use super::gameevent::GameEvent;
 use super::gameevent::GameEventType;
 
 use std::thread;
 use std::time;
-use log::{info, warn, error, debug};
+use log::{info, debug, LevelFilter};
 
 pub struct GameMaster {
    room: Box<dyn Room>,
@@ -33,30 +34,61 @@ impl GameMaster {
    }
 
    fn run_lobby(&mut self) -> Result<usize, &str> {
+      self.run_lobby_loop()?;
+      self.lobby.ready()
+   }
+
+   fn run_lobby_loop(&mut self) -> Result<usize, &str> {
       while !self.lobby.locked {
-         let rollback = self.room.since();
+         self.run_lobby_scrape()?;
-         let events = self.room.sync();
-         for e in &events {
-            let ge = GameEvent::new(e.body.clone());
-            if ge.mode() == GameEventType::GameStart {
-               self.room.rollback(e.since.clone());
-               self.lobby.lock();
-               return self.lobby.ready();
-            }
-            self.lobby.eat(e.clone());
-         }
          thread::sleep(time::Duration::new(1, 0));
       }
-      return self.lobby.ready();
+      Ok(0)
+   }
+
+   fn run_lobby_scrape(&mut self) -> Result<usize, &str> {
+      /*
+      let rollback = self.room.since();
+      let events = self.room.sync();
+      for e in &events {
+         let ge = GameEvent::new(e.body.clone());
+         if ge.mode() == GameEventType::GameStart {
+            self.room.rollback(e.since.clone());
+            self.lobby.lock();
+            return self.lobby.ready();
+         }
+         self.lobby.eat(e.clone());
+      }
+      */
+      Ok(0)
    }
 
    fn run_game_setup(&mut self) -> Result<String, String> {
+      for player in self.players() {
+         if self.player(player.clone()).is_none() {
+            return Err(format!("missing player {}", player));
+         }
+         debug!("player = {}", player);
+      }
+      debug!("/players");
       Err("not impl".to_string())
    }
 
    fn run_game(&mut self) -> Result<String, String> {
       Err("not impl".to_string())
    }
+
+   fn players(&self) -> Vec<String> {
+      let mut players = vec![];
+      for k in self.lobby.players.keys() {
+         players.push(k.clone());
+      }
+      players
+   }
+
+   fn player(&mut self, id: String) -> Option<&mut Player> {
+      self.lobby.players.get_mut(&id)
+   }
 }
 
 #[cfg(test)]
@@ -67,9 +99,9 @@ mod tests {
    use super::super::super::super::model::state::rooms::Rooms;
 
    fn init() {
-      use env_logger::Env;
       let _ = env_logger::builder()
          .is_test(true)
+         .filter_level(LevelFilter::Trace)
          .try_init();
    }
 
@@ -125,7 +157,12 @@ mod tests {
 
    #[test]
    fn run_game_setup_fail() {
-      assert!(false, "not impl");
+      init();
+      let mut mrs = MockRooms::new();
+      let r1 = mrs.create();
+      let room_id = r1.room_id();
+      let mut gm = GameMaster::new(r1);
+      assert!(gm.run_game_setup().is_ok());
    }
 
    #[test]

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

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

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

@@ -1,5 +1,4 @@
 use super::role::Role;
-use super::role::Roles;
 
 #[derive(Clone, Debug)]
 pub struct Player {
@@ -15,7 +14,7 @@ impl Player {
       }
    }
 
-   fn set_role(&mut self, role: Roles) {
+   pub fn set_role(&mut self, role: Role) {
       self.role.set(role);
    }
 }
@@ -28,4 +27,11 @@ mod tests {
    fn new_player() {
       let _ = Player::new("id".to_string());
    }
+
+   #[test]
+   fn set_role() {
+      let mut p = Player::new("id".to_string());
+      p.set_role(Role::Facist);
+      assert!(p.role == Role::Facist);
+   }
 }

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

@@ -1,10 +1,5 @@
-#[derive(Clone, Debug)]
-pub struct Role {
-   role: Roles,
-}
-
 #[derive(Clone, Debug, PartialEq, Eq)]
-pub enum Roles {
+pub enum Role {
    Null,
    Facist,
    Hitler,
@@ -13,25 +8,23 @@ pub enum Roles {
 
 impl Role {
    pub fn new() -> Role {
-      Role {
+      Role::Null
-         role: Roles::Null,
-      }
    }
 
-   pub fn set(&mut self, role: Roles) {
+   pub fn set(&mut self, role: Role) {
-      self.role = role
+      *self = role.clone()
    }
 
    pub fn is_hitler(&self) -> bool {
-      self.role == Roles::Hitler
+      self == &Role::Hitler
    }
 
    pub fn is_facist(&self) -> bool {
-      self.role == Roles::Facist || self.is_hitler()
+      self == &Role::Facist || self.is_hitler()
    }
 
    pub fn is_liberal(&self) -> bool {
-      self.role == Roles::Liberal
+      self == &Role::Liberal
    }
 }
 
@@ -47,70 +40,70 @@ mod tests {
    #[test]
    fn set() {
       let mut r = Role::new();
-      r.set(Roles::Facist);
+      r.set(Role::Facist);
-      assert!(r.role == Roles::Facist);
+      assert!(r == Role::Facist);
    }
 
    #[test]
    fn is_hitler_liberal() {
       let mut r = Role::new();
-      r.set(Roles::Liberal);
+      r.set(Role::Liberal);
       assert!(!r.is_hitler());
    }
 
    #[test]
    fn is_hitler_facist() {
       let mut r = Role::new();
-      r.set(Roles::Facist);
+      r.set(Role::Facist);
       assert!(!r.is_hitler());
    }
 
    #[test]
    fn is_hitler_yes() {
       let mut r = Role::new();
-      r.set(Roles::Hitler);
+      r.set(Role::Hitler);
       assert!(r.is_hitler());
    }
 
    #[test]
    fn is_facist_liberal() {
       let mut r = Role::new();
-      r.set(Roles::Liberal);
+      r.set(Role::Liberal);
       assert!(!r.is_facist());
    }
 
    #[test]
    fn is_facist_facist() {
       let mut r = Role::new();
-      r.set(Roles::Facist);
+      r.set(Role::Facist);
       assert!(r.is_facist());
    }
 
    #[test]
    fn is_facist_hitler() {
       let mut r = Role::new();
-      r.set(Roles::Hitler);
+      r.set(Role::Hitler);
       assert!(r.is_facist());
    }
 
    #[test]
    fn is_liberal_liberal() {
       let mut r = Role::new();
-      r.set(Roles::Liberal);
+      r.set(Role::Liberal);
       assert!(r.is_liberal());
    }
 
    #[test]
    fn is_liberal_facist() {
       let mut r = Role::new();
-      r.set(Roles::Facist);
+      r.set(Role::Facist);
       assert!(!r.is_liberal());
    }
 
    #[test]
    fn is_liberal_hitler() {
       let mut r = Role::new();
-      r.set(Roles::Hitler);
+      r.set(Role::Hitler);
       assert!(!r.is_liberal());
    }
 }

secert-hitler/src/main.rs

@@ -3,14 +3,14 @@ mod controller;
 mod model;
 mod view;
 
-use self::model::state::rooms::Rooms;
 
-#[macro_use] extern crate log;
+use env_logger;
-use env_logger::Env;
 
 fn main() {
    env_logger::init();
    println!("{}", config::PORT);
+   /*
+use self::model::state::rooms::Rooms;
    let mut rooms = get_rooms();
    let room = rooms.create();
    let mut gamemaster = controller::gamemaster::gamemaster::GameMaster::new(room);
@@ -19,4 +19,5 @@ fn main() {
 
 fn get_rooms() -> impl Rooms {
    model::state::mockrooms::MockRooms::new()
+   */
 }