the beginninging

server/src/cryp.rs

@@ -64,6 +64,7 @@ impl CrypSkill {
 pub enum EffectMeta {
     TickAmount(u64),
     AddedDamage(u64),
+    ScatterTarget(Uuid),
 }
 
 #[derive(Debug,Clone,PartialEq,Serialize,Deserialize)]

server/src/game.rs

@@ -14,7 +14,7 @@ use failure::err_msg;
 use account::Account;
 use rpc::{GameStateParams, GameSkillParams};
 use cryp::{Cryp};
-use skill::{Skill, Effect, Cast, Resolution, Event, resolve};
+use skill::{Skill, Effect, Cast, Resolution, Event, resolution_steps};
 use player::{Player};
 use instance::{instance_game_finished, global_game_finished};
 use util::{IntPct};
@@ -133,7 +133,7 @@ impl Game {
                     .collect::<Vec<Cryp>>()
     }
 
-    fn update_cryp(&mut self, cryp: &mut Cryp) -> &mut Game {
+    pub fn update_cryp(&mut self, cryp: &mut Cryp) -> &mut Game {
         match self.players.iter_mut().find(|t| t.cryps.iter().any(|c| c.id == cryp.id)) {
             Some(player) => {
                 let index = player.cryps.iter().position(|t| t.id == cryp.id).unwrap();
@@ -373,7 +373,7 @@ impl Game {
             .collect()
     }
 
-    fn get_targets(&self, skill: Skill, source: &Cryp, target_cryp_id: Uuid) -> Vec<Uuid> {
+    pub fn get_targets(&self, skill: Skill, source: &Cryp, target_cryp_id: Uuid) -> Vec<Uuid> {
         let target_player = self.players.iter()
             .find(|t| t.cryps.iter().any(|c| c.id == target_cryp_id))
             .unwrap();
@@ -415,19 +415,7 @@ impl Game {
         while let Some(cast) = self.stack.pop() {
             // println!("{:} casts ", cast);
 
-            let mut resolutions = vec![];
-            let mut source = self.cryp_by_id(cast.source_cryp_id).unwrap().clone();
-
-            let targets = self.get_targets(cast.skill, &source, cast.target_cryp_id);
-            for target_id in targets {
-                let mut source = self.cryp_by_id(cast.source_cryp_id).unwrap().clone();
-                let mut target = self.cryp_by_id(target_id).unwrap().clone();
-                resolutions = resolve(cast.skill, &mut source, &mut target, resolutions);
-                // save the clones
-                self.update_cryp(&mut source);
-                self.update_cryp(&mut target);
-            }
-
+            let mut resolutions = resolution_steps(&cast, &mut self);
             resolutions.reverse();
             while let Some(resolution) = resolutions.pop() {
                 self.log_resolution(cast.speed, &resolution);

server/src/skill.rs

@@ -5,6 +5,33 @@ use util::{IntPct};
 use cryp::{Cryp, CrypEffect, EffectMeta, Stat};
 use vbox::{Var};
 
+use game::{Game};
+
+pub fn resolution_steps(cast: &Cast, game: &mut Game) -> Resolutions {
+    let mut resolutions = vec![];
+
+    resolutions = pre_resolve(cast, game, resolutions);
+
+    return resolutions;
+}
+
+pub fn pre_resolve(cast: &Cast, game: &mut Game, mut resolutions: Resolutions) -> Resolutions {
+    let skill = cast.skill;
+    let mut source = game.cryp_by_id(cast.source_cryp_id).unwrap().clone();
+
+    let targets = game.get_targets(cast.skill, &source, cast.target_cryp_id);
+    for target_id in targets {
+        let mut source = game.cryp_by_id(cast.source_cryp_id).unwrap().clone();
+        let mut target = game.cryp_by_id(target_id).unwrap().clone();
+        resolutions = resolve(cast.skill, &mut source, &mut target, resolutions);
+        // save the clones
+        game.update_cryp(&mut source);
+        game.update_cryp(&mut target);
+    }
+
+    return resolutions;
+}
+
 pub fn resolve(skill: Skill, source: &mut Cryp, target: &mut Cryp, mut resolutions: Vec<Resolution>) -> Resolutions {
     if let Some(disable) = source.disabled(skill) {
         resolutions.push(Resolution::new(source, target).event(Event::Disable { disable, skill }));
@@ -25,6 +52,10 @@ pub fn resolve(skill: Skill, source: &mut Cryp, target: &mut Cryp, mut resolutio
         return resolve(skill, target, source, resolutions);
     }
 
+    if target.affected(Effect::Scatter) {
+        resolutions = resolve(skill, target, source, resolutions);
+    }
+
     // match self.category() == Category::Red {
     //     true => {
     //         if let Some(evasion) = target.evade(*self) {
@@ -1233,13 +1264,12 @@ fn silence(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, skill
     let silence = CrypEffect::new(Effect::Silence, skill.duration());
     results.push(Resolution::new(source, target).event(target.add_effect(skill, silence)));
 
-    let mut s_multi: u64 = 100;
-    for cs in target.skills.iter() {
-        s_multi += match cs.skill.category() {
-            Category::Blue => 45,
-            _ => 0,
-        }
-    }
+    let s_multi = target.skills
+        .iter()
+        .fold(100, |acc, cs| match cs.skill.category() {
+            Category::Blue => acc + 45,
+            _ => acc,
+        });
 
     let amount = source.blue_damage().pct(skill.multiplier()).pct(s_multi);
     target.deal_blue_damage(skill, amount)