move into own mod

server/src/effect.rs

@@ -0,0 +1,216 @@
+use construct::{Stat, EffectMeta};
+use skill::{Skill};
+use util::{IntPct};
+
+pub type Cooldown = Option<u8>;
+
+#[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
+pub enum Effect {
+    Amplify,
+    Banish,
+    Block,
+    Buff,
+    Clutch,
+    Curse,
+    Haste,
+    Hex,
+    Impurity,
+    Invert,
+    Parry,
+    Purge,
+    Reflect,
+    Slow,
+    Snare,
+    Stun,
+    Taunt,
+    Vulnerable,
+    Silence,
+    Wither, // Reduce green dmg (healing) taken
+
+    // corrupt is the buff that applies
+    // corruption the dmg debuff
+    Corrupt,
+    Corruption,
+
+    // hostility is the buff
+    // hatred is the increased damage
+    Hostility,
+    Hatred,
+
+    // magic immunity
+    Scatter,
+
+    // effects over time
+    Triage,
+    Decay,
+    Regen,
+    Siphon,
+
+    // Airborne,
+    // Boost
+    // Bleed,
+    // Blind,
+    // Deadly,
+    // Enslave,
+    // Fury,
+    // Injured,
+    // Leech,
+    // Mesmerise,
+    // Untouchable,
+    // SpeedSiphon,
+    // SpeedIncrease,
+
+    Ko,
+}
+
+impl Effect {
+    pub fn immune(&self, skill: Skill) -> bool {
+        match self {
+            Effect::Parry => match skill {
+                Skill::Attack => true,
+                Skill::Stun => true,
+                _ => skill.colours().contains(&Colour::Red)
+            },
+            Effect::Banish => true,
+            Effect::Clutch => [
+                Skill::Stun,
+                Skill::HexI,
+                Skill::HexII,
+                Skill::HexIII,
+                Skill::SilenceI,
+                Skill::SilenceII,
+                Skill::SilenceIII,
+                Skill::RuinI,
+                Skill::RuinII,
+                Skill::RuinIII,
+                Skill::SnareI,
+                Skill::SnareII,
+                Skill::SnareIII
+            ].contains(&skill),
+            _ => false,
+        }
+    }
+
+    pub fn disables_skill(&self, skill: Skill) -> bool {
+        if skill.is_tick() {
+            return false;
+        }
+
+        match self {
+            Effect::Stun => true,
+            Effect::Hex => true,
+            Effect::Banish => true,
+            Effect::Silence => skill.colours().contains(&Colour::Blue),
+            Effect::Snare => skill.colours().contains(&Colour::Red),
+            Effect::Purge => skill.colours().contains(&Colour::Green),
+            Effect::Ko => skill.ko_castable(),
+            _ => false,
+        }
+    }
+
+    pub fn modifications(&self) -> Vec<Stat> {
+        match self {
+            Effect::Vulnerable => vec![Stat::RedDamageTaken],
+            Effect::Block => vec![Stat::RedDamageTaken],
+            Effect::Buff => vec![Stat::RedPower, Stat::Speed],
+
+            Effect::Hatred => vec![Stat::RedPower, Stat::BluePower],
+
+            Effect::Amplify => vec![Stat::RedPower, Stat::BluePower],
+            Effect::Curse => vec![Stat::BlueDamageTaken],
+
+            Effect::Impurity => vec![Stat::GreenPower],
+            Effect::Wither => vec![Stat::GreenDamageTaken],
+
+            Effect::Haste => vec![Stat::Speed],
+            Effect::Slow => vec![Stat::Speed],
+
+            Effect::Scatter => vec![Stat::BlueDamageTaken, Stat::GreenDamageTaken, Stat::RedDamageTaken],
+
+            _ => vec![],
+        }
+    }
+
+    pub fn apply(&self, value: u64, meta: Option<EffectMeta>) -> u64 {
+        match self {
+            Effect::Amplify |
+            Effect::Vulnerable |
+            Effect::Block |
+            Effect::Buff |
+            Effect::Curse |
+            Effect::Haste |
+            Effect::Slow |
+            Effect::Impurity |
+            Effect::Wither  => value.pct(match meta {
+                Some(EffectMeta::Multiplier(d)) => d,
+                _ => 100,
+            }),
+
+            Effect::Scatter     => value >> 1,
+
+            Effect::Hatred      => value + match meta {
+                Some(EffectMeta::AddedDamage(d)) => d,
+                _ => panic!("hatred meta not damage"),
+            },
+
+            _ => {
+                info!("{:?} does not have a mod effect", self);
+                return value;
+            },
+        }
+    }
+
+    pub fn colour(&self) -> Option<Colour> {
+        match self {
+            // physical
+            Effect::Stun => Some(Colour::Red),
+            Effect::Block => Some(Colour::Green),
+            Effect::Buff => Some(Colour::Green),
+            Effect::Parry => Some(Colour::Green),
+            Effect::Vulnerable => Some(Colour::Red),
+            Effect::Snare => Some(Colour::Red),
+            Effect::Clutch => Some(Colour::Green),
+            Effect::Taunt => Some(Colour::Green),
+
+            // magic
+            Effect::Hex => Some(Colour::Blue),
+            Effect::Curse => Some(Colour::Blue),
+            Effect::Banish => None,
+            // Effect::Banish => rng.gen_bool(0.5),
+
+            Effect::Slow => Some(Colour::Blue),
+            Effect::Haste => Some(Colour::Green),
+            Effect::Hatred => Some(Colour::Green),
+            Effect::Reflect => Some(Colour::Green),
+            Effect::Amplify => Some(Colour::Green),
+            Effect::Silence => Some(Colour::Blue),
+            Effect::Wither => Some(Colour::Blue),
+            Effect::Purge => Some(Colour::Blue),
+
+            Effect::Corrupt => Some(Colour::Green),
+            Effect::Corruption => Some(Colour::Blue),
+
+            Effect::Hostility => Some(Colour::Green),
+
+            // magic
+            Effect::Impurity => Some(Colour::Green),
+            Effect::Scatter => Some(Colour::Green),
+            Effect::Invert => Some(Colour::Green),
+
+            // effects over time
+            Effect::Triage => Some(Colour::Green),
+            Effect::Decay => Some(Colour::Blue),
+            Effect::Regen => Some(Colour::Green),
+            Effect::Siphon => Some(Colour::Blue),
+
+            Effect::Ko => None,
+        }
+    }
+}
+
+#[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
+pub enum Colour {
+    Red,
+    Blue,
+    Green,
+}