120 lines
3.3 KiB
Rust
120 lines
3.3 KiB
Rust
use super::super::super::model::state::room::Room;
|
|
use super::lobby::Lobby;
|
|
use super::gameevent::GameEvent;
|
|
use super::gameevent::GameEventType;
|
|
use std::thread;
|
|
use std::time;
|
|
|
|
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(&mut self) -> Result<String, String> {
|
|
self.run_lobby()?;
|
|
self.run_game_setup()?;
|
|
self.run_game()
|
|
}
|
|
|
|
fn run_lobby(&mut self) -> Result<String, String> {
|
|
while !self.lobby.locked {
|
|
let rollback = self.room.since();
|
|
let events = self.room.sync();
|
|
println!("top of loop: since={:?}, events={:?}", self.room.since(), events);
|
|
for e in &events {
|
|
let ge = GameEvent::new(e.body.clone());
|
|
println!(" ge.mode = {:?}", ge.mode());
|
|
if ge.mode() == GameEventType::GameStart {
|
|
println!(" should return");
|
|
self.room.rollback(e.since.clone());
|
|
self.lobby.lock();
|
|
return Ok("ok".to_string());
|
|
}
|
|
self.lobby.eat(e.clone());
|
|
}
|
|
thread::sleep(time::Duration::new(1, 0));
|
|
}
|
|
Ok("ok".to_string()) // todo: on lobby too small, return err and do not lock
|
|
}
|
|
|
|
fn run_game_setup(&mut self) -> Result<String, String> {
|
|
Err("not impl".to_string())
|
|
}
|
|
|
|
fn run_game(&mut self) -> Result<String, String> {
|
|
Err("not impl".to_string())
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use super::super::super::super::model::state::mockroom::MockRoom;
|
|
use super::super::super::super::model::state::mockrooms::MockRooms;
|
|
use super::super::super::super::model::state::rooms::Rooms;
|
|
|
|
#[test]
|
|
fn new_mockroom() {
|
|
let _ = GameMaster::new(Box::new(MockRoom::create()));
|
|
}
|
|
|
|
#[test]
|
|
fn new_rooms_mockrooms() {
|
|
fn get() -> impl Rooms {
|
|
let mrs = MockRooms::new();
|
|
mrs
|
|
}
|
|
let mut mrs = get();
|
|
let r = mrs.create();
|
|
let _ = GameMaster::new(r);
|
|
}
|
|
|
|
#[test]
|
|
fn new_mockrooms() {
|
|
let mut mrs = MockRooms::new();
|
|
let r = mrs.create();
|
|
let _ = GameMaster::new(r);
|
|
}
|
|
|
|
#[test]
|
|
fn run_lobby() {
|
|
let mut mrs = MockRooms::new();
|
|
let r1 = mrs.create();
|
|
let room_id = r1.room_id();
|
|
let mut gm = GameMaster::new(r1);
|
|
let mut r2 = mrs.join(room_id).unwrap();
|
|
r2.send(format!(r#"{{
|
|
"msgtype": "m.text",
|
|
"body": "{{\"GameEventType\": \"GameStart\"}}"
|
|
}}"#)).unwrap(); // TODO mark end of new players
|
|
gm.run_lobby(); // todo assert is_ok
|
|
assert!(gm.lobby.players.len() == 2, "first run_lobby players: {:?}, sync: {:?}", gm.lobby.players, gm.room.sync());
|
|
let mut players1 = vec![];
|
|
for k in gm.lobby.players.keys() {
|
|
players1.push(k.clone());
|
|
}
|
|
gm.run_lobby(); // todo assert is_ok
|
|
assert!(gm.lobby.players.len() == 2, "secnd run_lobby players: {:?}, sync: {:?}", gm.lobby.players, gm.room.sync());
|
|
let players2 = gm.lobby.players.keys();
|
|
assert!(format!("{:?}", players1) == format!("{:?}", players2));
|
|
}
|
|
|
|
#[test]
|
|
fn run_game_setup_fail() {
|
|
assert!(false, "not impl");
|
|
}
|
|
|
|
#[test]
|
|
fn run_game_fail() {
|
|
assert!(false, "not impl");
|
|
}
|
|
}
|