Merge branch 'master' of ssh://mnml.gg:40022/~/mnml

server/src/game.rs

@@ -162,13 +162,14 @@ impl Game {
             return self.finish();
         }
 
-        self.skill_phase_start()
+        self.skill_phase_start(0)
     }
 
-    fn skill_phase_start(mut self) -> Game {
+    fn skill_phase_start(mut self, num_resolutions: usize) -> Game {
+        let phase_add_time_ms = 60000 + num_resolutions * 2500;
         self.phase_start = Utc::now();
         self.phase_end = Utc::now()
-            .checked_add_signed(Duration::seconds(60))
+            .checked_add_signed(Duration::milliseconds(phase_add_time_ms as i64))
             .expect("could not set phase end");
 
         for player in self.players.iter_mut() {
@@ -426,12 +427,14 @@ impl Game {
         // temp vec of this round's resolving skills
         // because need to check cooldown use before pushing them into the complete list
         let mut casts = vec![];
+        let mut turn_events = 0;
 
         while let Some(cast) = self.stack.pop() {
             // info!("{:} casts ", cast);
 
             let mut resolutions = resolution_steps(&cast, &mut self);
             resolutions.reverse();
+            turn_events += resolutions.len();
             while let Some(resolution) = resolutions.pop() {
                 self.log_resolution(cast.speed, &resolution);
                 // the results go into the resolutions
@@ -455,7 +458,7 @@ impl Game {
             return self.finish()
         }
 
-        self.skill_phase_start()
+        self.skill_phase_start(turn_events)
     }
 
     fn progress_durations(&mut self, resolved: &Vec<Cast>) -> &mut Game {

server/src/instance.rs

@@ -30,6 +30,12 @@ enum InstancePhase {
     Finished,
 }
 
+#[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
+enum Format {
+    Standard,
+    RoundRobin,
+}
+
 #[derive(Debug,Clone,Serialize,Deserialize)]
 struct Round {
     player_ids: Vec<Uuid>,
@@ -40,15 +46,21 @@ struct Round {
 #[derive(Debug,Clone,Serialize,Deserialize)]
 pub struct Instance {
     id: Uuid,
+    pub name: String,
+
     players: Vec<Player>,
-    phase: InstancePhase,
     rounds: Vec<Vec<Round>>,
+
     open: bool,
     max_players: usize,
     max_rounds: usize,
     password: Option<String>,
-    pub name: String,
+
+    phase: InstancePhase,
     phase_end: DateTime<Utc>,
+    phase_start: DateTime<Utc>,
+
+    format: Format,
 }
 
 impl Instance {
@@ -64,6 +76,9 @@ impl Instance {
             name: String::new(),
             password: None,
             phase_end: Utc::now(),
+            phase_start: Utc::now(),
+
+            format: Format::RoundRobin,
         }
     }
 
@@ -78,7 +93,10 @@ impl Instance {
             max_rounds: 1,
             name: "Global Matchmaking".to_string(),
             password: None,
+            phase_start: Utc::now(),
             phase_end: Utc::now(),
+
+            format: Format::Standard,
         }
     }
 
@@ -131,12 +149,8 @@ impl Instance {
         Ok(self)
     }
 
-    fn set_max_rounds(mut self, rounds: usize) -> Result<Instance, Error> {
-        if rounds == 0 {
-            return Err(err_msg("max rounds must be nonzero"));
-        }
-
-        self.max_rounds = rounds;
+    fn set_format(mut self, format: Format) -> Result<Instance, Error> {
+        self.format = format;
         Ok(self)
     }
 
@@ -273,16 +287,17 @@ impl Instance {
     }
 
     fn next_round(&mut self) -> &mut Instance {
-        self.phase = InstancePhase::InProgress;
-        self.phase_end = Utc::now()
-            .checked_add_signed(Duration::seconds(15000))
-            .expect("could not set phase end");
-
-
-        if self.rounds.len() >= self.max_rounds {
+        if self.win_condition() {
             return self.finish();
         }
 
+        self.phase = InstancePhase::InProgress;
+        self.phase_start = Utc::now();
+        self.phase_end = Utc::now()
+            .checked_add_signed(Duration::seconds(120))
+            .expect("could not set phase end");
+
+
         self.players.iter_mut().for_each(|p| {
             p.set_ready(false);
             p.vbox.fill();
@@ -294,6 +309,13 @@ impl Instance {
         self
     }
 
+    fn win_condition(&self) -> bool {
+        match self.format {
+            Format::Standard => self.players.iter().any(|p| p.score.wins > 2),
+            Format::RoundRobin => self.rounds.len() == self.players.len() / 2,
+        }
+    }
+
     fn finish(&mut self) -> &mut Instance {
         self.phase = InstancePhase::Finished;
         self
@@ -732,7 +754,7 @@ mod tests {
     fn instance_pve_test() {
         let mut instance = Instance::new()
             .set_max_players(16).expect("unable to set max players")
-            .set_max_rounds(2).expect("max rounds failure")
+            .set_format(Format::RoundRobin).expect("format failure")
             .add_bots();
 
         let player_account = Uuid::new_v4();
@@ -747,12 +769,12 @@ mod tests {
 
         assert_eq!(instance.phase, InstancePhase::Finished);
         assert_eq!(instance.rounds[0].len(), 8);
-        assert_eq!(instance.rounds.len(), 2);
+        assert_eq!(instance.rounds.len(), 8);
     }
 
     #[test]
     fn instance_bot_vbox_test() {
-        let instance = Instance::new();
+        let _instance = Instance::new();
         let player_account = Uuid::new_v4();
         let constructs = instance_mobs(player_account);
         let _player = Player::new(player_account, &"test".to_string(), constructs).set_bot(true);
@@ -802,8 +824,8 @@ mod tests {
     #[test]
     fn instance_upkeep_test() {
         let mut instance = Instance::new()
-            .set_max_players(2)
-            .expect("could not create instance");
+            .set_max_players(2).expect("could not create instance")
+            .set_format(Format::Standard).expect("format err");
 
         let player_account = Uuid::new_v4();
         let constructs = instance_mobs(player_account);