goddamn borrow checker

server/src/cryp.rs

@@ -9,7 +9,7 @@ use failure::err_msg;
 
 use account::Account;
 use rpc::{CrypSpawnParams, CrypLearnParams, CrypForgetParams};
-use skill::{Skill, Cooldown, Effect, Cast, Source};
+use skill::{Skill, Cooldown, Effect, Cast, Immunity};
 use game::{Log};
 
 #[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
@@ -29,7 +29,7 @@ impl CrypSkill {
     }
 }
 
-#[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
+#[derive(Debug,Clone,PartialEq,Serialize,Deserialize)]
 pub struct CrypEffect {
     pub effect: Effect,
     pub duration: u8,
@@ -178,17 +178,17 @@ impl Cryp {
         self.hp.base == 0
     }
 
-    pub fn immune(&self, skill: Skill) -> (bool, Vec<Effect>) {
+    pub fn immune(&self, skill: Skill) -> Immunity {
         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 Immunity { immune: true, effects: immunities};
         }
 
-        return (false, vec![]);
+        return Immunity { immune: false, effects: vec![]};
     }
 
     pub fn is_stunned(&self) -> bool {

server/src/game.rs

@@ -389,11 +389,9 @@ impl Game {
             let mut source = self.cryp_by_id(skill.source_cryp_id).unwrap().clone();
             let mut target = self.cryp_by_id(skill.target_cryp_id.unwrap()).unwrap().clone();
 
-            // self.log.push(format!("{:?} uses {:?} on {:?}", source.name, skill.skill, target.name));
             skill.set_resolution(&mut source, &mut target, &mut self.log);
             self.resolved.push(skill.clone());
 
-
             self.update_cryp(&mut source);
             self.update_cryp(&mut target);
 
@@ -444,6 +442,15 @@ impl Game {
 
     fn finish(&mut self) -> &mut Game {
         self.phase = Phase::Finish;
+        self.log.push(format!("Game finished."));
+
+        {
+            let winner = self.teams.iter().find(|t| t.cryps.iter().any(|c| !c.is_ko()));
+            match winner {
+                Some(w) => self.log.push(format!("Winner: {:?}", w.id)),
+                None => self.log.push(format!("Game was drawn.")),
+            };
+        }
 
         self.stack.clear();
 

server/src/skill.rs

@@ -4,13 +4,15 @@ use uuid::Uuid;
 use game::{Log};
 use cryp::{Cryp, CrypEffect, Stat};
 
-#[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
+#[derive(Debug,Clone,PartialEq,Serialize,Deserialize)]
 pub struct Cast {
     pub id: Uuid,
-    pub skill: Skill, pub source_team_id: Uuid,
+    pub skill: Skill,
+    pub source_team_id: Uuid,
     pub source_cryp_id: Uuid,
     pub target_cryp_id: Option<Uuid>,
     pub target_team_id: Uuid,
+    pub resolution: Resolution,
 }
 
 impl Cast {
@@ -28,6 +30,7 @@ impl Cast {
             target_cryp_id,
             target_team_id,
             skill,
+            resolution: Resolution { skill, results: vec![] },
         };
     }
 
@@ -38,7 +41,7 @@ impl Cast {
     }
 
     pub fn set_resolution(&mut self, cryp: &mut Cryp, target: &mut Cryp, log: &mut Log) -> &mut Cast {
-        self.skill.resolve(cryp, target, log);
+        self.resolution = self.skill.resolve(cryp, target, log);
         self
     }
 
@@ -52,15 +55,29 @@ impl Cast {
     }
 }
 
+
+#[derive(Debug,Clone,PartialEq,Serialize,Deserialize)]
+pub struct Immunity {
+    pub immune: bool,
+    pub effects: Vec<Effect>
+}
+
+#[derive(Debug,Clone,PartialEq,Serialize,Deserialize)]
+pub enum ResolutionResult {
+    Damage { amount: u64, category: Category , immunity: Immunity },
+    Effect { effect: Effect, duration: u8, immunity: Immunity },
+    Removal { effect: Effect, immunity: Immunity },
+}
+
 #[derive(Debug,Clone,PartialEq,Serialize,Deserialize)]
 pub struct Resolution {
-    pub base: u64,
+    pub skill: Skill,
-    pub result: Option<u64>,
+    pub results: Vec<ResolutionResult>,
 }
 
 pub type Cooldown = Option<u8>;
 
-#[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
+#[derive(Debug,Clone,PartialEq,Serialize,Deserialize)]
 pub enum Effect {
     // physical
     Stun,
@@ -111,9 +128,10 @@ impl Effect {
                 Skill::Attack => true,
                 _ => false,
             },
-            Effect::Shield => match skill.cast_type() {
+            Effect::Shield => match skill.category() {
-                Damage::Magic => true,
+                Category::Spell => true,
-                Damage::Physical => false,
+                Category::Physical => false,
+                _ => false,
             },
             Effect::Banish => true,
             _ => false,
@@ -123,9 +141,10 @@ impl Effect {
     pub fn prevents_casting(&self, skill: Skill) -> bool {
         match self {
             Effect::Stun => true,
-            Effect::Silence => match skill.cast_type() {
+            Effect::Silence => match skill.category() {
-                Damage::Magic => true,
+                Category::Spell => true,
-                Damage::Physical => false,
+                Category::Physical => false,
+                _ => false,
             },
             _ => false,
         }
@@ -150,67 +169,62 @@ impl Effect {
         }
     }
 
-    pub fn source(&self) -> Source {
+    pub fn category(&self) -> Category {
         match self {
             // physical
-            Effect::Stun => Source::Debuff,
+            Effect::Stun => Category::PhysDebuff,
-            Effect::Block => Source::Buff,
+            Effect::Block => Category::PhysBuff,
-            Effect::Bleed => Source::Debuff,
+            Effect::Bleed => Category::PhysDebuff,
-            Effect::Leech => Source::Debuff,
+            Effect::Leech => Category::PhysDebuff,
-            Effect::Airborne => Source::Buff,
+            Effect::Airborne => Category::PhysDebuff,
-            Effect::Untouchable => Source::Buff,
+            Effect::Untouchable => Category::PhysBuff,
-            Effect::Deadly => Source::Buff,
+            Effect::Deadly => Category::PhysBuff,
-            Effect::Vulnerable => Source::Debuff,
+            Effect::Vulnerable => Category::PhysDebuff,
-            Effect::Fury => Source::Buff,
+            Effect::Fury => Category::PhysBuff,
-            Effect::Evasion => Source::Buff,
+            Effect::Evasion => Category::PhysBuff,
-            Effect::Blind => Source::Debuff,
+            Effect::Blind => Category::PhysDebuff,
-            Effect::Snare => Source::Debuff,
+            Effect::Snare => Category::PhysDebuff,
 
-            Effect::Empower => Source::Buff,
+            Effect::Empower => Category::PhysBuff,
 
             // magic
-            Effect::Hex => Source::Debuff,
+            Effect::Hex => Category::SpellDebuff,
-            Effect::Curse => Source::Debuff,
+            Effect::Curse => Category::SpellDebuff,
-            Effect::Banish => Source::Debuff, // todo randomise
+            Effect::Banish => Category::SpellDebuff, // todo randomise
-            Effect::Slow => Source::Debuff,
+            Effect::Slow => Category::SpellDebuff,
-            Effect::Haste => Source::Buff,
+            Effect::Haste => Category::SpellBuff,
-            Effect::Enslave => Source::Debuff,
+            Effect::Enslave => Category::SpellDebuff,
-            Effect::Mesmerise => Source::Debuff,
+            Effect::Mesmerise => Category::SpellDebuff,
-            Effect::Amplify => Source::Buff,
+            Effect::Amplify => Category::SpellBuff,
-            Effect::Silence => Source::Debuff,
+            Effect::Silence => Category::SpellDebuff,
 
             // magic immunity
-            Effect::Shield => Source::Buff,
+            Effect::Shield => Category::SpellBuff,
 
             // effects over time
-            Effect::Triage => Source::Buff,
+            Effect::Triage => Category::SpellBuff,
-            Effect::Decay => Source::Debuff,
+            Effect::Decay => Category::SpellDebuff,
-            Effect::Regen => Source::Buff,
+            Effect::Regen => Category::SpellBuff,
-            Effect::Drain => Source::Debuff,
+            Effect::Drain => Category::SpellDebuff,
 
-            Effect::SpeedDrain => Source::Debuff,
+            Effect::SpeedDrain => Category::SpellDebuff,
-            Effect::SpeedIncrease => Source::Buff,
+            Effect::SpeedIncrease => Category::SpellBuff,
         }
     }
 }
 
 #[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
-pub enum Damage {
+pub enum Category {
     Physical,
-    Magic,
+    PhysHeal,
-}
+    PhysDmg,
-
+    PhysDebuff,
-// #[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
+    PhysBuff,
-// enum Style {
+    Spell,
-//     Offensive,
+    SpellDmg,
-//     Defensive,
+    SpellHeal,
-// }
+    SpellDebuff,
-
+    SpellBuff,
-#[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
-pub enum Source {
-    Buff,
-    Debuff,
-    Stat,
 }
 
 #[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
@@ -379,88 +393,88 @@ impl Skill {
         }
     }
 
-    pub fn cast_type(&self) -> Damage {
+    pub fn category(&self) -> Category {
         match self {
-            Skill::Attack => Damage::Physical,
+            Skill::Attack => Category::Physical,
 
             // -----------------
             // Nature
             // -----------------
-            Skill::Block => Damage::Physical, // reduce dmg
+            Skill::Block => Category::Physical, // reduce dmg
-            Skill::Evade => Damage::Physical,
+            Skill::Evade => Category::Physical,
-            Skill::Parry => Damage::Physical, // avoid all dmg
+            Skill::Parry => Category::Physical, // avoid all dmg
-            Skill::Snare => Damage::Physical,
+            Skill::Snare => Category::Physical,
 
-            Skill::Paralyse => Damage::Physical,
+            Skill::Paralyse => Category::Physical,
-            Skill::Strangle => Damage::Physical,
+            Skill::Strangle => Category::Physical,
 
             // Strangle
 
-            Skill::Stun => Damage::Physical,
+            Skill::Stun => Category::Physical,
-            Skill::Evasion => Damage::Physical, // additional layer of dmg avoidance
+            Skill::Evasion => Category::Physical, // additional layer of dmg avoidance
 
             // -----------------
             // Technology
             // -----------------
-            Skill::Replicate => Damage::Physical,
+            Skill::Replicate => Category::Physical,
-            Skill::Swarm => Damage::Physical,
+            Skill::Swarm => Category::Physical,
-            Skill::Orbit => Damage::Physical,
+            Skill::Orbit => Category::Physical,
-            Skill::Repair => Damage::Physical,
+            Skill::Repair => Category::Physical,
-            Skill::Scan => Damage::Physical, // track?
+            Skill::Scan => Category::Physical, // track?
 
             // -----------------
             // Preservation
             // -----------------
-            Skill::Heal => Damage::Physical,
+            Skill::Heal => Category::Physical,
-            Skill::Triage => Damage::Physical, // hot
+            Skill::Triage => Category::Physical, // hot
-            Skill::TriageTick => Damage::Physical, // hot
+            Skill::TriageTick => Category::Physical, // hot
-            Skill::Throw => Damage::Physical, // no dmg stun, adds vulnerable
+            Skill::Throw => Category::Physical, // no dmg stun, adds vulnerable
-            Skill::Charm => Damage::Physical,
+            Skill::Charm => Category::Physical,
-            Skill::Calm => Damage::Physical,
+            Skill::Calm => Category::Physical,
-            Skill::Rez => Damage::Physical,
+            Skill::Rez => Category::Physical,
 
             // -----------------
             // Destruction
             // -----------------
-            Skill::Blast => Damage::Magic,
+            Skill::Blast => Category::Spell,
-            Skill::Amplify => Damage::Magic,
+            Skill::Amplify => Category::Spell,
-            Skill::Decay => Damage::Magic, // dot
+            Skill::Decay => Category::Spell, // dot
-            Skill::DecayTick => Damage::Magic, // hot
+            Skill::DecayTick => Category::Spell, // hot
-            Skill::Drain => Damage::Magic,
+            Skill::Drain => Category::Spell,
-            Skill::DrainTick => Damage::Magic, // hot
+            Skill::DrainTick => Category::Spell, // hot
-            Skill::Curse => Damage::Magic,
+            Skill::Curse => Category::Spell,
-            Skill::Plague => Damage::Magic, // aoe dot
+            Skill::Plague => Category::Spell, // aoe dot
-            Skill::Ruin => Damage::Magic, // aoe
+            Skill::Ruin => Category::Spell, // aoe
 
             // -----------------
             // Purity
             // -----------------
             // Skill::Precision => 1,
-            Skill::Empower => Damage::Physical,
+            Skill::Empower => Category::Physical,
-            Skill::Slay => Damage::Physical,
+            Skill::Slay => Category::Physical,
-            Skill::Shield => Damage::Magic,
+            Skill::Shield => Category::Spell,
-            Skill::Silence => Damage::Magic,
+            Skill::Silence => Category::Spell,
-            Skill::Inquiry => Damage::Magic,
+            Skill::Inquiry => Category::Spell,
-            Skill::Purify => Damage::Magic,
+            Skill::Purify => Category::Spell,
-            Skill::Purge => Damage::Magic,
+            Skill::Purge => Category::Spell,
 
             // -----------------
             // Chaos
             // -----------------
-            Skill::Banish => Damage::Magic,
+            Skill::Banish => Category::Spell,
-            Skill::Hex => Damage::Magic,
+            Skill::Hex => Category::Spell,
-            Skill::Fear => Damage::Magic,
+            Skill::Fear => Category::Spell,
-            Skill::Taunt => Damage::Magic,
+            Skill::Taunt => Category::Spell,
-            Skill::Pause => Damage::Magic, // extend durations
+            Skill::Pause => Category::Spell, // extend durations
             // Skill::Lag => 2, //
 
             // -----------------
             // Test
             // -----------------
-            Skill::TestTouch => Damage::Physical,
+            Skill::TestTouch => Category::Physical,
-            Skill::TestStun => Damage::Physical,
+            Skill::TestStun => Category::Physical,
-            Skill::TestBlock => Damage::Physical,
+            Skill::TestBlock => Category::Physical,
-            Skill::TestDrain => Damage::Magic,
+            Skill::TestDrain => Category::Spell,
         }
     }
 
@@ -549,28 +563,10 @@ impl Skill {
         }
     }
 
-    pub fn resolve(&self, cryp: &mut Cryp, target: &mut Cryp, log: &mut Log) {
+    pub fn resolve(&self, cryp: &mut Cryp, target: &mut Cryp, log: &mut Log) -> Resolution {
         let mut rng = thread_rng();
         let base: u64 = rng.gen();
 
-        // let res = Resolution { base, result: None };
-
-        //     println!("{:?}'s stats", self.name);
-        //     println!("{:064b}   <- finalised", roll.result);
-        //     roll.result = roll.result & stat();
-
-        //     println!("{:064b} & <- attribute roll", stat());
-        //     println!("{:064b} = {:?}", roll.result, roll.result);
-        //     println!("");
-
-        //     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),
             // -----------------
@@ -644,11 +640,11 @@ impl Skill {
             // -----------------
             // Test
             // -----------------
-            Skill::TestTouch => (),
+            Skill::TestTouch => Resolution { skill: Skill::TestTouch, results: vec![] },
             Skill::TestStun => stun(cryp, target, log),
             Skill::TestBlock => block(cryp, target, log),
             Skill::TestDrain => drain(cryp, target, log),
-        };
+        }
     }
 
     pub fn duration(&self) -> u8 {
@@ -685,159 +681,473 @@ impl Skill {
     }
 }
 
-fn attack(cryp: &mut Cryp, target: &mut Cryp, log: &mut Log) {
+fn attack(cryp: &mut Cryp, target: &mut Cryp, log: &mut Log) -> Resolution {
-    target.deal_phys_dmg(cryp.phys_dmg());
+    let amount = cryp.phys_dmg();
+    let immunity = target.immune(Skill::Attack);
+
+    let attack_result = ResolutionResult::Damage {
+        amount,
+        category: Category::PhysDmg,
+        immunity,
+    };
+
+    let mut resolution = Resolution { skill: Skill::Attack, results: vec![attack_result] };
+
+    if !immunity.immune {
+        target.deal_phys_dmg(amount);
+    }
+
     log.push(format!("{:?} -> {:?} | Attack for {:?}", cryp.name, target.name, cryp.phys_dmg));
+
+    return resolution;
 }
 
-fn stun(cryp: &mut Cryp, target: &mut Cryp, log: &mut Log) {
+fn stun(cryp: &mut Cryp, target: &mut Cryp, log: &mut Log) -> Resolution {
     let stun = CrypEffect { effect: Effect::Stun, duration: Skill::Stun.duration(), tick: None };
-    target.effects.push(stun);
+    let immunity = target.immune(Skill::Stun);
+
+    let attack_result = ResolutionResult::Effect {
+        effect: stun.effect,
+        duration: stun.duration,
+        immunity,
+    };
+
+    let mut resolution = Resolution { skill: Skill::Stun, results: vec![attack_result] };
+
+    if !immunity.immune {
+        target.effects.push(stun);
+    }
+
     log.push(format!("{:?} -> {:?} | {:?} for {:?}T", cryp.name, target.name, stun.effect, stun.duration));
+    return resolution;
 }
 
-fn throw(cryp: &mut Cryp, target: &mut Cryp, log: &mut Log) {
+fn throw(cryp: &mut Cryp, target: &mut Cryp, log: &mut Log) -> Resolution {
     let stun = CrypEffect { effect: Effect::Stun, duration: Skill::Stun.duration(), tick: None };
     let vulnerable = CrypEffect { effect: Effect::Vulnerable, duration: Skill::Stun.duration(), tick: None };
-    target.effects.push(stun);
+    let immunity = target.immune(Skill::Throw);
-    target.effects.push(vulnerable);
+
+    let stun_result = ResolutionResult::Effect {
+        effect: stun.effect,
+        duration: stun.duration,
+        immunity,
+    };
+
+    let vulnerable_result = ResolutionResult::Effect {
+        effect: vulnerable.effect,
+        duration: vulnerable.duration,
+        immunity,
+    };
+
+    let mut resolution = Resolution { skill: Skill::Throw, results: vec![stun_result, vulnerable_result] };
+
+    if !immunity.immune {
+        target.effects.push(stun);
+        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, vulnerable.effect, vulnerable.duration));
+    return resolution;
 }
 
 
-fn block(_cryp: &mut Cryp, target: &mut Cryp, log: &mut Log) {
+fn block(_cryp: &mut Cryp, target: &mut Cryp, log: &mut Log) -> Resolution {
-    let effect = CrypEffect { effect: Effect::Block, duration: Skill::Block.duration(), tick: None };
+    let block = CrypEffect { effect: Effect::Block, duration: Skill::Block.duration(), tick: None };
-    target.effects.push(effect);
+    let immunity = target.immune(Skill::Block);
-    log.push(format!("{:?} < {:?} for {:?}T", target.name, effect.effect, effect.duration));
+
+    let block_result = ResolutionResult::Effect {
+        effect: block.effect,
+        duration: block.duration,
+        immunity,
+    };
+
+    let mut resolution = Resolution { skill: Skill::Block, results: vec![block_result] };
+
+    if !immunity.immune {
+        target.effects.push(block);
+    }
+
+    log.push(format!("{:?} -> {:?} | {:?} for {:?}T", target.name, target.name, block.effect, block.duration));
+    return resolution;
 }
 
-fn snare(_cryp: &mut Cryp, target: &mut Cryp, log: &mut Log) {
+fn snare(cryp: &mut Cryp, target: &mut Cryp, log: &mut Log) -> Resolution {
-    let effect = CrypEffect { effect: Effect::Snare, duration: Skill::Snare.duration(), tick: None };
+    let snare = CrypEffect { effect: Effect::Snare, duration: Skill::Snare.duration(), tick: None };
-    target.effects.push(effect);
+    let immunity = target.immune(Skill::Snare);
-    log.push(format!("{:?} < {:?} for {:?}T", target.name, effect.effect, effect.duration));
+
+    let snare_result = ResolutionResult::Effect {
+        effect: snare.effect,
+        duration: snare.duration,
+        immunity,
+    };
+
+    let mut resolution = Resolution { skill: Skill::Snare, results: vec![snare_result] };
+
+    if !immunity.immune {
+        target.effects.push(snare);
+    }
+
+    log.push(format!("{:?} -> {:?} | {:?} for {:?}T", cryp.name, target.name, snare.effect, snare.duration));
+    return resolution;
 }
 
-fn empower(_cryp: &mut Cryp, target: &mut Cryp, log: &mut Log) {
+fn empower(cryp: &mut Cryp, target: &mut Cryp, log: &mut Log) -> Resolution {
-    let effect = CrypEffect { effect: Effect::Empower, duration: Skill::Empower.duration(), tick: None };
+    let empower = CrypEffect { effect: Effect::Empower, duration: Skill::Empower.duration(), tick: None };
-    target.effects.push(effect);
+    let immunity = target.immune(Skill::Empower);
-    log.push(format!("{:?} < {:?} for {:?}T", target.name, effect.effect, effect.duration));
+
+    let snare_result = ResolutionResult::Effect {
+        effect: empower.effect,
+        duration: empower.duration,
+        immunity,
+    };
+
+    let mut resolution = Resolution { skill: Skill::Empower, results: vec![snare_result] };
+
+    if !immunity.immune {
+        target.effects.push(empower);
+    }
+
+    log.push(format!("{:?} -> {:?} | {:?} for {:?}T", cryp.name, target.name, empower.effect, empower.duration));
+    return resolution;
 }
 
-fn heal(cryp: &mut Cryp, target: &mut Cryp, log: &mut Log) {
+// TODO put overhealing back
-    let (healing, overhealing) = target.heal(cryp.phys_dmg());
+fn heal(cryp: &mut Cryp, target: &mut Cryp, log: &mut Log) -> Resolution {
-    log.push(format!("{:?} -> {:?} | Heal for {:?} ({:?} OH)", cryp.name, target.name, healing, overhealing));
+    let amount = cryp.phys_dmg();
+    let immunity = target.immune(Skill::Heal);
+
+    let heal_result = ResolutionResult::Damage {
+        amount,
+        category: Category::PhysHeal,
+        immunity,
+    };
+
+    let mut resolution = Resolution { skill: Skill::Heal, results: vec![heal_result] };
+
+    if !immunity.immune {
+        let (healing, overhealing) = target.heal(amount);
+    }
+
+    log.push(format!("{:?} -> {:?} | Attack for {:?}", cryp.name, target.name, amount));
+
+    return resolution;
+
 }
 
-fn triage(cryp: &mut Cryp, target: &mut Cryp, log: &mut Log) {
+fn triage(cryp: &mut Cryp, target: &mut Cryp, log: &mut Log) -> Resolution {
-    let effect = CrypEffect {
+    let triage = CrypEffect {
         effect: Effect::Triage,
         duration: Skill::Triage.duration(),
         tick: Some(Cast::new_tick(cryp, target, Skill::TriageTick)),
     };
-    target.effects.push(effect);
+    let immunity = target.immune(Skill::Triage);
-    log.push(format!("{:?} < {:?} for {:?}T", target.name, effect.effect, effect.duration));
+
+    let snare_result = ResolutionResult::Effect {
+        effect: triage.effect,
+        duration: triage.duration,
+        immunity,
+    };
+
+    let mut resolution = Resolution { skill: Skill::Triage, results: vec![snare_result] };
+
+    if !immunity.immune {
+        target.effects.push(triage);
+    }
+
+    log.push(format!("{:?} -> {:?} | {:?} for {:?}T", cryp.name, target.name, triage.effect, triage.duration));
+    return resolution;
 }
 
-fn triage_tick(cryp: &mut Cryp, target: &mut Cryp, log: &mut Log) {
+fn triage_tick(cryp: &mut Cryp, target: &mut Cryp, log: &mut Log) -> Resolution {
     let amount = cryp.spell_dmg().wrapping_div(2);
-    let (healing, overhealing) = target.heal(amount);
+    let immunity = target.immune(Skill::TriageTick);
-    log.push(format!("{:?} -> {:?} | Triage for {:?} ({:?} OH)", cryp.name, target.name, healing, overhealing));
+
+    let heal_result = ResolutionResult::Damage {
+        amount,
+        category: Category::PhysHeal,
+        immunity,
+    };
+
+    let mut resolution = Resolution { skill: Skill::TriageTick, results: vec![heal_result] };
+
+    if !immunity.immune {
+        let (healing, overhealing) = target.heal(amount);
+    }
+
+    log.push(format!("{:?} -> {:?} | Attack for {:?}", cryp.name, target.name, amount));
+
+    return resolution;
 }
 
-fn blast(cryp: &mut Cryp, target: &mut Cryp, log: &mut Log) {
+fn blast(cryp: &mut Cryp, target: &mut Cryp, log: &mut Log) -> Resolution {
     let amount = cryp.spell_dmg();
-    log.push(format!("{:?} -> {:?} | Blast for {:?}", cryp.name, target.name, amount));
+    let immunity = target.immune(Skill::Blast);
-    target.deal_spell_dmg(amount);
+
+    let blast_result = ResolutionResult::Damage {
+        amount,
+        category: Category::SpellDmg,
+        immunity,
+    };
+
+    let mut resolution = Resolution { skill: Skill::Blast, results: vec![blast_result] };
+
+    if !immunity.immune {
+        target.deal_spell_dmg(amount);
+    }
+
+    return resolution;
 }
 
-fn amplify(_cryp: &mut Cryp, target: &mut Cryp, log: &mut Log) {
+fn amplify(cryp: &mut Cryp, target: &mut Cryp, log: &mut Log) -> Resolution {
-    let effect = CrypEffect { effect: Effect::Amplify, duration: Skill::Amplify.duration(), tick: None };
+    let amplify = CrypEffect { effect: Effect::Amplify, duration: Skill::Amplify.duration(), tick: None };
-    target.effects.push(effect);
+    let immunity = target.immune(Skill::Amplify);
-    log.push(format!("{:?} < {:?} for {:?}T", target.name, effect.effect, effect.duration));
+
+    let amplify_result = ResolutionResult::Effect {
+        effect: amplify.effect,
+        duration: amplify.duration,
+        immunity,
+    };
+
+    let mut resolution = Resolution { skill: Skill::Amplify, results: vec![amplify_result] };
+
+    if !immunity.immune {
+        target.effects.push(amplify);
+    }
+
+    log.push(format!("{:?} -> {:?} | {:?} for {:?}T", cryp.name, target.name, amplify.effect, amplify.duration));
+    return resolution;;
 }
 
-fn decay(cryp: &mut Cryp, target: &mut Cryp, log: &mut Log) {
+fn decay(cryp: &mut Cryp, target: &mut Cryp, log: &mut Log) -> Resolution {
-    let effect = CrypEffect {
+    let decay = CrypEffect {
         effect: Effect::Decay,
         duration: Skill::Decay.duration(),
         tick: Some(Cast::new_tick(cryp, target, Skill::DecayTick)),
     };
-    target.effects.push(effect);
+    let immunity = target.immune(Skill::Empower);
-    log.push(format!("{:?} < {:?} for {:?}T", target.name, effect.effect, effect.duration));
+
+    let decay_result = ResolutionResult::Effect {
+        effect: decay.effect,
+        duration: decay.duration,
+        immunity,
+    };
+
+    let mut resolution = Resolution { skill: Skill::Decay, results: vec![decay_result] };
+
+    if !immunity.immune {
+        target.effects.push(decay);
+    }
+
+    log.push(format!("{:?} -> {:?} | {:?} for {:?}T", cryp.name, target.name, decay.effect, decay.duration));
+    return resolution;
 }
 
-fn decay_tick(cryp: &mut Cryp, target: &mut Cryp, log: &mut Log) {
+fn decay_tick(cryp: &mut Cryp, target: &mut Cryp, log: &mut Log) -> Resolution {
     let amount = cryp.spell_dmg();
-    log.push(format!("{:?} -> {:?} | Decay for {:?}", cryp.name, target.name, amount));
+    let immunity = target.immune(Skill::DecayTick);
-    target.deal_spell_dmg(amount);
+
+    let decay_tick_result = ResolutionResult::Damage {
+        amount,
+        category: Category::SpellDmg,
+        immunity,
+    };
+
+    let mut resolution = Resolution { skill: Skill::DecayTick, results: vec![decay_tick_result] };
+
+    if !immunity.immune {
+        target.deal_spell_dmg(amount);
+    }
+
+    return resolution;
 }
 
-fn hex(_cryp: &mut Cryp, target: &mut Cryp, log: &mut Log) {
+fn hex(cryp: &mut Cryp, target: &mut Cryp, log: &mut Log) -> Resolution {
-    let effect = CrypEffect { effect: Effect::Hex, duration: Skill::Hex.duration(), tick: None };
+    let hex = CrypEffect { effect: Effect::Hex, duration: Skill::Hex.duration(), tick: None };
-    target.effects.push(effect);
+    let immunity = target.immune(Skill::Hex);
-    log.push(format!("{:?} < {:?} for {:?}T", target.name, effect.effect, effect.duration));
+
+    let hex_result = ResolutionResult::Effect {
+        effect: hex.effect,
+        duration: hex.duration,
+        immunity,
+    };
+
+    let mut resolution = Resolution { skill: Skill::Hex, results: vec![hex_result] };
+
+    if !immunity.immune {
+        target.effects.push(hex);
+    }
+
+    log.push(format!("{:?} -> {:?} | {:?} for {:?}T", cryp.name, target.name, hex.effect, hex.duration));
+    return resolution;;
 }
 
-fn curse(_cryp: &mut Cryp, target: &mut Cryp, log: &mut Log) {
+fn curse(cryp: &mut Cryp, target: &mut Cryp, log: &mut Log) -> Resolution {
-    let effect = CrypEffect { effect: Effect::Curse, duration: Skill::Curse.duration(), tick: None };
+    let curse = CrypEffect { effect: Effect::Curse, duration: Skill::Curse.duration(), tick: None };
-    target.effects.push(effect);
+    let immunity = target.immune(Skill::Curse);
-    log.push(format!("{:?} < {:?} for {:?}T", target.name, effect.effect, effect.duration));
+
+    let curse_result = ResolutionResult::Effect {
+        effect: curse.effect,
+        duration: curse.duration,
+        immunity,
+    };
+
+    let mut resolution = Resolution { skill: Skill::Curse, results: vec![curse_result] };
+
+    if !immunity.immune {
+        target.effects.push(curse);
+    }
+
+    log.push(format!("{:?} -> {:?} | {:?} for {:?}T", cryp.name, target.name, curse.effect, curse.duration));
+    return resolution;;
 }
 
-fn drain(cryp: &mut Cryp, target: &mut Cryp, log: &mut Log) {
+fn drain(cryp: &mut Cryp, target: &mut Cryp, log: &mut Log) -> Resolution {
-    let effect = CrypEffect {
+    let drain = CrypEffect {
         effect: Effect::Drain,
         duration: Skill::Drain.duration(),
         tick: Some(Cast::new_tick(cryp, target, Skill::DrainTick)),
     };
-    target.effects.push(effect);
+    let immunity = target.immune(Skill::Drain);
-    log.push(format!("{:?} < {:?} for {:?}T", target.name, effect.effect, effect.duration));
+
+    let drain_result = ResolutionResult::Effect {
+        effect: drain.effect,
+        duration: drain.duration,
+        immunity,
+    };
+
+    let mut resolution = Resolution { skill: Skill::Drain, results: vec![drain_result] };
+
+    if !immunity.immune {
+        target.effects.push(drain);
+    }
+
+    log.push(format!("{:?} -> {:?} | {:?} for {:?}T", cryp.name, target.name, drain.effect, drain.duration));
+    return resolution;;
 }
 
-fn drain_tick(cryp: &mut Cryp, target: &mut Cryp, log: &mut Log) {
+// TODO is fukt
-    // Damage part
+fn drain_tick(cryp: &mut Cryp, target: &mut Cryp, log: &mut Log) -> Resolution {
-    let (damage, _) = target.deal_spell_dmg(cryp.spell_dmg().wrapping_div(2));
+    let amount = cryp.spell_dmg().wrapping_div(2);
-    log.push(format!("{:?} | Drain Damage {:?}", target.name, damage));
+    let immunity = target.immune(Skill::DrainTick);
 
-    let (healing, overhealing) = target.heal(damage);
+    let drain_tick_dmg_result = ResolutionResult::Damage {
-    log.push(format!("{:?} | Drain healing {:?} ({:?} OH)", cryp.name, healing, overhealing));
+        amount,
+        category: Category::SpellDmg,
+        immunity,
+    };
+
+    let drain_tick_heal_result = ResolutionResult::Damage {
+        amount,
+        category: Category::SpellHeal,
+        immunity,
+    };
+
+
+    let mut resolution = Resolution { skill: Skill::DrainTick, results: vec![drain_tick_dmg_result, drain_tick_heal_result] };
+
+    if !immunity.immune {
+        // need to saturate amount and check caster immunity to healing
+        target.deal_spell_dmg(amount);
+        let (healing, overhealing) = cryp.heal(amount);
+    }
+
+    return resolution;
 }
 
-fn shield(_cryp: &mut Cryp, target: &mut Cryp, log: &mut Log) {
+fn shield(cryp: &mut Cryp, target: &mut Cryp, log: &mut Log) -> Resolution {
-    let effect = CrypEffect { effect: Effect::Shield, duration: Skill::Shield.duration(), tick: None };
+    let shield = CrypEffect { effect: Effect::Shield, duration: Skill::Shield.duration(), tick: None };
-    target.effects.push(effect);
+    let immunity = target.immune(Skill::Shield);
-    log.push(format!("{:?} < {:?} for {:?}T", target.name, effect.effect, effect.duration));
+
+    let shield_result = ResolutionResult::Effect {
+        effect: shield.effect,
+        duration: shield.duration,
+        immunity,
+    };
+
+    let mut resolution = Resolution { skill: Skill::Shield, results: vec![shield_result] };
+
+    if !immunity.immune {
+        target.effects.push(shield);
+    }
+
+    log.push(format!("{:?} -> {:?} | {:?} for {:?}T", cryp.name, target.name, shield.effect, shield.duration));
+    return resolution;
 }
 
-fn silence(_cryp: &mut Cryp, target: &mut Cryp, log: &mut Log) {
+fn silence(cryp: &mut Cryp, target: &mut Cryp, log: &mut Log) -> Resolution {
-    let effect = CrypEffect { effect: Effect::Silence, duration: Skill::Silence.duration(), tick: None };
+    let silence = CrypEffect { effect: Effect::Silence, duration: Skill::Silence.duration(), tick: None };
-    target.effects.push(effect);
+    let immunity = target.immune(Skill::Silence);
-    log.push(format!("{:?} < {:?} for {:?}T", target.name, effect.effect, effect.duration));
+
+    let silence_result = ResolutionResult::Effect {
+        effect: silence.effect,
+        duration: silence.duration,
+        immunity,
+    };
+
+    let mut resolution = Resolution { skill: Skill::Silence, results: vec![silence_result] };
+
+    if !immunity.immune {
+        target.effects.push(silence);
+    }
+
+    log.push(format!("{:?} -> {:?} | {:?} for {:?}T", cryp.name, target.name, silence.effect, silence.duration));
+    return resolution;
 }
 
-fn purge(_cryp: &mut Cryp, target: &mut Cryp, log: &mut Log) {
+fn purge(cryp: &mut Cryp, target: &mut Cryp, log: &mut Log) -> Resolution {
-    for (i, ce) in target.effects.clone().iter_mut().enumerate() {
+    let immunity = target.immune(Skill::Purge);
-        if ce.effect.source() == Source::Buff {
+
-            target.effects.remove(i);
+    let mut resolution = Resolution { skill: Skill::Silence, results: vec![] };
-            log.push(format!("{:?} < {:?} purged", target.name, ce.effect));
+
+    if !immunity.immune {
+        for (i, ce) in target.effects.clone().iter_mut().enumerate() {
+            if ce.effect.category() == Category::SpellBuff {
+                target.effects.remove(i);
+                resolution.results.push(ResolutionResult::Removal { effect: ce.effect, immunity });
+                log.push(format!("{:?} < {:?} purged", target.name, ce.effect));
+            }
         }
     }
+
+    return resolution;
 }
 
-fn purify(_cryp: &mut Cryp, target: &mut Cryp, log: &mut Log) {
+fn purify(_cryp: &mut Cryp, target: &mut Cryp, log: &mut Log) -> Resolution {
-    for (i, ce) in target.effects.clone().iter_mut().enumerate() {
+    let immunity = target.immune(Skill::Purify);
-        if ce.effect.source() == Source::Debuff {
+
-            target.effects.remove(i);
+    let mut resolution = Resolution { skill: Skill::Silence, results: vec![] };
-            log.push(format!("{:?} < {:?} purified", target.name, ce.effect));
+
+    if !immunity.immune {
+        for (i, ce) in target.effects.clone().iter_mut().enumerate() {
+            if ce.effect.category() == Category::SpellDebuff {
+                target.effects.remove(i);
+                resolution.results.push(ResolutionResult::Removal { effect: ce.effect, immunity });
+                log.push(format!("{:?} < {:?} purified", target.name, ce.effect));
+            }
         }
     }
+
+    return resolution;
 }
 
-fn banish(_cryp: &mut Cryp, target: &mut Cryp, log: &mut Log) {
+fn banish(cryp: &mut Cryp, target: &mut Cryp, log: &mut Log) -> Resolution {
-    let effect = CrypEffect { effect: Effect::Banish, duration: Skill::Banish.duration(), tick: None };
+    let banish = CrypEffect { effect: Effect::Banish, duration: Skill::Banish.duration(), tick: None };
-    target.effects.push(effect);
+    let immunity = target.immune(Skill::Banish);
-    log.push(format!("{:?} < {:?} for {:?}T", target.name, effect.effect, effect.duration));
+
+    let banish_result = ResolutionResult::Effect {
+        effect: banish.effect,
+        duration: banish.duration,
+        immunity,
+    };
+
+    let mut resolution = Resolution { skill: Skill::Banish, results: vec![banish_result] };
+
+    if !immunity.immune {
+        target.effects.push(banish);
+    }
+
+    log.push(format!("{:?} -> {:?} | {:?} for {:?}T", cryp.name, target.name, banish.effect, banish.duration));
+    return resolution;
 }