Merge branch 'master' of ssh://cryps.gg:40022/~/cryps

CHANGELOG.md

@@ -8,17 +8,58 @@ This project adheres to [Semantic Versioning](http://semver.org/).
     Event::Skill
         needed to convey the use of skill which is followed by other events 
         used for skill Purify to show that it is used and then followed by removal and other events
+    New Skill `Sleep`
+        Combined using Stun + GG
+        Stuns target for 3T (might need to be 4T)
+        Deals 240% green damage (heal)
+        Concept - high duration stun with the drawback of a big heal on the target 
+        Base cooldown 3T
+        (Could be played aggressively or defensively)
 
 ### Fixed
 
 ### Changed
     Switch purify with reflect
-        - Purify now GG + block instead of GB + block
+        - Purify 
-        - Purify now applies a small heal 45% multiplier green damage (power)
+            Now GG + block (was GB + block)
+            Now applies a small heal 45% multiplier green damage (power) for each debuff removed
     
-        - reflect now GB + block
+        - Reflect 
-        - reflect restores blue shield
+            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
 
+    Silence 
+        No longer Stun + GB (already exists as debuff BB)
+        Now also deals damage amount of 55% base blue damage
+        This damage amount does 45% more damage per blue skill blocked 
+        Maximum = (0.55)(1.35)*base_blue_damage
+        Cooldown changed 1T -> 2T
+        Debuff duration increased 2T -> 3T
+    Snare
+        Now also deals damage amount of 40% base blue damage
+        This damage amount does 45% more damage per red skill blocked 
+        Maximum = (0.40)(1.35)*base_red_damage
+        Cooldown changed 1T -> 2T
+        Debuff duration increased 2T -> 3T
+
+
+    Switch clutch with taunt
+        Clutch now GR + Block (was GR + Buff)
+        Taunt now GR + Buff
+            No longer self-target only
+
+    
+    Hex is now Stun + GB (was Stun + RB)
+    Banish is now Stun + RB (was Stun + RG) for rng theme
+    Throw is now Stun + RG (was Stun + GG) 
+        - Better fit as it applies inc Red taken debuff (vulnerability)
 
 
 ## [0.1.0] - 2019-05-02

client/src/utils.jsx

@@ -228,13 +228,20 @@ function getCombatSequence(event) {
     if (['Healing'].includes(event[0])
         && (event[1].skill === 'Slay'
             || event[1].skill === 'SiphonTick'
-            || event[1].skill === 'Purify')) return ['POST_SKILL'];
+            || 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'];
 
     if (['Damage'].includes(event[0])
-        && event[1].skill === 'Chaos' && event[1].colour === 'RedDamage') return ['POST_SKILL'];
+        && ((event[1].skill === 'Chaos' && event[1].colour === 'RedDamage')
+            || event[1].skill === 'Silence'
+            || event[1].skill === 'Snare')) return ['POST_SKILL'];
 
     if (['Ko'].includes(event[0])
         || (event[1].skill === 'Throw' && event[1].effect === 'Vulnerable')) return ['POST_SKILL'];

server/src/cryp.rs

@@ -470,6 +470,14 @@ impl Cryp {
             .fold(self.speed.value, |acc, fx| fx.0.apply(acc, fx.1));
         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 {
+    pub fn recharge(&mut self, skill: Skill, red_amount: u64, blue_amount: u64) -> Event {
-        let skill = Skill::Recharge;
+        // 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);
+        // Do we need inversion?
-        self.red_life.value = self.red_life.max;
+        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);
+        let current_blue_life = self.blue_life();
-        self.blue_life.value = self.blue_life.max;
+        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

@@ -67,6 +67,7 @@ pub fn resolve(skill: Skill, source: &mut Cryp, target: &mut Cryp, mut resolutio
         Skill::Siphon => siphon(source, target, resolutions, Skill::Siphon),
         Skill::SiphonTick => siphon_tick(source, target, resolutions, Skill::SiphonTick), // hot
         Skill::Slay => slay(source, target, resolutions, Skill::Slay), // hybrid dmg self heal
+        Skill::Sleep => sleep(source, target, resolutions, Skill::Sleep), // speed slow
         Skill::Slow => slow(source, target, resolutions, Skill::Slow), // speed slow
         Skill::Snare => snare(source, target, resolutions, Skill::Snare),
         Skill::Strangle => strangle(source, target, resolutions, Skill::Strangle),
@@ -481,6 +482,7 @@ pub enum Skill {
     Reflect,
     Ruin,
     Slay,
+    Sleep,
     Clutch,
     Taunt,
     Invert,
@@ -563,7 +565,15 @@ 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)
+
+            // Debuff Base
+            Skill::Silence => 55, // Deals more per blue skill on target
+            Skill::Snare => 40, // Deals more per blue skill on target
 
             // Others
             Skill::CorruptionTick => 80,
@@ -589,8 +599,10 @@ impl Skill {
             Skill::Strangle => 2,
 
             Skill::Stun => 2,
+            Skill::Sleep => 3,
+
             Skill::Throw => 2,
-            Skill::Snare => 2,
+            Skill::Snare => 3,
 
             Skill::Taunt => 1,
             Skill::Empower => 2,
@@ -605,7 +617,7 @@ impl Skill {
             Skill::Haste => 2,
 
             Skill::Amplify => 2,
-            Skill::Silence => 2,
+            Skill::Silence => 3,
 
             Skill::Hostility => 2, // Primary Buff
             Skill::Corrupt => 2, // Primary Buff
@@ -647,7 +659,7 @@ impl Skill {
             Skill::Block => None, // reduce damage
             Skill::Parry => None, // avoid all damage
             Skill::Riposte => None, // used on parry
-            Skill::Snare => Some(1),
+            Skill::Snare => Some(2),
             Skill::Stun => Some(1),
             Skill::Heal => None,
             Skill::Triage => None, // hot
@@ -664,7 +676,7 @@ impl Skill {
             Skill::Curse => Some(1),
             Skill::Empower => Some(1),
             Skill::Shield => None,
-            Skill::Silence => Some(1),
+            Skill::Silence => Some(2),
             Skill::Purify => None,
             Skill::Purge => None,
             Skill::Banish => Some(1),
@@ -675,6 +687,8 @@ impl Skill {
             Skill::Recharge => Some(2),
             Skill::Ruin => Some(3),
             Skill::Slay => None,
+            Skill::Sleep => Some(3),
+
             Skill::Strangle => Some(2),
             Skill::StrangleTick => None,
             Skill::Clutch => Some(2),
@@ -726,6 +740,7 @@ impl Skill {
             Skill::Reflect => Category::Green,
             Skill::Haste => Category::Green,
             Skill::Invert => Category::Green,
+            Skill::Sleep => Category::Green,
 
             Skill::Blast => Category::Blue,
             Skill::Chaos => Category::Blue,
@@ -804,7 +819,7 @@ impl Skill {
             Skill::Block => true,
             Skill::Parry => true,
             Skill::Clutch => true,
-            Skill::Taunt => true,
+            // Skill::Taunt => true,
             Skill::Corrupt => true,
 
             Skill::TestBlock => true,
@@ -883,6 +898,17 @@ fn stun(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, skill: S
     return results;
 }
 
+fn sleep(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, skill: Skill) -> Resolutions {
+    let effect = CrypEffect::new(Effect::Stun, skill.duration());
+    results.push(Resolution::new(source, target).event(target.add_effect(skill, effect)));
+    let amount = source.green_damage().pct(skill.multiplier());
+    target.deal_green_damage(skill, amount)
+        .into_iter()
+        .for_each(|e| results.push(Resolution::new(source, target).event(e)));
+
+    return results;
+}
+
 fn clutch(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, skill: Skill) -> Resolutions {
     let effect = CrypEffect::new(Effect::Clutch, skill.duration());
     results.push(Resolution::new(source, target).event(target.add_effect(skill, effect)));
@@ -959,6 +985,21 @@ fn riposte(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, skill
 fn snare(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, skill: Skill) -> Resolutions {
     let snare = CrypEffect::new(Effect::Snare, skill.duration());
     results.push(Resolution::new(source, target).event(target.add_effect(skill, snare)));
+    
+    let mut s_multi: u64 = 100;
+    for cs in target.skills.iter() {
+        s_multi += match cs.skill.category() {
+            Category::Red => 45,
+            _ => 0,
+        }
+    }
+
+    let amount = source.red_damage().pct(skill.multiplier()).pct(s_multi);
+    target.deal_red_damage(skill, amount)
+        .into_iter()
+        .for_each(|e| results.push(Resolution::new(source, target).event(e)));
+
+
     return results;
 }
 
@@ -1137,11 +1178,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;
 }
 
@@ -1182,6 +1230,20 @@ fn shield(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, skill:
 fn silence(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, skill: Skill) -> Resolutions {
     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 amount = source.blue_damage().pct(skill.multiplier()).pct(s_multi);
+    target.deal_blue_damage(skill, amount)
+        .into_iter()
+        .for_each(|e| results.push(Resolution::new(source, target).event(e)));
+
     return results;
 }
 

server/src/vbox.rs

@@ -66,6 +66,8 @@ pub enum Var {
     Banish,
     Blast,
     Chaos,
+    Clutch,
+    Corrupt,
     Curse,
     Decay,
     Empower,
@@ -83,6 +85,7 @@ pub enum Var {
     Shield,
     Silence,
     Slay,
+    Sleep,
     Slow,
     Snare,
     Strangle,
@@ -90,10 +93,8 @@ pub enum Var {
     StrikeII,
     StrikeIII,
     Siphon,
-    Clutch,
     Taunt,
     Throw,
-    Corrupt,
     Triage,
 
 
@@ -211,6 +212,7 @@ impl Var {
             Var::Shield     => Some(Skill::Shield),
             Var::Silence    => Some(Skill::Silence),
             Var::Slay       => Some(Skill::Slay),
+            Var::Sleep       => Some(Skill::Sleep),
             Var::Slow       => Some(Skill::Slow),
             Var::Siphon     => Some(Skill::Siphon),
             Var::Snare      => Some(Skill::Snare),
@@ -287,6 +289,7 @@ impl From<Skill> for Var {
             Skill::Silence => Var::Silence,
             Skill::Siphon => Var::Siphon,
             Skill::Slay => Var::Slay,
+            Skill::Sleep => Var::Sleep,
             Skill::Slow => Var::Slow,
             Skill::Snare => Var::Snare,
             Skill::Strangle => Var::Strangle,
@@ -348,42 +351,42 @@ struct Combo {
 
 fn get_combos() -> Vec<Combo> {
     let mut combinations = vec![
-        Combo { units: vec![Var::Buff, Var::Red,    Var::Red],      var: Var::Empower   },
+        Combo { units: vec![Var::Buff, Var::Red,    Var::Red],      var: Var::Empower   }, // Gereric red dmg buff
         Combo { units: vec![Var::Buff, Var::Green,  Var::Green],    var: Var::Triage    },
-        Combo { units: vec![Var::Buff, Var::Blue,   Var::Blue],     var: Var::Amplify   },
+        Combo { units: vec![Var::Buff, Var::Blue,   Var::Blue],     var: Var::Amplify   }, // Gereric blue dmg buff
-        Combo { units: vec![Var::Buff, Var::Red,    Var::Green],    var: Var::Clutch    },
+        Combo { units: vec![Var::Buff, Var::Red,    Var::Green],    var: Var::Taunt     },
-        Combo { units: vec![Var::Buff, Var::Green,  Var::Blue],     var: Var::Curse },
+        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     },
+        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     }, // disable red and dmg
-        Combo { units: vec![Var::Debuff, Var::Green,  Var::Green],  var: Var::Purge     },
+        Combo { units: vec![Var::Debuff, Var::Green,  Var::Green],  var: Var::Purge     }, // disable green and remove debuff
-        Combo { units: vec![Var::Debuff, Var::Blue,   Var::Blue],   var: Var::Silence   },
+        Combo { units: vec![Var::Debuff, Var::Blue,   Var::Blue],   var: Var::Silence   }, // disable blue and dmg
-        Combo { units: vec![Var::Debuff, Var::Red,    Var::Green],  var: Var::Slow      },
+        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::Green,  Var::Blue],   var: Var::Decay     },
         Combo { units: vec![Var::Debuff, Var::Red,    Var::Blue],   var: Var::Invert    },
 
         Combo { units: vec![Var::Block, Var::Red,     Var::Red],    var: Var::Parry     },
         Combo { units: vec![Var::Block, Var::Green,   Var::Green],  var: Var::Purify    },
         Combo { units: vec![Var::Block, Var::Blue,    Var::Blue],   var: Var::Corrupt   },
-        Combo { units: vec![Var::Block, Var::Red,     Var::Green],  var: Var::Taunt     },
+        Combo { units: vec![Var::Block, Var::Red,     Var::Green],  var: Var::Clutch    },
         Combo { units: vec![Var::Block, Var::Green,   Var::Blue],   var: Var::Reflect   },
         Combo { units: vec![Var::Block, Var::Red,     Var::Blue],   var: Var::Recharge  },
 
         Combo { units: vec![Var::Stun, Var::Red,    Var::Red],      var: Var::Strangle  },
-        Combo { units: vec![Var::Stun, Var::Green,  Var::Green],    var: Var::Throw     },
+        Combo { units: vec![Var::Stun, Var::Green,  Var::Green],    var: Var::Sleep     },
         Combo { units: vec![Var::Stun, Var::Blue,   Var::Blue],     var: Var::Ruin      },
-        Combo { units: vec![Var::Stun, Var::Red,    Var::Green],    var: Var::Banish    },
+        Combo { units: vec![Var::Stun, Var::Red,    Var::Green],    var: Var::Throw     },
-        Combo { units: vec![Var::Stun, Var::Green,  Var::Blue],     var: Var::Silence   },
+        Combo { units: vec![Var::Stun, Var::Green,  Var::Blue],     var: Var::Hex       },
-        Combo { units: vec![Var::Stun, Var::Red,    Var::Blue],     var: Var::Hex       },
+        Combo { units: vec![Var::Stun, Var::Red,    Var::Blue],     var: Var::Banish    },
 
-        Combo { units: vec![Var::Attack, Var::Red,    Var::Red],    var: Var::Strike    },
+        Combo { units: vec![Var::Attack, Var::Red,    Var::Red],    var: Var::Strike          },
-        Combo { units: vec![Var::Strike, Var::Strike, Var::Strike], var: Var::StrikeII  },
+        Combo { units: vec![Var::Strike, Var::Strike, Var::Strike], var: Var::StrikeII        },
         Combo { units: vec![Var::StrikeII, Var::StrikeII, Var::StrikeII], var: Var::StrikeIII },
 
         Combo { units: vec![Var::Attack, Var::Green,  Var::Green],  var: Var::Heal          },
         Combo { units: vec![Var::Attack, Var::Blue,   Var::Blue],   var: Var::Blast         },
         Combo { units: vec![Var::Attack, Var::Red,    Var::Green],  var: Var::Slay          },
-        Combo { units: vec![Var::Attack, Var::Green,  Var::Blue],   var: Var::Siphon         },
+        Combo { units: vec![Var::Attack, Var::Green,  Var::Blue],   var: Var::Siphon        },
         Combo { units: vec![Var::Attack, Var::Red,    Var::Blue],   var: Var::Chaos         },
 
         Combo { units: vec![Var::Damage, Var::Red,    Var::Red],    var: Var::RedDamageI    },