check immunities

server/src/cryp.rs

@@ -168,8 +168,17 @@ impl Cryp {
         self.hp.base == 0
     }
 
-    pub fn immune(&self, skill: Skill) -> bool {
+    pub fn immune(&self, skill: Skill) -> (bool, Vec<Effect>) {
-        self.effects.iter().any(|e| e.effect.immune(skill))
+        let immunities = self.effects.iter()
+            .filter(|e| e.effect.immune(skill))
+            .map(|e| e.effect)
+            .collect::<Vec<Effect>>();
+
+        if immunities.len() > 0 {
+            return (true, immunities);
+        }
+
+        return (false, vec![]);
     }
 
     pub fn is_stunned(&self) -> bool {

server/src/game.rs

@@ -915,7 +915,7 @@ mod tests {
 
         assert!(game.resolved.iter().any(|r| r.skill == Skill::DrainTick));
 
-        println!("{:#?}", game);
+        // println!("{:#?}", game);
     }
 
 }

server/src/skill.rs

@@ -76,6 +76,8 @@ pub enum Effect {
     Blind,
     Snare,
 
+    Empower,
+
     // magic
     Hex,
     Curse,
@@ -88,7 +90,7 @@ pub enum Effect {
     Silence,
 
     // magic immunity
-    Immune,
+    Shield,
 
     // effects over time
     Triage,
@@ -105,9 +107,14 @@ impl Effect {
         match self {
             Effect::Block => match skill {
                 Skill::Stun |
+                Skill::TestStun |
                 Skill::Attack => true,
                 _ => false,
             },
+            Effect::Shield => match skill.cast_type() {
+                Damage::Magic => true,
+                Damage::Physical => false,
+            }
             _ => false,
         }
     }
@@ -126,13 +133,18 @@ impl Effect {
     pub fn modifications(&self) -> Vec<Stat> {
         match self {
             Effect::Amplify => vec![Stat::SpellDmg],
+            Effect::Empower => vec![Stat::PhysDmg],
             _ => vec![],
         }
     }
 
+    // maybe increase by rng
+    // roll little endian bits
+    // and OR with base stat
     pub fn apply(&self, value: u64) -> u64 {
         match self {
             Effect::Amplify => value << 1,
+            Effect::Empower => value << 1,
             _ => panic!("{:?} does not have a mod effect", self),
         }
     }
@@ -199,7 +211,7 @@ pub enum Skill {
     // -----------------
     // Purity
     // -----------------
-    Inspire,
+    Empower,
     Slay,
     Shield,
     Silence,
@@ -281,7 +293,7 @@ impl Skill {
             // Purity
             // -----------------
             // Skill::Precision => Some(1),
-            Skill::Inspire => Some(2),
+            Skill::Empower => Some(2),
             Skill::Slay => Some(1),
             Skill::Shield => Some(1),
             Skill::Silence => Some(2),
@@ -364,7 +376,7 @@ impl Skill {
             // Purity
             // -----------------
             // Skill::Precision => 1,
-            Skill::Inspire => Damage::Physical,
+            Skill::Empower => Damage::Physical,
             Skill::Slay => Damage::Physical,
             Skill::Shield => Damage::Magic,
             Skill::Silence => Damage::Magic,
@@ -448,7 +460,7 @@ impl Skill {
             // Purity
             // -----------------
             // Skill::Precision => 1,
-            Skill::Inspire => 2,
+            Skill::Empower => 2,
             Skill::Slay => 1,
             Skill::Shield => 1,
             Skill::Silence => 2,
@@ -491,6 +503,12 @@ impl Skill {
 
         //     return Some(roll);
 
+        let (immune, reason) = target.immune(*self);
+        if immune {
+            log.push(format!("{:?} -> {:?} | {:?} immune: {:?}", cryp.name, target.name, self, reason));
+            return;
+        }
+
         match self {
             Skill::Attack => attack(cryp, target, log),
             // -----------------
@@ -531,7 +549,7 @@ impl Skill {
             // Destruction
             // -----------------
             Skill::Blast => blast(cryp, target, log),
-            Skill::Amplify => amplify(cryp, target, log), // TODO increase magic dmg
+            Skill::Amplify => amplify(cryp, target, log), // increase magic dmg
             Skill::Decay => decay(cryp, target, log), // dot
             Skill::DecayTick => decay_tick(cryp, target, log), // hot
             Skill::Drain => drain(cryp, target, log),
@@ -544,7 +562,7 @@ impl Skill {
             // Purity
             // -----------------
             // Skill::Precision => panic!("nyi"),
-            Skill::Inspire => panic!("nyi"), // increased phys dmg
+            Skill::Empower => empower(cryp, target, log), // increased phys dmg
             Skill::Slay => panic!("nyi"), // phys dmg mult by target magic dmg
             Skill::Shield => panic!("nyi"), // target is immune to magic dmg and fx
             Skill::Silence => silence(cryp, target, log), // target cannot cast spells
@@ -576,6 +594,8 @@ impl Skill {
             Skill::Stun => 2,
             Skill::Block => 1,
 
+            Skill::Empower => 2,
+
             Skill::Decay => 3,
             Skill::Drain => 3,
             Skill::Triage => 3,
@@ -608,26 +628,18 @@ fn attack(cryp: &mut Cryp, target: &mut Cryp, log: &mut Log) {
 }
 
 fn stun(cryp: &mut Cryp, target: &mut Cryp, log: &mut Log) {
-    if !target.immune(Skill::Stun) {
+    let stun = CrypEffect { effect: Effect::Stun, duration: Skill::Stun.duration(), tick: None };
-        let stun = CrypEffect { effect: Effect::Stun, duration: Skill::Stun.duration(), tick: None };
+    target.effects.push(stun);
-        target.effects.push(stun);
+    log.push(format!("{:?} -> {:?} | {:?} for {:?}T", cryp.name, target.name, stun.effect, stun.duration));
-        log.push(format!("{:?} -> {:?} | {:?} for {:?}T", cryp.name, target.name, stun.effect, stun.duration));
-    } else {
-        log.push(format!("{:?} -> {:?} | {:?} immune", cryp.name, target.name, target.name));
-    }
 }
 
 fn throw(cryp: &mut Cryp, target: &mut Cryp, log: &mut Log) {
-    if !target.immune(Skill::Throw) {
+    let stun = CrypEffect { effect: Effect::Stun, duration: Skill::Stun.duration(), tick: None };
-        let stun = CrypEffect { effect: Effect::Stun, duration: Skill::Stun.duration(), tick: None };
+    let vulnerable = CrypEffect { effect: Effect::Vulnerable, duration: Skill::Stun.duration(), tick: None };
-        let vulnerable = CrypEffect { effect: Effect::Vulnerable, duration: Skill::Stun.duration(), tick: None };
+    target.effects.push(stun);
-        target.effects.push(stun);
+    target.effects.push(vulnerable);
-        target.effects.push(vulnerable);
+    log.push(format!("{:?} -> {:?} | {:?} for {:?}T", cryp.name, target.name, stun.effect, stun.duration));
-        log.push(format!("{:?} -> {:?} | {:?} for {:?}T", cryp.name, target.name, stun.effect, stun.duration));
+    log.push(format!("{:?} -> {:?} | {:?} for {:?}T", cryp.name, target.name, vulnerable.effect, vulnerable.duration));
-        log.push(format!("{:?} -> {:?} | {:?} for {:?}T", cryp.name, target.name, vulnerable.effect, vulnerable.duration));
-    } else {
-        log.push(format!("{:?} -> {:?} | {:?} immune", cryp.name, target.name, target.name));
-    }
 }
 
 
@@ -643,6 +655,12 @@ fn snare(_cryp: &mut Cryp, target: &mut Cryp, log: &mut Log) {
     log.push(format!("{:?} < {:?} for {:?}T", target.name, effect.effect, effect.duration));
 }
 
+fn empower(_cryp: &mut Cryp, target: &mut Cryp, log: &mut Log) {
+    let effect = CrypEffect { effect: Effect::Empower, duration: Skill::Empower.duration(), tick: None };
+    target.effects.push(effect);
+    log.push(format!("{:?} < {:?} for {:?}T", target.name, effect.effect, effect.duration));
+}
+
 fn heal(cryp: &mut Cryp, target: &mut Cryp, log: &mut Log) {
     let (healing, overhealing) = target.heal(cryp.phys_dmg());
     log.push(format!("{:?} -> {:?} | Heal for {:?} ({:?} OH)", cryp.name, target.name, healing, overhealing));