move durations onto effect

server/src/skill.rs

@@ -260,6 +260,33 @@ impl Effect {
             Effect::Ko => Category::Ko,
         }
     }
+
+    pub fn duration(&self) -> u8 {
+        match self {
+            Effect::Evasion => 1,
+            Effect::Block => 1,
+            Effect::Parry => 1,
+
+            Effect::Stun => 2,
+            Effect::Vulnerable => 2,
+            Effect::Snare => 1,
+
+            Effect::Empower => 2,
+
+            Effect::Decay => 2,
+            Effect::Drain => 2,
+            Effect::Triage => 2,
+
+            Effect::Amplify => 2,
+            Effect::Silence => 2,
+
+            _ => {
+                println!("{:?} does not have a duration", self);
+                return 1;
+            },
+        }
+    }
+
 }
 
 #[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
@@ -723,31 +750,6 @@ impl Skill {
         }
     }
 
-    pub fn duration(&self) -> u8 {
-        match self {
-            Skill::Evade => 1,
-            Skill::Stun => 2,
-            Skill::Block => 1,
-
-            Skill::Empower => 2,
-
-            Skill::Decay => 3,
-            Skill::Drain => 3,
-            Skill::Triage => 3,
-
-            Skill::Amplify => 2,
-            Skill::Silence => 3,
-
-            Skill::TestBlock => 1,
-            Skill::TestParry => 1,
-            Skill::TestStun => 2,
-            _ => {
-                println!("{:?} does not have a duration", self);
-                return 2;
-            },
-        }
-    }
-
     pub fn self_targeting(&self) -> bool {
         match self {
             Skill::Block => true,
@@ -782,7 +784,7 @@ fn attack(cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Res
 }
 
 fn stun(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution {
-    let stun = CrypEffect { effect: Effect::Stun, duration: Skill::Stun.duration(), tick: None };
+    let stun = CrypEffect { effect: Effect::Stun, duration: Effect::Stun.duration(), tick: None };
     let immunity = target.immune(Skill::Stun);
     let immune = immunity.immune;
 
@@ -802,8 +804,8 @@ fn stun(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Reso
 }
 
 fn throw(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution {
-    let stun = CrypEffect { effect: Effect::Stun, duration: Skill::Stun.duration(), tick: None };
+    let stun = CrypEffect { effect: Effect::Stun, duration: Effect::Stun.duration(), tick: None };
-    let vulnerable = CrypEffect { effect: Effect::Vulnerable, duration: Skill::Stun.duration(), tick: None };
+    let vulnerable = CrypEffect { effect: Effect::Vulnerable, duration: Effect::Vulnerable.duration(), tick: None };
     let immunity = target.immune(Skill::Throw);
     let immune = immunity.immune;
 
@@ -832,7 +834,7 @@ fn throw(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Res
 
 
 fn block(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution {
-    let block = CrypEffect { effect: Effect::Block, duration: Skill::Block.duration(), tick: None };
+    let block = CrypEffect { effect: Effect::Block, duration: Effect::Block.duration(), tick: None };
     let immunity = target.immune(Skill::Block);
     let immune = immunity.immune;
 
@@ -852,7 +854,7 @@ fn block(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Res
 }
 
 fn parry(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution {
-    let parry = CrypEffect { effect: Effect::Parry, duration: Skill::Parry.duration(), tick: None };
+    let parry = CrypEffect { effect: Effect::Parry, duration: Effect::Parry.duration(), tick: None };
     let immunity = target.immune(Skill::Parry);
     let immune = immunity.immune;
 
@@ -873,7 +875,7 @@ fn parry(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Res
 
 
 fn evade(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution {
-    let evade = CrypEffect { effect: Effect::Evasion, duration: Skill::Evade.duration(), tick: None };
+    let evade = CrypEffect { effect: Effect::Evasion, duration: Effect::Evasion.duration(), tick: None };
     let immunity = target.immune(Skill::Evade);
     let immune = immunity.immune;
 
@@ -898,7 +900,7 @@ fn evade_roll() -> bool {
 }
 
 fn snare(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution {
-    let snare = CrypEffect { effect: Effect::Snare, duration: Skill::Snare.duration(), tick: None };
+    let snare = CrypEffect { effect: Effect::Snare, duration: Effect::Snare.duration(), tick: None };
     let immunity = target.immune(Skill::Snare);
     let immune = immunity.immune;
 
@@ -918,7 +920,7 @@ fn snare(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Res
 }
 
 fn empower(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution {
-    let empower = CrypEffect { effect: Effect::Empower, duration: Skill::Empower.duration(), tick: None };
+    let empower = CrypEffect { effect: Effect::Empower, duration: Effect::Empower.duration(), tick: None };
     let immunity = target.immune(Skill::Empower);
     let immune = immunity.immune;
 
@@ -963,7 +965,7 @@ fn heal(cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resol
 fn triage(cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution {
     let triage = CrypEffect {
         effect: Effect::Triage,
-        duration: Skill::Triage.duration(),
+        duration: Effect::Triage.duration(),
         tick: Some(Cast::new_tick(cryp, target, Skill::TriageTick)),
     };
     let immunity = target.immune(Skill::Triage);
@@ -1026,7 +1028,7 @@ fn blast(cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Reso
 }
 
 fn amplify(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution {
-    let amplify = CrypEffect { effect: Effect::Amplify, duration: Skill::Amplify.duration(), tick: None };
+    let amplify = CrypEffect { effect: Effect::Amplify, duration: Effect::Amplify.duration(), tick: None };
     let immunity = target.immune(Skill::Amplify);
     let immune = immunity.immune;
 
@@ -1048,7 +1050,7 @@ fn amplify(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> R
 fn decay(cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution {
     let decay = CrypEffect {
         effect: Effect::Decay,
-        duration: Skill::Decay.duration(),
+        duration: Effect::Decay.duration(),
         tick: Some(Cast::new_tick(cryp, target, Skill::DecayTick)),
     };
     let immunity = target.immune(Skill::Empower);
@@ -1090,7 +1092,7 @@ fn decay_tick(cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) ->
 }
 
 fn hex(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution {
-    let hex = CrypEffect { effect: Effect::Hex, duration: Skill::Hex.duration(), tick: None };
+    let hex = CrypEffect { effect: Effect::Hex, duration: Effect::Hex.duration(), tick: None };
     let immunity = target.immune(Skill::Hex);
     let immune = immunity.immune;
 
@@ -1110,7 +1112,7 @@ fn hex(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resol
 }
 
 fn curse(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution {
-    let curse = CrypEffect { effect: Effect::Curse, duration: Skill::Curse.duration(), tick: None };
+    let curse = CrypEffect { effect: Effect::Curse, duration: Effect::Curse.duration(), tick: None };
     let immunity = target.immune(Skill::Curse);
     let immune = immunity.immune;
 
@@ -1132,7 +1134,7 @@ fn curse(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Res
 fn drain(cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution {
     let drain = CrypEffect {
         effect: Effect::Drain,
-        duration: Skill::Drain.duration(),
+        duration: Effect::Drain.duration(),
         tick: Some(Cast::new_tick(cryp, target, Skill::DrainTick)),
     };
     let immunity = target.immune(Skill::Drain);
@@ -1184,7 +1186,7 @@ fn drain_tick(cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) ->
 }
 
 fn shield(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution {
-    let shield = CrypEffect { effect: Effect::Shield, duration: Skill::Shield.duration(), tick: None };
+    let shield = CrypEffect { effect: Effect::Shield, duration: Effect::Shield.duration(), tick: None };
     let immunity = target.immune(Skill::Shield);
     let immune = immunity.immune;
 
@@ -1204,7 +1206,7 @@ fn shield(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Re
 }
 
 fn silence(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution {
-    let silence = CrypEffect { effect: Effect::Silence, duration: Skill::Silence.duration(), tick: None };
+    let silence = CrypEffect { effect: Effect::Silence, duration: Effect::Silence.duration(), tick: None };
     let immunity = target.immune(Skill::Silence);
     let immune = immunity.immune;
 
@@ -1256,7 +1258,7 @@ fn purify(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Re
 }
 
 fn banish(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution {
-    let banish = CrypEffect { effect: Effect::Banish, duration: Skill::Banish.duration(), tick: None };
+    let banish = CrypEffect { effect: Effect::Banish, duration: Effect::Banish.duration(), tick: None };
     let immunity = target.immune(Skill::Banish);
     let immune = immunity.immune;