Strike T2

server/src/skill.rs

@@ -69,7 +69,8 @@ pub fn resolve(skill: Skill, source: &mut Cryp, target: &mut Cryp, mut resolutio
         Skill::Snare => snare(source, target, resolutions),
         Skill::Strangle => strangle(source, target, resolutions),
         Skill::StrangleTick => strangle_tick(source, target, resolutions),
-        Skill::Strike => strike(source, target, resolutions),
+        Skill::Strike => strike(source, target, resolutions, 1),
+        Skill::StrikeII => strike(source, target, resolutions, 2),
         Skill::Stun => stun(source, target, resolutions),
         Skill::Taunt => taunt(source, target, resolutions),
         Skill::Throw => throw(source, target, resolutions), // no damage stun, adds vulnerable
@@ -527,6 +528,7 @@ pub enum Skill {
     StrangleTick,
 
     Strike,
+    StrikeII,
     Stun,
     // Evade, // actively evade
 
@@ -588,6 +590,7 @@ impl Skill {
         match self {
             Skill::Attack => 0.9,
             Skill::Strike => 1.1,
+            Skill::StrikeII => 1.3,
             Skill::StrangleTick => 0.3,
             Skill::Riposte => 1.0,
             Skill::Heal => 1.2,
@@ -604,6 +607,7 @@ impl Skill {
         match self {
             Skill::Attack => None,
             Skill::Strike => None,
+            Skill::StrikeII => None,            
             Skill::Block => None, // reduce damage
             Skill::Parry => None, // avoid all damage
             Skill::Riposte => None, // used on parry
@@ -660,6 +664,7 @@ impl Skill {
         match self {
             Skill::Attack => Category::Red,
             Skill::Strike => Category::Red,
+            Skill::StrikeII => Category::Red,
             Skill::Injure => Category::Red,
             Skill::Strangle => Category::Red,
             Skill::StrangleTick => Category::Red,
@@ -704,6 +709,7 @@ impl Skill {
             // -----------------
             // Test
             // -----------------
+
             Skill::TestTouch => Category::Red,
             Skill::TestStun => Category::Red,
             Skill::TestParry => Category::Red,
@@ -734,6 +740,7 @@ impl Skill {
             Skill::TestSiphon => 10,
 
             Skill::Strike => u8::max_value(),
+            Skill::StrikeII => u8::max_value(),
 
             Skill::SiphonTick => Var::from(Skill::Siphon).speed(),
             Skill::DecayTick => Var::from(Skill::Decay).speed(),
@@ -810,8 +817,12 @@ fn attack(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) -> Res
     return results;
 }
 
-fn strike(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) -> Resolutions {
+fn strike(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, tier: u8) -> Resolutions {
-    let amount = (source.red_damage() as f64 * Skill::Strike.multiplier()).floor() as u64;
+    let multiplier = match tier {
+        2 => Skill::StrikeII.multiplier(),
+        _ => Skill::Strike.multiplier()
+    };
+    let amount = (source.red_damage() as f64 * multiplier).floor() as u64;
     target.deal_red_damage(Skill::Strike, amount)
         .into_iter()
         .for_each(|e| results.push(Resolution::new(source, target).event(e)));
@@ -980,7 +991,7 @@ 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() as f64 * Skill::DecayTick.multiplier()) as u64;
+    let amount = (source.blue_damage() as f64 * Skill::DecayTick.multiplier()).floor() as u64;
     target.deal_blue_damage(Skill::DecayTick, amount)
         .into_iter()
         .for_each(|e| results.push(Resolution::new(source, target).event(e)));
@@ -1004,7 +1015,7 @@ 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() as f64 * Skill::CorruptionTick.multiplier()) as u64;
+    let amount = (source.blue_damage() as f64 * Skill::CorruptionTick.multiplier()).floor() as u64;
     target.deal_blue_damage(Skill::CorruptionTick, amount)
         .into_iter()
         .for_each(|e| results.push(Resolution::new(source, target).event(e)));

server/src/vbox.rs

@@ -87,6 +87,7 @@ pub enum Var {
     Snare,
     Strangle,
     Strike,
+    StrikeII,
     Siphon,
     Clutch,
     Taunt,
@@ -207,6 +208,7 @@ impl Var {
             Var::Snare      => Some(Skill::Snare),
             Var::Strangle   => Some(Skill::Strangle),
             Var::Strike     => Some(Skill::Strike),
+            Var::StrikeII   => Some(Skill::StrikeII),
             Var::Clutch     => Some(Skill::Clutch),
             Var::Taunt      => Some(Skill::Taunt),
             Var::Throw      => Some(Skill::Throw),
@@ -277,6 +279,7 @@ impl From<Skill> for Var {
             Skill::Snare => Var::Snare,
             Skill::Strangle => Var::Strangle,
             Skill::Strike => Var::Strike,
+            Skill::StrikeII => Var::StrikeII,
             Skill::Stun => Var::Stun,
             Skill::Taunt => Var::Taunt,
             Skill::Throw => Var::Throw,
@@ -361,6 +364,8 @@ fn get_combos() -> Vec<Combo> {
         Combo { units: vec![Var::Stun, Var::Red,    Var::Blue],     var: Var::Hex       },
 
         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::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::Purify    },