Merge branch 'resolutions'

server/src/cryp.rs

@@ -9,7 +9,7 @@ use failure::err_msg;
 
 use account::Account;
 use rpc::{CrypSpawnParams, CrypLearnParams, CrypForgetParams};
-use skill::{Skill, Cooldown, Effect, Cast, Source};
+use skill::{Skill, Cooldown, Effect, Cast, Immunity};
 use game::{Log};
 
 #[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
@@ -29,7 +29,7 @@ impl CrypSkill {
     }
 }
 
-#[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
+#[derive(Debug,Clone,PartialEq,Serialize,Deserialize)]
 pub struct CrypEffect {
     pub effect: Effect,
     pub duration: u8,
@@ -178,17 +178,17 @@ impl Cryp {
         self.hp.base == 0
     }
 
-    pub fn immune(&self, skill: Skill) -> (bool, Vec<Effect>) {
+    pub fn immune(&self, skill: Skill) -> Immunity {
         let immunities = self.effects.iter()
             .filter(|e| e.effect.immune(skill))
             .map(|e| e.effect)
             .collect::<Vec<Effect>>();
 
         if immunities.len() > 0 {
-            return (true, immunities);
+            return Immunity { immune: true, effects: immunities};
         }
 
-        return (false, vec![]);
+        return Immunity { immune: false, effects: vec![]};
     }
 
     pub fn is_stunned(&self) -> bool {

server/src/game.rs

@@ -12,7 +12,7 @@ use failure::err_msg;
 use account::Account;
 use rpc::{GameStateParams, GameSkillParams, GamePveParams, GamePvpParams, GameTargetParams, GameJoinParams};
 use cryp::{Cryp, cryp_get};
-use skill::{Skill, Cast};
+use skill::{Skill, Cast, ResolutionResult};
 
 pub type Log = Vec<String>;
 
@@ -363,6 +363,24 @@ impl Game {
         self.resolve_skills()
     }
 
+    fn log_resolution(&mut self, source: &Cryp, target: &Cryp, cast: &Cast) -> &mut Game {
+        for result in cast.resolution.results.iter() {
+            match result {
+                ResolutionResult::Damage { amount, category: _, immunity: _ } => {
+                    self.log.push(format!("{:?} {:?} {:?} {:?}", source.name, cast.skill, target.name, amount));
+                },
+                ResolutionResult::Effect { effect, duration, immunity: _ } => {
+                    self.log.push(format!("{:?} {:?} {:?} {:?} {:?}T", source.name, cast.skill, target.name, effect, duration));
+                },
+                ResolutionResult::Removal { effect, immunity: _ } => {
+                    self.log.push(format!("{:?} removed {:?} {:?}", source.name, target.name, effect));
+                },
+            }
+        }
+
+        self
+    }
+
     fn resolve_skills(&mut self) -> &mut Game {
         if self.phase != Phase::Resolve {
             panic!("game not in Resolve phase");
@@ -374,6 +392,7 @@ impl Game {
             .flat_map(
                 |c| c.effects
                     .iter()
+                    .cloned()
                     .filter_map(|e| e.tick))
                     .collect::<Vec<Cast>>();
 
@@ -389,10 +408,11 @@ impl Game {
             let mut source = self.cryp_by_id(skill.source_cryp_id).unwrap().clone();
             let mut target = self.cryp_by_id(skill.target_cryp_id.unwrap()).unwrap().clone();
 
-            // self.log.push(format!("{:?} uses {:?} on {:?}", source.name, skill.skill, target.name));
+            skill.set_resolution(&mut source, &mut target);
-            skill.set_resolution(&mut source, &mut target, &mut self.log);
-            self.resolved.push(skill.clone());
 
+            self.log_resolution(&source, &target, skill);
+
+            self.resolved.push(skill.clone());
 
             self.update_cryp(&mut source);
             self.update_cryp(&mut target);
@@ -444,6 +464,15 @@ impl Game {
 
     fn finish(&mut self) -> &mut Game {
         self.phase = Phase::Finish;
+        self.log.push(format!("Game finished."));
+
+        {
+            let winner = self.teams.iter().find(|t| t.cryps.iter().any(|c| !c.is_ko()));
+            match winner {
+                Some(w) => self.log.push(format!("Winner: {:?}", w.id)),
+                None => self.log.push(format!("Game was drawn.")),
+            };
+        }
 
         self.stack.clear();
 
@@ -761,7 +790,7 @@ mod tests {
     use cryp::*;
 
     fn create_test_game() -> Game {
-        let mut x = Cryp::new()
+        let x = Cryp::new()
             .named(&"pronounced \"creeep\"".to_string())
             .level(8)
             .learn(Skill::TestStun)
@@ -809,58 +838,58 @@ mod tests {
         return game;
     }
 
-    fn create_2v2_test_game() -> Game {
+    // fn create_2v2_test_game() -> Game {
-        let mut i = Cryp::new()
+    //     let mut i = Cryp::new()
-            .named(&"pretaliate".to_string())
+    //         .named(&"pretaliate".to_string())
-            .level(8)
+    //         .level(8)
-            .learn(Skill::Attack)
+    //         .learn(Skill::Attack)
-            .create();
+    //         .create();
 
-        let mut j = Cryp::new()
+    //     let mut j = Cryp::new()
-            .named(&"poy sian".to_string())
+    //         .named(&"poy sian".to_string())
-            .level(8)
+    //         .level(8)
-            .learn(Skill::Attack)
+    //         .learn(Skill::Attack)
-            .create();
+    //         .create();
 
-        let mut x = Cryp::new()
+    //     let mut x = Cryp::new()
-            .named(&"pronounced \"creeep\"".to_string())
+    //         .named(&"pronounced \"creeep\"".to_string())
-            .level(8)
+    //         .level(8)
-            .learn(Skill::Attack)
+    //         .learn(Skill::Attack)
-            .create();
+    //         .create();
 
-        let mut y = Cryp::new()
+    //     let mut y = Cryp::new()
-            .named(&"lemongrass tea".to_string())
+    //         .named(&"lemongrass tea".to_string())
-            .level(8)
+    //         .level(8)
-            .learn(Skill::Attack)
+    //         .learn(Skill::Attack)
-            .create();
+    //         .create();
 
-        let mut game = Game::new();
+    //     let mut game = Game::new();
 
-        game
+    //     game
-            .set_team_num(2)
+    //         .set_team_num(2)
-            .set_team_size(2)
+    //         .set_team_size(2)
-            .set_pve(false);
+    //         .set_pve(false);
 
-        let x_team_id = Uuid::new_v4();
+    //     let x_team_id = Uuid::new_v4();
-        let mut x_team = Team::new(x_team_id);
+    //     let mut x_team = Team::new(x_team_id);
-        x_team
+    //     x_team
-            .set_cryps(vec![x]);
+    //         .set_cryps(vec![x]);
 
-        let y_team_id = Uuid::new_v4();
+    //     let y_team_id = Uuid::new_v4();
-        let mut y_team = Team::new(y_team_id);
+    //     let mut y_team = Team::new(y_team_id);
-        y_team
+    //     y_team
-            .set_cryps(vec![y]);
+    //         .set_cryps(vec![y]);
 
-        game
+    //     game
-            .team_add(x_team).unwrap()
+    //         .team_add(x_team).unwrap()
-            .team_add(y_team).unwrap();
+    //         .team_add(y_team).unwrap();
 
-        assert!(game.can_start());
+    //     assert!(game.can_start());
 
-        game.start();
+    //     game.start();
 
-        return game;
+    //     return game;
-    }
+    // }
 
     #[test]
     fn phase_test() {
@@ -1045,6 +1074,8 @@ mod tests {
 
         assert!([Phase::Skill, Phase::Finish].contains(&game.phase));
 
+        println!("{:#?}", game);
+
         return;
     }