dmg returns vec of events now to clean up log

server/src/cryp.rs

@@ -456,12 +456,14 @@ impl Cryp {
         Event::Recharge { red, blue, skill }
     }
 
-    pub fn deal_green_damage(&mut self, skill: Skill, amount: u64) -> Event {
+    pub fn deal_green_damage(&mut self, skill: Skill, amount: u64) -> Vec<Event> {
+        let mut events = vec![];
         if let Some(immunity) = self.immune(skill) {
-            return Event::Immunity {
+            events.push(Event::Immunity {
                 immunity,
                 skill,
-            };
+            });
+            return events;
         }
 
         let healing_mods = self.effects.iter()
@@ -471,46 +473,52 @@ impl Cryp {
 
         // println!("{:?}", healing_mods);
 
-        let modified_healing = healing_mods.iter().fold(amount, |acc, m| m.apply(acc));
+        let modified_green_damage = healing_mods.iter().fold(amount, |acc, m| m.apply(acc));
 
         match self.affected(Effect::Invert) {
             false => {
                 let current_hp = self.hp();
-                self.hp.increase(modified_healing);
+                self.hp.increase(modified_green_damage);
                 let new_hp = self.hp.value;
 
                 let healing = new_hp - current_hp;
-                let overhealing = modified_healing - healing;
+                let overhealing = modified_green_damage - healing;
 
-                return Event::Healing {
+                events.push(Event::Healing {
                     skill,
                     amount: healing,
                     overhealing,
-                };
+                });
             },
             true => {
+                events.push(Event::Inversion { skill });
+
                 // there is no green shield (yet)
                 let current_hp = self.hp();
-                self.reduce_hp(modified_healing);
+                self.reduce_hp(modified_green_damage);
                 let delta = current_hp - self.hp();
 
-                return Event::Inversion {
+                events.push(Event::Damage {
                     skill,
-                    damage: delta,
+                    amount: delta,
-                    healing: 0,
+                    mitigation: 0,
-                    recharge: 0,
                     category: Category::GreenDamage,
-                };
+                });
-            }
             }
         }
 
-    pub fn deal_red_damage(&mut self, skill: Skill, amount: u64) -> Event {
+        return events;
+    }
+
+    pub fn deal_red_damage(&mut self, skill: Skill, amount: u64) -> Vec<Event> {
+        let mut events = vec![];
+
         if let Some(immunity) = self.immune(skill) {
-            return Event::Immunity {
+            events.push(Event::Immunity {
                 skill,
                 immunity,
-            };
+            });
+            return events;
         }
 
         let red_damage_mods = self.effects.iter()
@@ -539,14 +547,16 @@ impl Cryp {
                 self.reduce_hp(remainder);
                 let delta = current_hp - self.hp();
 
-                return Event::Damage {
+                events.push(Event::Damage {
                     skill,
                     amount: delta,
                     mitigation,
                     category: Category::RedDamage,
-                };
+                });
             },
             true => {
+                events.push(Event::Inversion { skill });
+
                 let current_hp = self.hp();
                 self.hp.increase(modified_damage);
                 let new_hp = self.hp.value;
@@ -557,23 +567,32 @@ impl Cryp {
                 self.red_shield.increase(overhealing);
                 let recharge = self.red_shield.value - current_shield;
 
-                return Event::Inversion {
+                if healing > 0 {
-                    damage: 0,
+                    events.push(Event::Healing {
-                    healing,
-                    recharge,
                         skill,
-                    category: Category::RedDamage,
+                        amount: healing,
-                };
+                        overhealing: overhealing - recharge,
-            }
+                    });
-        }
                 }
 
-    pub fn deal_blue_damage(&mut self, skill: Skill, amount: u64) -> Event {
+                if recharge > 0 {
+                    events.push(Event::Recharge { red: recharge, blue: 0, skill });
+                }
+            }
+        };
+
+        return events;
+    }
+
+    pub fn deal_blue_damage(&mut self, skill: Skill, amount: u64) -> Vec<Event> {
+        let mut events = vec![];
+
         if let Some(immunity) = self.immune(skill) {
-            return Event::Immunity {
+            events.push(Event::Immunity {
                 skill,
                 immunity,
-            };
+            });
+            return events;
         }
 
         let blue_damage_mods = self.effects.iter()
@@ -582,6 +601,7 @@ impl Cryp {
             .collect::<Vec<Effect>>();
 
         // println!("{:?}", blue_damage_mods);
+
         let modified_damage = blue_damage_mods.iter().fold(amount, |acc, m| m.apply(acc));
 
         match self.affected(Effect::Invert) {
@@ -589,20 +609,24 @@ impl Cryp {
                 let remainder = modified_damage.saturating_sub(self.blue_shield.value);
                 let mitigation = modified_damage.saturating_sub(remainder);
 
+                // reduce blue_shield by mitigation amount
                 self.blue_shield.reduce(mitigation);
 
+                // deal remainder to hp
                 let current_hp = self.hp();
                 self.reduce_hp(remainder);
                 let delta = current_hp - self.hp();
 
-                return Event::Damage {
+                events.push(Event::Damage {
                     skill,
                     amount: delta,
                     mitigation,
                     category: Category::BlueDamage,
-                };
+                });
             },
             true => {
+                events.push(Event::Inversion { skill });
+
                 let current_hp = self.hp();
                 self.hp.increase(modified_damage);
                 let new_hp = self.hp.value;
@@ -613,15 +637,21 @@ impl Cryp {
                 self.blue_shield.increase(overhealing);
                 let recharge = self.blue_shield.value - current_shield;
 
-                return Event::Inversion {
+                if healing > 0 {
+                    events.push(Event::Healing {
                         skill,
-                    damage: 0,
+                        amount: healing,
-                    healing,
+                        overhealing,
-                    recharge,
+                    });
-                    category: Category::BlueDamage,
+                }
+
+                if recharge > 0 {
+                    events.push(Event::Recharge { red: 0, blue: recharge, skill });
+                }
+            }
         };
-            }
+
-        }
+        return events;
     }
 
     pub fn add_effect(&mut self, skill: Skill, effect: CrypEffect) -> Event {

server/src/game.rs

@@ -516,14 +516,9 @@ impl Game {
                 self.log.push(format!("[{:}] {:} {:?} {:} {:} ({:}OH)",
                     speed, source.name, skill, target.name, amount, overhealing)),
 
-            Event::Inversion { skill, healing, damage, recharge, category: _ } => {
+            Event::Inversion { skill } =>
-                match *healing > 0 {
+                self.log.push(format!("[{:}] {:} {:?} {:} INVERTED",
-                    true => self.log.push(format!("[{:}] {:} {:?} {:} INVERTED {:} ({:} recharge)",
+                    speed, source.name, skill, target.name)),
-                        speed, source.name, skill, target.name, healing, recharge)),
-                    false => self.log.push(format!("[{:}] {:} {:?} {:} INVERTED {:}",
-                        speed, source.name, skill, target.name, damage)),
-                }
-            },
 
             Event::Effect { skill, effect, duration } =>
                 self.log.push(format!("[{:}] {:} {:?} {:} {:?} {:}T",

server/src/skill.rs

@@ -77,7 +77,7 @@ pub enum Event {
     Damage      { skill: Skill, amount: u64, mitigation: u64, category: Category  },
     Healing     { skill: Skill, amount: u64, overhealing: u64 },
     Recharge    { skill: Skill, red: u64, blue: u64 },
-    Inversion   { skill: Skill, healing: u64, damage: u64, recharge: u64, category: Category },
+    Inversion   { skill: Skill },
     Effect      { skill: Skill, effect: Effect, duration: u8 },
     Removal     { effect: Effect },
     Evasion     { skill: Skill, evasion_rating: u64 },
@@ -746,16 +746,32 @@ impl Skill {
 }
 
 fn touch(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) -> Resolutions {
-    results.push(Resolution::new(source, target).event(target.deal_red_damage(Skill::TestTouch, 0)));
+    target.deal_red_damage(Skill::TestTouch, 0)
+        .into_iter()
+        .for_each(|e| results.push(Resolution::new(source, target).event(e)));
+
     return results;
 }
 
 fn attack(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) -> Resolutions {
     let amount = source.red_damage();
-    results.push(Resolution::new(source, target).event(target.deal_red_damage(Skill::Attack, amount)));
+    target.deal_red_damage(Skill::Attack, amount)
+        .into_iter()
+        .for_each(|e| results.push(Resolution::new(source, target).event(e)));
+
     return results;
 }
 
+fn strike(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) -> Resolutions {
+    let amount = source.red_damage();
+    target.deal_red_damage(Skill::Strike, amount)
+        .into_iter()
+        .for_each(|e| results.push(Resolution::new(source, target).event(e)));
+
+    return results;
+}
+
+
 fn stun(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) -> Resolutions {
     let effect = CrypEffect { effect: Effect::Stun, duration: Effect::Stun.duration(), tick: None };
     results.push(Resolution::new(source, target).event(target.add_effect(Skill::Stun, effect)));
@@ -799,7 +815,9 @@ fn strangle(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) -> R
 
 fn strangle_tick(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) -> Resolutions {
     let amount = source.red_damage();
-    results.push(Resolution::new(source, target).event(target.deal_red_damage(Skill::StrangleTick, amount)));
+    target.deal_red_damage(Skill::StrangleTick, amount)
+        .into_iter()
+        .for_each(|e| results.push(Resolution::new(source, target).event(e)));
 
     // remove immunity if target ko
     if target.is_ko() {
@@ -841,7 +859,9 @@ fn empower(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) -> Re
 
 fn heal(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) -> Resolutions {
     let amount = source.green_damage();
-    results.push(Resolution::new(source, target).event(target.deal_green_damage(Skill::Heal, amount)));
+    target.deal_green_damage(Skill::Heal, amount)
+        .into_iter()
+        .for_each(|e| results.push(Resolution::new(source, target).event(e)));
     return results;
 }
 
@@ -857,13 +877,17 @@ fn triage(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) -> Res
 
 fn triage_tick(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) -> Resolutions {
     let amount = source.green_damage().wrapping_div(2);
-    results.push(Resolution::new(source, target).event(target.deal_green_damage(Skill::TriageTick, amount)));
+    target.deal_green_damage(Skill::TriageTick, amount)
+        .into_iter()
+        .for_each(|e| results.push(Resolution::new(source, target).event(e)));
     return results;
 }
 
 fn blast(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) -> Resolutions {
     let amount = source.blue_damage();
-    results.push(Resolution::new(source, target).event(target.deal_blue_damage(Skill::Blast, amount)));
+    target.deal_blue_damage(Skill::Blast, amount)
+        .into_iter()
+        .for_each(|e| results.push(Resolution::new(source, target).event(e)));
     return results;
 }
 
@@ -897,7 +921,9 @@ fn decay(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) -> Reso
 
 fn decay_tick(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) -> Resolutions {
     let amount = source.blue_damage();
-    results.push(Resolution::new(source, target).event(target.deal_blue_damage(Skill::DecayTick, amount)));
+    target.deal_blue_damage(Skill::DecayTick, amount)
+        .into_iter()
+        .for_each(|e| results.push(Resolution::new(source, target).event(e)));
     return results;
 }
 
@@ -921,7 +947,9 @@ fn corruption(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) ->
 
 fn corruption_tick(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) -> Resolutions {
     let amount = source.blue_damage() / 2;
-    results.push(Resolution::new(source, target).event(target.deal_blue_damage(Skill::CorruptionTick, amount)));
+    target.deal_blue_damage(Skill::CorruptionTick, amount)
+        .into_iter()
+        .for_each(|e| results.push(Resolution::new(source, target).event(e)));
     return results;
 }
 
@@ -972,14 +1000,20 @@ fn siphon(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) -> Res
 
 fn siphon_tick(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) -> Resolutions {
     let amount = source.blue_damage();
-    let siphon_damage = target.deal_blue_damage(Skill::SiphonTick, amount);
+    let siphon_events = target.deal_blue_damage(Skill::SiphonTick, amount);
-    results.push(Resolution::new(source, target).event(siphon_damage.clone()));
 
-    match siphon_damage {
+    for e in siphon_events {
+        match e {
             Event::Damage { amount, mitigation: _, category: _, skill: _ } => {
-            results.push(Resolution::new(source, source).event(source.deal_green_damage(Skill::Heal, amount)));
+                let dmg = source.deal_green_damage(Skill::Siphon, amount);
+                for e in dmg {
+                    results.push(Resolution::new(source, target).event(e));
+                };
             },
-        _ => panic!("siphon tick damage not dealt {:?}", siphon_damage),
+            _ => (),
+        }
+
+        results.push(Resolution::new(source, target).event(e));
     }
 
     return results;
@@ -1025,13 +1059,6 @@ fn banish(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) -> Res
     return results;
 }
 
-fn strike(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) -> Resolutions {
-    let _amount = source.red_damage();
-    results.push(Resolution::new(source, target).event(target.deal_red_damage(Skill::Attack, u64::max_value())));
-    return results;
-}
-
-
 #[cfg(test)]
 mod tests {
     use skill::*;
@@ -1139,11 +1166,20 @@ mod tests {
         let mut results = attack(&mut x, &mut y, vec![]);
         assert!(y.hp() == 1024);
 
-        let Resolution { source: _, target: _, event } = results.remove(0);
+        match results.remove(0).event {
-        match event {
+            Event::Inversion { skill } => assert_eq!(skill, Skill::Attack),
-            Event::Inversion { damage: _, healing: _, recharge, category: _, skill: _ } => assert_eq!(recharge, 64),
             _ => panic!("not inversion"),
         };
+
+        match results.remove(0).event {
+            Event::Healing { skill: _, overhealing: _, amount } => assert_eq!(amount, 256),
+            _ => panic!("not healing from inversion"),
+        };
+
+        match results.remove(0).event {
+            Event::Recharge { skill: _, red, blue: _ } => assert_eq!(red, 64),
+            _ => panic!("not recharge from inversion"),
+        };
     }
 
     #[test]