invert recharge, fix recharge border

WORKLOG.md

@@ -8,8 +8,6 @@
 
 * mobile info page
 
-* Invert recharge
-
 ## SOON
 
 * supporter gold name in instance (anyone whos put any money into game)

client/src/components/buttons.jsx

@@ -8,33 +8,33 @@ module.exports = {
     Slay: () => 'red-green-border',
     Siphon: () => 'blue-green-border',
     // Stun
-    Link: () => 'blue-green-border',
     Bash: () => 'red-border',
-    Sleep: () => 'green-border',
     Ruin: () => 'blue-border',
-    Break: () => 'red-green-border',
+    Sleep: () => 'green-border',
     Banish: () => 'red-blue-border',
+    Break: () => 'red-green-border',
+    Link: () => 'blue-green-border',
     // Block
     Counter: () => 'red-border',
-    Purify: () => 'green-border',
     Electrify: () => 'blue-border',
+    Purify: () => 'green-border',
+    Recharge: () => 'red-blue-border',
     Sustain: () => 'red-green-border',
     Reflect: () => 'blue-green-border',
-    Recharge: () => 'blue-red-border',
     // Buff
     Intercept: () => 'red-border',
-    Triage: () => 'green-border',
-    Haste: () => 'red-green-border',
     Absorb: () => 'blue-border',
-    Hybrid: () => 'blue-green-border',
+    Triage: () => 'green-border',
     Amplify: () => 'red-blue-border',
+    Haste: () => 'red-green-border',
+    Hybrid: () => 'blue-green-border',
     // Debuff
     Restrict: () => 'red-border',
-    Purge: () => 'green-border',
     Silence: () => 'blue-border',
+    Purge: () => 'green-border',
+    Curse: () => 'red-blue-border',
     Invert: () => 'red-green-border',
     Decay: () => 'blue-green-border',
-    Curse: () => 'red-blue-border',
 
     //     // Lifes Upgrades
     // LifeGG: () => 'green-border',

server/src/construct.rs

@@ -7,7 +7,7 @@ use postgres::transaction::Transaction;
 use failure::Error;
 use failure::err_msg;
 
-use skill::{Skill, Cast, Immunity, Disable, Event, EventStages};
+use skill::{Skill, Cast, Immunity, Disable, Event};
 use effect::{Cooldown, Effect, Colour};
 use spec::{Spec};
 use item::{Item};
@@ -549,32 +549,93 @@ impl Construct {
         }
     }
 
