ntr/mnml
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fix forfeit waiting on game phase timeout

Browse Source
This commit is contained in:
ntr 2019-09-10 11:56:09 +10:00
parent 5874f040ad
commit f002e9e283
2 changed files with 27 additions and 16 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
server/src/instance.rs
View File

@ -17,7 +17,7 @@ use events::{EventsTx, Event};
use player::{Player, Score, player_create}; use player::{Player, Score, player_create};
use construct::{Construct, construct_get}; use construct::{Construct, construct_get};
use mob::{bot_player, instance_mobs}; use mob::{bot_player, instance_mobs};
use game::{Game, Phase, game_get, game_write}; use game::{Game, Phase, game_get, game_write, game_update};
use item::{Item}; use item::{Item};
use rpc::{RpcMessage}; use rpc::{RpcMessage};
use img; use img;
@ -51,7 +51,7 @@ pub enum TimeControl {
impl TimeControl { impl TimeControl {
fn vbox_time_seconds(&self) -> i64 { fn vbox_time_seconds(&self) -> i64 {
match self { match self {
TimeControl::Standard => 180, TimeControl::Standard => 10,
TimeControl::Slow => 240, TimeControl::Slow => 240,
TimeControl::Practice => panic!("practice vbox seconds called"), TimeControl::Practice => panic!("practice vbox seconds called"),
} }
@ -59,7 +59,7 @@ impl TimeControl {
fn game_time_seconds(&self) -> i64 { fn game_time_seconds(&self) -> i64 {
match self { match self {
TimeControl::Standard => 60, TimeControl::Standard => 10,
TimeControl::Slow => 120, TimeControl::Slow => 120,
TimeControl::Practice => panic!("practice game seconds called"), TimeControl::Practice => panic!("practice game seconds called"),
} }
@ -139,28 +139,30 @@ impl Instance {
.collect::<Vec<Uuid>>() .collect::<Vec<Uuid>>()
} }
pub fn upkeep(mut self) -> (Instance, Vec<Game>) { pub fn upkeep(mut self) -> (Instance, Option<Game>) {
// time out lobbies that have been open too long // time out lobbies that have been open too long
if self.phase == InstancePhase::Lobby && self.phase_timed_out() { if self.phase == InstancePhase::Lobby && self.phase_timed_out() {
self.finish(); self.finish();
return (self, vec![]); return (self, None);
} }
if self.phase != InstancePhase::InProgress { if self.phase != InstancePhase::InProgress {
return (self, vec![]); return (self, None);
} }
if !self.phase_timed_out() { if !self.phase_timed_out() {
return (self, vec![]); return (self, None);
} }
let new_games = self let new_game = self
.timed_out_players() .timed_out_players()
.iter() .iter()
.filter_map(|p| self.player_ready(*p).unwrap()) .filter_map(|p| self.player_ready(*p).unwrap())
.collect::<Vec<Game>>(); .collect::<Vec<Game>>()
.into_iter()
.next();
(self, new_games) (self, new_game)
} }
fn set_name(mut self, name: String) -> Result<Instance, Error> { fn set_name(mut self, name: String) -> Result<Instance, Error> {
@ -731,6 +733,10 @@ pub fn instance_ready(tx: &mut Transaction, account: &Account, instance_id: Uuid
if let Some(game) = instance.player_ready(player_id)? { if let Some(game) = instance.player_ready(player_id)? {
game_write(tx, &game)?; game_write(tx, &game)?;
// ensures cleanup for warden etc is done
game_update(tx, &game)?;
instance_update(tx, instance)?; instance_update(tx, instance)?;
return Ok(RpcMessage::GameState(game)); return Ok(RpcMessage::GameState(game));
} }
@ -862,12 +868,12 @@ mod tests {
let (mut instance, new_games) = instance.upkeep(); let (mut instance, new_games) = instance.upkeep();
assert_eq!(new_games.len(), 1); assert!(new_games.is_some());
let game = &new_games[0]; let game = new_games.unwrap();
assert!(game.finished()); assert!(game.finished());
instance.game_finished(game).unwrap(); instance.game_finished(&game).unwrap();
assert_eq!(instance.rounds.len(), 2); assert_eq!(instance.rounds.len(), 2);
assert!(instance.players.iter().all(|p| !p.ready)); assert!(instance.players.iter().all(|p| !p.ready));

11
server/src/warden.rs
View File

@ -131,11 +131,16 @@ fn fetch_games(mut tx: Transaction) -> Result<Transaction, Error> {
fn fetch_instances(mut tx: Transaction) -> Result<Transaction, Error> { fn fetch_instances(mut tx: Transaction) -> Result<Transaction, Error> {
for mut instance in instances_need_upkeep(&mut tx)? { for mut instance in instances_need_upkeep(&mut tx)? {
let (instance, new_games) = instance.upkeep(); let (instance, new_game) = instance.upkeep();
for game in new_games {
if let Some(game) = new_game {
game_write(&mut tx, &game)?; game_write(&mut tx, &game)?;
}
instance_update(&mut tx, instance)?; instance_update(&mut tx, instance)?;
// ensures cleanup for forfeits etc is done
game_update(&mut tx, &game)?;
} else {
instance_update(&mut tx, instance)?;
}
} }
for mut instance in instances_idle(&mut tx)? { for mut instance in instances_idle(&mut tx)? {