player box

server/src/instance.rs

@@ -14,7 +14,7 @@ use chrono::Duration;
 use account::Account;
 use account;
 use events::{EventsTx, Event};
-use player::{Player, player_create};
+use player::{Player, Score, player_create};
 use construct::{Construct, construct_get};
 use mob::{bot_player, instance_mobs};
 use game::{Game, Phase, game_get, game_write};
@@ -318,14 +318,14 @@ impl Instance {
 
         // tennis
         for player in self.players.iter() {
-            if player.wins >= 4 && player.wins >= player.losses + 2 {
+            if player.score == Score::Win {
                 self.winner = Some(player.id);
                 return true;
             }
         }
 
         // both players afk
-        if self.players.iter().all(|p| p.wins == 0) {
+        if self.players.iter().all(|p| p.score == Score::Zero) {
             return true;
         }
 
@@ -403,12 +403,25 @@ impl Instance {
             None => return Ok(self.finish()),
         };
 
-        for player in game.players.iter() {
-            let mut player = self.account_player(player.id)?;
-            match player.id == winner_id {
-                true => player.add_win(),
-                false => player.add_loss(),
-            };
+        {
+            let loser = self.players.iter()
+                .find(|p| p.id != winner_id)
+                .map(|p| p.score)
+                .unwrap();
+
+            let winner = self.players.iter_mut()
+                .find(|p| p.id == winner_id)
+                .unwrap();
+
+            winner.score = winner.score.add_win(&loser);
+        }
+
+        {
+            let loser = self.players.iter_mut()
+                .find(|p| p.id != winner_id)
+                .unwrap();
+
+            loser.score = loser.score.add_loss();
         }
 
         if self.all_games_finished() {

server/src/player.rs

@@ -14,6 +14,43 @@ use effect::{Effect};
 
 const DISCARD_COST: u16 = 2;
 
+#[derive(Debug,Copy,Clone,Serialize,Deserialize,Eq,PartialEq)]
+pub enum Score {
+    Zero,
+    One,
+    Two,
+    Three,
+    Adv,
+
+    Win,
+    Lose,
+}
+
+impl Score {
+    pub fn add_win(self, opp: &Score) -> Score {
+        match self {
+            Score::Zero => Score::One,
+            Score::One => Score::Two,
+            Score::Two => Score::Three,
+            Score::Three => match opp {
+                Score::Adv => Score::Three,
+                Score::Three => Score::Adv,
+                _ => Score::Win,
+            }
+            Score::Adv => Score::Win,
+            _ => panic!("faulty score increment {:?}", self),
+        }
+    }
+
+    pub fn add_loss(self) -> Score {
+        match self {
+            Score::Adv => Score::Three,
+            _ => self,
+        }
+    }
+
+}
+
 #[derive(Debug,Clone,Serialize,Deserialize)]
 pub struct Player {
     pub id: Uuid,
@@ -23,8 +60,7 @@ pub struct Player {
     pub bot: bool,
     pub ready: bool,
     pub warnings: u8,
-    pub wins: u8,
-    pub losses: u8,
+    pub score: Score,
 }
 
 impl Player {
@@ -33,12 +69,11 @@ impl Player {
             id: account,
             name: name.clone(),
             vbox: Vbox::new(),
-            wins: 0,
-            losses: 0,
             constructs,
             bot: false,
             ready: false,
             warnings: 0,
+            score: Score::Zero,
         }
     }
 
@@ -64,21 +99,6 @@ impl Player {
         self
     }
 
-    pub fn add_win(&mut self) -> &mut Player {
-        self.wins += 1;
-        let win_bonus = 12 + 6 * (self.wins + self.losses);
-        self.vbox.balance_add(win_bonus.into());
-        self
-    }
-
-    pub fn add_loss(&mut self) -> &mut Player {
-        self.losses += 1;
-        let loss_bonus = 12 + 6 * (self.wins + self.losses);
-        self.vbox.balance_add(loss_bonus.into());
-        self
-    }
-
-
     pub fn construct_get(&mut self, id: Uuid) -> Result<&mut Construct, Error> {
         self.constructs.iter_mut().find(|c| c.id == id).ok_or(err_msg("construct not found"))
     }
@@ -336,4 +356,32 @@ mod tests {
 
         assert!(player.constructs.iter().all(|c| c.skills.len() >= 1));
     }
+
+    #[test]
+    fn player_score_test() {
+        let player_account = Uuid::new_v4();
+        let constructs = instance_mobs(player_account);
+        let mut player = Player::new(player_account, &"test".to_string(), constructs).set_bot(true);
+
+        player.score = player.score.add_win(&Score::Zero);
+        player.score = player.score.add_win(&Score::Zero);
+        player.score = player.score.add_win(&Score::Zero);
+        assert_eq!(player.score, Score::Three); // 40 / 0
+
+        player.score = player.score.add_loss(); // adv -> deuce
+        assert_eq!(player.score, Score::Three);
+
+        player.score = player.score.add_loss(); // adv -> deuce
+        assert_eq!(player.score, Score::Three);
+
+        player.score = player.score.add_win(&Score::Adv); // opp adv -> stays deuce
+        assert_eq!(player.score, Score::Three);
+
+        player.score = player.score.add_win(&Score::Three);
+        assert_eq!(player.score, Score::Adv);
+
+        player.score = player.score.add_win(&Score::Three);
+        assert_eq!(player.score, Score::Win);
+    }
+
 }

server/src/skill.rs

@@ -2113,8 +2113,8 @@ mod tests {
             .learn(Skill::HealPlus);
 
         purge(&mut x, &mut y, vec![], Skill::Purge);
-        // 2 turns at lvl 1
-        assert!(y.effects.iter().any(|e| e.effect == Effect::Purge && e.duration == 2));
+        // current turn + 2 turns at lvl 1
+        assert!(y.effects.iter().any(|e| e.effect == Effect::Purge && e.duration == 3));
         assert!(y.disabled(Skill::Heal).is_some());
     }
 }