-    pub fn recharge(&mut self, skill: Skill, red_amount: u64, blue_amount: u64) -> Vec<(Event, EventStages)> {
+    pub fn recharge(&mut self, skill: Skill, red_amount: u64, blue_amount: u64) -> Vec<Event> {
         let mut events = vec![];
 
         // Should red type immunity block recharge???
-        let mut stages = EventStages::PostOnly;
         if let Some(immunity) = self.immune(skill) {
-            events.push((Event::Immunity { skill, immunity }, stages));
+            events.push(Event::Immunity { skill, immunity });
             return events;
         }
 
-        // Do we need inversion?
+        match self.affected(Effect::Invert) {
-        let current_red_life = self.red_life();
+            false => {
-        self.red_life.increase(red_amount);
+                // Do we need inversion?
-        let new_red_life = self.red_life.value;
+                let current_red_life = self.red_life();
-        let red = new_red_life - current_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 current_blue_life = self.blue_life();
+                let current_blue_life = self.blue_life();
-        self.blue_life.increase(blue_amount);
+                self.blue_life.increase(blue_amount);
-        let new_blue_life = self.blue_life.value;
+                let new_blue_life = self.blue_life.value;
-        let blue = new_blue_life - current_blue_life;
+                let blue = new_blue_life - current_blue_life;
 
-        if red == 0 && blue == 0 {
+                if red != 0 || blue != 0 {
-            stages = EventStages::NoStages;
+                    events.push(Event::Recharge { red, blue, skill });
+                }
+            },
+            true => {
+                // Recharge takes a red and blue amount so check for them
+                if red_amount != 0 {
+                    let red_mods = self.effects.iter()
+                        .filter(|e| e.effect.modifications().contains(&Stat::RedDamageTaken))
+                        .map(|e| (e.effect, e.meta))
+                        .collect::<Vec<(Effect, Option<EffectMeta>)>>();
+
+                    let red_modified_power = red_mods.iter()
+                        .fold(red_amount, |acc, fx| fx.0.apply(acc, fx.1));
+
+
+                    let red_remainder = red_modified_power.saturating_sub(self.red_life.value);
+                    let red_mitigation = red_modified_power.saturating_sub(red_remainder);
+
+                    // reduce red_life by mitigation amount
+                    self.red_life.reduce(red_remainder);
+
+                    // deal remainder to green_life
+                    let red_current_green_life = self.green_life();
+                    self.reduce_green_life(red_remainder);
+                    let red_amount = red_current_green_life - self.green_life();
+
+                    events.push(Event::Damage { 
+                        skill,
+                        amount: red_amount,
+                        mitigation: red_mitigation,
+                        colour: Colour::Red 
+                    });
+                }
+
+                if blue_amount != 0 {
+                    let blue_mods = self.effects.iter()
+                        .filter(|e| e.effect.modifications().contains(&Stat::BlueDamageTaken))
+                        .map(|e| (e.effect, e.meta))
+                        .collect::<Vec<(Effect, Option<EffectMeta>)>>();
+
+                    let blue_modified_power = blue_mods.iter()
+                        .fold(blue_amount, |acc, fx| fx.0.apply(acc, fx.1));
+
+
+                    let blue_remainder = blue_modified_power.saturating_sub(self.blue_life.value);
+                    let blue_mitigation = blue_modified_power.saturating_sub(blue_remainder);
+
+                    // reduce blue_life by mitigation amount
+                    self.blue_life.reduce(blue_remainder);
+
+                    // deal remainder to green_life
+                    let blue_current_green_life = self.green_life();
+                    self.reduce_green_life(blue_remainder);
+                    let blue_amount = blue_current_green_life - self.green_life();
+
+                    events.push(Event::Damage { 
+                        skill,
+                        amount: blue_amount,
+                        mitigation: blue_mitigation,
+                        colour: Colour::Blue 
+                    });
+                }
+            }
         }
-
-        events.push((Event::Recharge { red, blue, skill }, stages));
         return events;
     }
 

server/src/game.rs

@@ -1429,7 +1429,7 @@ mod tests {
 
         game = game.resolve_phase_start();
 
-        assert!(game.resolved.len() == 5);
+        assert!(game.resolved.len() == 4);
         while let Some(r) = game.resolved.pop() {
             let Resolution { source , target, event: _,  stages: _ } = r;
             if [i_construct.id, j_construct.id].contains(&source.id) {

server/src/skill.rs

@@ -433,8 +433,6 @@ pub enum EventStages {
     EndOnly,    // Skip Anim Skip
     #[serde(rename = "POST_SKILL")]
     PostOnly,   // Skip Skip Anim
-    #[serde(rename = "")]
-    NoStages,   // Skip Skip Skip
 }
 
 #[derive(Debug,Clone,PartialEq,Serialize,Deserialize)]
@@ -490,7 +488,6 @@ impl Resolution {
             EventStages::EndPost => target_duration + post_skill,            // Skip Anim Anim
             EventStages::EndOnly => target_duration,                         // Skip Anim Skip
             EventStages::PostOnly => post_skill,                             // Skip Skip Anim
-            EventStages::NoStages => 0,                                      // Skip Skip Skip
         }
     }
 }
@@ -1413,7 +1410,7 @@ fn sustain(source: &mut Construct, target: &mut Construct, mut results: Resoluti
     let red_amount = source.red_power().pct(skill.multiplier());
     target.recharge(skill, red_amount, 0)
         .into_iter()
-        .for_each(|(e, stages)| results.push(Resolution::new(source, target).event(e).stages(stages)));
+        .for_each(|e| results.push(Resolution::new(source, target).event(e).stages(EventStages::PostOnly)));
 
     return results;
 }
@@ -1425,7 +1422,7 @@ fn intercept(source: &mut Construct, target: &mut Construct, mut results: Resolu
     let red_amount = source.red_power().pct(skill.multiplier());
     target.recharge(skill, red_amount, 0)
         .into_iter()
-        .for_each(|(e, stages)| results.push(Resolution::new(source, target).event(e).stages(stages)));
+        .for_each(|e| results.push(Resolution::new(source, target).event(e).stages(EventStages::PostOnly)));
 
     return results;
 }
@@ -1689,7 +1686,7 @@ fn absorb(source: &mut Construct, target: &mut Construct, mut results: Resolutio
     let blue_amount = source.blue_power().pct(skill.multiplier());
     target.recharge(skill, 0, blue_amount)
         .into_iter()
-        .for_each(|(e, stages)| results.push(Resolution::new(source, target).event(e).stages(stages)));
+        .for_each(|e| results.push(Resolution::new(source, target).event(e).stages(EventStages::PostOnly)));
     return results;;
 }
 
@@ -1730,7 +1727,7 @@ fn reflect(source: &mut Construct, target: &mut Construct, mut results: Resoluti
     let blue_amount = source.blue_power().pct(skill.multiplier());
         target.recharge(skill, 0, blue_amount)
         .into_iter()
-        .for_each(|(e, stages)| results.push(Resolution::new(source, target).event(e).stages(stages)));
+        .for_each(|e| results.push(Resolution::new(source, target).event(e).stages(EventStages::PostOnly)));
 
     return results;;
 }
@@ -1741,7 +1738,7 @@ fn recharge(source: &mut Construct, target: &mut Construct, mut results: Resolut
     let blue_amount = source.blue_power().pct(skill.multiplier());
     target.recharge(skill, red_amount, blue_amount)
         .into_iter()
-        .for_each(|(e, stages)| results.push(Resolution::new(source, target).event(e).stages(stages)));
+        .for_each(|e| results.push(Resolution::new(source, target).event(e).stages(EventStages::PostOnly)));
 
     return results;
 }