Rework recharge, reflect recharges blue life

CHANGELOG.md

@@ -20,10 +20,21 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 
 ### Changed
     Switch purify with reflect
-        - Purify now GG + block (was GB + block)
-        - Purify now applies a small heal 45% multiplier green damage (power) for each debuff removed
+        - Purify 
+            Now GG + block (was GB + block)
+            Now applies a small heal 45% multiplier green damage (power) for each debuff removed
+    
+        - Reflect 
+            Now GB + block (was GG + block)
+            Recharges blue life at 45% blue damage
+        
+        - Server function recharge changed to take skill, red amount and blue amount as inputs
+        
+        - Recharge Skill reworked
+            No longer restores full Red and Blue life
+            Now restores Red life and Blue life based on respective red and blue damage 
+            Recharge value calculated at 85% multiplier with red and blue damage
 
-        - reflect now GB + block (was GG + block)
 
     Switch clutch with taunt
         Clutch now GR + Block (was GR + Buff)

client/src/utils.jsx

@@ -231,6 +231,10 @@ function getCombatSequence(event) {
             || event[1].skill === 'Purify'
             || event[1].skill === 'Sleep')) return ['POST_SKILL'];
 
+    if (['Recharge'].includes(event[0])
+        && (event[1].skill === 'Reflect')) return ['POST_SKILL'];
+
+
     if (['Effect'].includes(event[0])
         && event[1].skill === 'Decay' && event[1].effect === 'Wither') return ['POST_SKILL'];
 

server/src/cryp.rs

@@ -471,6 +471,14 @@ impl Cryp {
         return modified_speed;
     }
     
+    pub fn red_life(&self) -> u64 {
+        self.red_life.value
+    }
+
+    pub fn blue_life(&self) -> u64 {
+        self.blue_life.value
+    }
+
     pub fn green_life(&self) -> u64 {
         self.green_life.value
     }
@@ -482,8 +490,8 @@ impl Cryp {
         }
     }
 
-    pub fn recharge(&mut self) -> Event {
-        let skill = Skill::Recharge;
+    pub fn recharge(&mut self, skill: Skill, red_amount: u64, blue_amount: u64) -> Event {
+        // Should red type immunity block recharge???
         if let Some(immunity) = self.immune(skill) {
             return Event::Immunity {
                 skill,
@@ -491,11 +499,16 @@ impl Cryp {
             };
         }
 
-        let red = self.red_life.max.saturating_sub(self.red_life.value);
-        self.red_life.value = self.red_life.max;
+        // Do we need inversion?
+        let current_red_life = self.red_life();
+        self.red_life.increase(red_amount);
+        let new_red_life = self.red_life.value;
+        let red = new_red_life - current_red_life;
 
-        let blue = self.blue_life.max.saturating_sub(self.blue_life.value);
-        self.blue_life.value = self.blue_life.max;
+        let current_blue_life = self.blue_life();
+        self.blue_life.increase(blue_amount);
+        let new_blue_life = self.blue_life.value;
+        let blue = new_blue_life - current_blue_life;
 
         Event::Recharge { red, blue, skill }
     }

server/src/skill.rs

@@ -565,6 +565,8 @@ impl Skill {
 
             // Block Base
             Skill::Purify => 45, //Green dmg (heal)
+            Skill::Recharge => 85, //restore red and blue life (heal)
+            Skill::Reflect => 45, //restore blue life (heal)
 
             // Stun Base
             Skill::Sleep => 240, //Green dmg (heal)
@@ -1156,11 +1158,18 @@ fn invert(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, skill:
 fn reflect(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, skill: Skill) -> Resolutions {
     let effect = CrypEffect::new(Effect::Reflect, skill.duration());
     results.push(Resolution::new(source, target).event(target.add_effect(skill, effect)));
+    
+    let blue_amount = source.blue_damage().pct(skill.multiplier());
+    results.push(Resolution::new(source, target).event(target.recharge(skill, 0, blue_amount)));
+
     return results;;
 }
 
 fn recharge(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, skill: Skill) -> Resolutions {
-    results.push(Resolution::new(source, target).event(target.recharge()));
+    let red_amount = source.red_damage().pct(skill.multiplier());
+    let blue_amount = source.blue_damage().pct(skill.multiplier());
+
+    results.push(Resolution::new(source, target).event(target.recharge(skill, red_amount, blue_amount)));
     return results;
 }
 

server/src/vbox.rs

@@ -358,9 +358,9 @@ fn get_combos() -> Vec<Combo> {
         Combo { units: vec![Var::Buff, Var::Green,  Var::Blue],     var: Var::Curse     }, // Needs a buff
         Combo { units: vec![Var::Buff, Var::Red,    Var::Blue],     var: Var::Haste     }, // Needs a buff
 
-        Combo { units: vec![Var::Debuff, Var::Red,    Var::Red],    var: Var::Snare     },
+        Combo { units: vec![Var::Debuff, Var::Red,    Var::Red],    var: Var::Snare     }, // Dmg for disabled red
         Combo { units: vec![Var::Debuff, Var::Green,  Var::Green],  var: Var::Purge     }, // Needs a buff
-        Combo { units: vec![Var::Debuff, Var::Blue,   Var::Blue],   var: Var::Silence   }, 
+        Combo { units: vec![Var::Debuff, Var::Blue,   Var::Blue],   var: Var::Silence   }, // Dmg for disabled blue
         Combo { units: vec![Var::Debuff, Var::Red,    Var::Green],  var: Var::Slow      }, // Needs a buff
         Combo { units: vec![Var::Debuff, Var::Green,  Var::Blue],   var: Var::Decay     },
         Combo { units: vec![Var::Debuff, Var::Red,    Var::Blue],   var: Var::Invert    },