From 567b1b7ee921acb2e14daf8731718d49a47e2b1f Mon Sep 17 00:00:00 2001
From: ntr <ntr@smokestack.io>
Date: Fri, 9 Nov 2018 15:17:49 +1100
Subject: [PATCH] effect ticks

---
 server/src/cryp.rs  | 22 ++++++++++++++------
 server/src/skill.rs | 50 ++++++++++++++++++++++++++++++++++-----------
 2 files changed, 54 insertions(+), 18 deletions(-)

diff --git a/server/src/cryp.rs b/server/src/cryp.rs
index 1f7d47f9..62874609 100755
--- a/server/src/cryp.rs
+++ b/server/src/cryp.rs
@@ -9,7 +9,7 @@ use failure::err_msg;
 
 use account::Account;
 use rpc::{CrypSpawnParams};
-use skill::{Skill, Cooldown, Effect};
+use skill::{Skill, Cooldown, Effect, Tick};
 
 #[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
 pub struct CrypSkill {
@@ -32,6 +32,14 @@ impl CrypSkill {
 pub struct CrypEffect {
     pub effect: Effect,
     pub duration: u8,
+    pub tick: Option<Tick>,
+}
+
+impl CrypEffect {
+    pub fn tick(&self, cryp: &mut Cryp) -> &CrypEffect {
+        self.effect.tick(self, cryp);
+        self
+    }
 }
 
 #[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
@@ -211,15 +219,17 @@ impl Cryp {
     }
 
     pub fn reduce_effect_durations(&mut self) -> &mut Cryp {
-        self.effects = self.effects.clone().into_iter().filter_map(|mut s| {
-            s.duration = s.duration.saturating_sub(1);
+        self.effects = self.effects.clone().into_iter().filter_map(|mut effect| {
 
-            if s.duration == 0 {
+            effect.tick(self);
+            effect.duration = effect.duration.saturating_sub(1);
+
+            if effect.duration == 0 {
                 return None;
             }
 
-            println!("reduced effect {:?}", s);
-            return Some(s);
+            println!("reduced effect {:?}", effect);
+            return Some(effect);
         }).collect::<Vec<CrypEffect>>();
 
         self
diff --git a/server/src/skill.rs b/server/src/skill.rs
index 9566dc1c..dd6ce388 100755
--- a/server/src/skill.rs
+++ b/server/src/skill.rs
@@ -30,7 +30,7 @@ impl Cast {
             target_cryp_id,
             target_team_id,
             skill,
-            resolution: Resolution { base: 0, result: None, text: String::new() },
+            resolution: Resolution { base: 0, result: None, text: String::new(),  },
         };
     }
 
@@ -104,6 +104,22 @@ impl Effect {
             _ => false,
         }
     }
+
+    pub fn tick(&self, cryp_effect: &CrypEffect, target: &mut Cryp) -> &Effect {
+        match self {
+            Effect::Decay => decay_tick(target, cryp_effect),
+            // Effect::Triage => triage_tick(target, res),
+            _ => (),
+        }
+
+        self
+    }
+
+}
+
+#[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
+pub struct Tick {
+    amount: u64
 }
 
 #[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
@@ -386,7 +402,7 @@ impl Skill {
             // Preservation
             // -----------------
             Skill::Heal => heal(cryp, target, &mut res),
-            Skill::Triage => panic!("nyi"), // hot
+            Skill::Triage => triage(cryp, target, &mut res), // hot
             Skill::Throw => panic!("nyi"), // no dmg stun, adds vulnerable
             Skill::Charm => panic!("nyi"),
             Skill::Calm => panic!("nyi"),
@@ -397,7 +413,7 @@ impl Skill {
             // -----------------
             Skill::Blast => panic!("nyi"),
             Skill::Amplify => panic!("nyi"),
-            Skill::Decay => panic!("nyi"), // dot
+            Skill::Decay => decay(cryp, target, &mut res), // dot
             Skill::Drain => panic!("nyi"),
             Skill::Curse => panic!("nyi"),
             Skill::Plague => panic!("nyi"), // aoe dot
@@ -469,7 +485,7 @@ fn attack(cryp: &mut Cryp, target: &mut Cryp, res: &mut Resolution) {
 
 fn stun(cryp: &mut Cryp, target: &mut Cryp, res: &mut Resolution) {
     if !target.effects.iter().any(|e| e.effect.prevents(Skill::Stun)) {
-        let stun = CrypEffect { effect: Effect::Stun, duration: Skill::Stun.duration() };
+        let stun = CrypEffect { effect: Effect::Stun, duration: Skill::Stun.duration(), tick: None };
         target.effects.push(stun);
         res.text = format!("{:?} -> {:?} | {:?} for {:?}T", cryp.name, target.name, stun.effect, stun.duration);
     } else {
@@ -478,7 +494,7 @@ fn stun(cryp: &mut Cryp, target: &mut Cryp, res: &mut Resolution) {
 }
 
 fn block(_cryp: &mut Cryp, target: &mut Cryp, res: &mut Resolution) {
-    let effect = CrypEffect { effect: Effect::Block, duration: Skill::Block.duration() };
+    let effect = CrypEffect { effect: Effect::Block, duration: Skill::Block.duration(), tick: None };
     target.effects.push(effect);
     res.text = format!("{:?} is {:?} for {:?}T", target.name, effect.effect, effect.duration);
 }
@@ -495,16 +511,26 @@ fn heal(cryp: &mut Cryp, target: &mut Cryp, res: &mut Resolution) {
     res.text = format!("{:?} -> {:?} | Heal for {:?} ({:?} OH)", cryp.name, target.name, healing, overhealing);
 }
 
-fn triage(cryp: &mut Cryp, target: &mut Cryp, res: &mut Resolution) {
-    target.hp.value.saturating_add(cryp.spell_dmg.value.wrapping_div(2)),
-    let healing = new_hp.saturating_sub(target.hp.value);
-    let overhealing = target.hp.value.saturating_add(cryp.phys_dmg.value).saturating_sub(target.stamina.value);
-    target.hp.value = new_hp;
-    res.text = format!("{:?} -> {:?} | Heal for {:?} ({:?} OH)", cryp.name, target.name, healing, overhealing);
+fn triage(_cryp: &mut Cryp, target: &mut Cryp, res: &mut Resolution) {
+    let effect = CrypEffect { effect: Effect::Triage, duration: Skill::Triage.duration(), tick: None };
+    target.effects.push(effect);
+    res.text = format!("{:?} is {:?} for {:?}T", target.name, effect.effect, effect.duration);
 }
 
+fn decay(cryp: &mut Cryp, target: &mut Cryp, res: &mut Resolution) {
+    let effect = CrypEffect {
+        effect: Effect::Decay,
+        duration: Skill::Decay.duration(),
+        tick: Some(Tick { amount: cryp.spell_dmg.value.wrapping_div(2) })
+    };
+    target.effects.push(effect);
+    res.text = format!("{:?} is {:?} for {:?}T", target.name, effect.effect, effect.duration);
+}
 
-
+fn decay_tick(target: &mut Cryp, effect: &CrypEffect) {
+    let tick = effect.tick.expect("no tick for decay");
+    target.hp.reduce(tick.amount);
+}
 
 #[cfg(test)]
 mod tests {