ntr/mnml
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

resolutions now affected by status effects

Browse Source
This commit is contained in:
ntr 2018-12-04 19:17:43 +11:00
parent aa2ecc4ce6
commit 6ad1ff2d3b
5 changed files with 141 additions and 93 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
client/index.html
View File

@ -1,7 +1,7 @@
<!DOCTYPE html> <!DOCTYPE html>
<html> <html>
<head> <head>
<title>cryps.gg - mnml pvp tbs</title> <title>cryps.gg - mnml pvp atbs</title>
<meta charset="utf-8"> <meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1"> <meta name="viewport" content="width=device-width, initial-scale=1">
<script defer src="https://use.fontawesome.com/releases/v5.1.0/js/all.js"></script> <script defer src="https://use.fontawesome.com/releases/v5.1.0/js/all.js"></script>

2
server/WORKLOG.md
View File

@ -9,6 +9,8 @@
* Global rolls * Global rolls
* notifications
* skills * skills
* check cryp status when resolving skills * check cryp status when resolving skills
* ko / stun / silence etc prevent effect * ko / stun / silence etc prevent effect

23
server/src/cryp.rs
View File

@ -9,7 +9,7 @@ use failure::err_msg;
use account::Account; use account::Account;
use rpc::{CrypSpawnParams, CrypLearnParams, CrypForgetParams}; use rpc::{CrypSpawnParams, CrypLearnParams, CrypForgetParams};
use skill::{Skill, Cooldown, Effect, Cast, Immunity}; use skill::{Skill, Cooldown, Effect, Cast, Immunity, Disable};
use game::{Log}; use game::{Log};
#[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)] #[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
@ -179,7 +179,6 @@ impl Cryp {
} }
pub fn immune(&self, skill: Skill) -> Immunity { pub fn immune(&self, skill: Skill) -> Immunity {
if self.is_ko() { if self.is_ko() {
return Immunity { immune: true, effects: vec![Effect::Ko]}; return Immunity { immune: true, effects: vec![Effect::Ko]};
} }
@ -196,12 +195,30 @@ impl Cryp {
return Immunity { immune: false, effects: vec![]}; return Immunity { immune: false, effects: vec![]};
} }
pub fn disabled(&self, skill: Skill) -> Disable {
if self.is_ko() {
return Disable { disabled: true, effects: vec![Effect::Ko]};
}
let disables = self.effects.iter()
.filter(|e| e.effect.disables_skill(skill))
.map(|e| e.effect)
.collect::<Vec<Effect>>();
if disables.len() > 0 {
return Disable { disabled: true, effects: disables};
}
return Disable { disabled: false, effects: vec![]};
}
pub fn is_stunned(&self) -> bool { pub fn is_stunned(&self) -> bool {
self.effects.iter().any(|s| s.effect == Effect::Stun) self.effects.iter().any(|s| s.effect == Effect::Stun)
} }
pub fn available_skills(&self) -> Vec<&CrypSkill> { pub fn available_skills(&self) -> Vec<&CrypSkill> {
self.skills.iter().filter(|s| !s.skill.disabled(self)).collect() self.skills.iter().filter(|s| !self.disabled(s.skill).disabled).collect()
} }
pub fn knows(&self, skill: Skill) -> bool { pub fn knows(&self, skill: Skill) -> bool {

4
server/src/game.rs
View File

@ -244,7 +244,8 @@ impl Game {
} }
// check here as well so uncastable spells don't go on the stack // check here as well so uncastable spells don't go on the stack
if skill.disabled(&cryp) { let check = cryp.disabled(skill);
if check.disabled {
return Err(err_msg("cryp cannot cast that skill")); return Err(err_msg("cryp cannot cast that skill"));
} }
} }
@ -1010,6 +1011,7 @@ mod tests {
game.resolve_phase_start(); game.resolve_phase_start();
// resolution should have been prevented by KO // resolution should have been prevented by KO
println!("{:#?}", game);
assert!(!game.team_by_id(y_team.id).cryps[0].is_stunned()); assert!(!game.team_by_id(y_team.id).cryps[0].is_stunned());
assert!(game.phase == Phase::Finish); assert!(game.phase == Phase::Finish);
} }

203
server/src/skill.rs
View File

@ -1,7 +1,6 @@
use rand::{thread_rng, Rng}; use rand::{thread_rng, Rng};
use uuid::Uuid; use uuid::Uuid;
use game::{Log};
use cryp::{Cryp, CrypEffect, Stat}; use cryp::{Cryp, CrypEffect, Stat};
#[derive(Debug,Clone,PartialEq,Serialize,Deserialize)] #[derive(Debug,Clone,PartialEq,Serialize,Deserialize)]
@ -30,7 +29,7 @@ impl Cast {
target_cryp_id, target_cryp_id,
target_team_id, target_team_id,
skill, skill,
resolution: Resolution { skill, results: vec![] }, resolution: Resolution::new(skill),
}; };
} }
@ -62,6 +61,24 @@ pub struct Immunity {
pub effects: Vec<Effect> pub effects: Vec<Effect>
} }
impl Immunity {
fn new() -> Immunity {
Immunity { immune: false, effects: vec![] }
}
}
#[derive(Debug,Clone,PartialEq,Serialize,Deserialize)]
pub struct Disable {
pub disabled: bool,
pub effects: Vec<Effect>
}
impl Disable {
fn new() -> Disable {
Disable { disabled: false, effects: vec![] }
}
}
#[derive(Debug,Clone,PartialEq,Serialize,Deserialize)] #[derive(Debug,Clone,PartialEq,Serialize,Deserialize)]
pub enum ResolutionResult { pub enum ResolutionResult {
Damage { amount: u64, category: Category , immunity: Immunity }, Damage { amount: u64, category: Category , immunity: Immunity },
@ -72,9 +89,16 @@ pub enum ResolutionResult {
#[derive(Debug,Clone,PartialEq,Serialize,Deserialize)] #[derive(Debug,Clone,PartialEq,Serialize,Deserialize)]
pub struct Resolution { pub struct Resolution {
pub skill: Skill, pub skill: Skill,
pub disable: Disable,
pub results: Vec<ResolutionResult>, pub results: Vec<ResolutionResult>,
} }
impl Resolution {
fn new(skill: Skill) -> Resolution {
Resolution { skill, results: vec![], disable: Disable::new() }
}
}
pub type Cooldown = Option<u8>; pub type Cooldown = Option<u8>;
#[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)] #[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
@ -570,22 +594,28 @@ impl Skill {
pub fn resolve(&self, cryp: &mut Cryp, target: &mut Cryp) -> Resolution { pub fn resolve(&self, cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
let mut rng = thread_rng(); let mut rng = thread_rng();
let base: u64 = rng.gen(); let _base: u64 = rng.gen();
let resolution = Resolution { skill: *self, results: vec![], disable: cryp.disabled(*self) };
if resolution.disable.disabled {
return resolution;
}
match self { match self {
Skill::Attack => attack(cryp, target), Skill::Attack => attack(cryp, target, resolution),
// ----------------- // -----------------
// Nature // Nature
// ----------------- // -----------------
Skill::Block => block(cryp, target), Skill::Block => block(cryp, target, resolution),
Skill::Evade => panic!("nyi"), // Skill::Evade => panic!("nyi"), //
Skill::Parry => panic!("nyi"), // avoid all dmg Skill::Parry => panic!("nyi"), // avoid all dmg
Skill::Snare => snare(cryp, target), // TODO prevent physical moves Skill::Snare => snare(cryp, target, resolution), // TODO prevent physical moves
Skill::Paralyse => panic!("nyi"), // no physical moves Skill::Paralyse => panic!("nyi"), // no physical moves
Skill::Strangle => panic!("nyi"), // no physical moves Skill::Strangle => panic!("nyi"), // no physical moves
Skill::Stun => stun(cryp, target), Skill::Stun => stun(cryp, target, resolution),
Skill::Evasion => panic!("nyi"), // additional layer of dmg avoidance Skill::Evasion => panic!("nyi"), // additional layer of dmg avoidance
// ----------------- // -----------------
@ -600,10 +630,10 @@ impl Skill {
// ----------------- // -----------------
// Preservation // Preservation
// ----------------- // -----------------
Skill::Heal => heal(cryp, target), Skill::Heal => heal(cryp, target, resolution),
Skill::Triage => triage(cryp, target), // hot Skill::Triage => triage(cryp, target, resolution), // hot
Skill::TriageTick => triage_tick(cryp, target), // hot Skill::TriageTick => triage_tick(cryp, target, resolution), // hot
Skill::Throw => throw(cryp, target), // no dmg stun, adds vulnerable Skill::Throw => throw(cryp, target, resolution), // no dmg stun, adds vulnerable
Skill::Charm => panic!("nyi"), // target casts random spell on teammate Skill::Charm => panic!("nyi"), // target casts random spell on teammate
Skill::Calm => panic!("nyi"), // physical fear, taunt removal Skill::Calm => panic!("nyi"), // physical fear, taunt removal
Skill::Rez => panic!("nyi"), Skill::Rez => panic!("nyi"),
@ -611,13 +641,13 @@ impl Skill {
// ----------------- // -----------------
// Destruction // Destruction
// ----------------- // -----------------
Skill::Blast => blast(cryp, target), Skill::Blast => blast(cryp, target, resolution),
Skill::Amplify => amplify(cryp, target), // increase magic dmg Skill::Amplify => amplify(cryp, target, resolution), // increase magic dmg
Skill::Decay => decay(cryp, target), // dot Skill::Decay => decay(cryp, target, resolution), // dot
Skill::DecayTick => decay_tick(cryp, target), // hot Skill::DecayTick => decay_tick(cryp, target, resolution), // hot
Skill::Drain => drain(cryp, target), Skill::Drain => drain(cryp, target, resolution),
Skill::DrainTick => drain_tick(cryp, target), // hot Skill::DrainTick => drain_tick(cryp, target, resolution), // hot
Skill::Curse => curse(cryp, target), Skill::Curse => curse(cryp, target, resolution),
Skill::Plague => panic!("nyi"), // dot that spreads every turn Skill::Plague => panic!("nyi"), // dot that spreads every turn
Skill::Ruin => panic!("nyi"), // aoe version of blast Skill::Ruin => panic!("nyi"), // aoe version of blast
@ -625,19 +655,19 @@ impl Skill {
// Purity // Purity
// ----------------- // -----------------
// Skill::Precision => panic!("nyi"), // Skill::Precision => panic!("nyi"),
Skill::Empower => empower(cryp, target), // increased phys dmg Skill::Empower => empower(cryp, target, resolution), // increased phys dmg
Skill::Slay => panic!("nyi"), // phys dmg mult by target magic dmg Skill::Slay => panic!("nyi"), // phys dmg mult by target magic dmg
Skill::Shield => shield(cryp, target), // target is immune to magic dmg and fx Skill::Shield => shield(cryp, target, resolution), // target is immune to magic dmg and fx
Skill::Silence => silence(cryp, target), // target cannot cast spells Skill::Silence => silence(cryp, target, resolution), // target cannot cast spells
Skill::Inquiry => panic!("nyi"), // Skill::Inquiry => panic!("nyi"), //
Skill::Purify => purify(cryp, target), // dispel all debuffs Skill::Purify => purify(cryp, target, resolution), // dispel all debuffs
Skill::Purge => purge(cryp, target), // dispel all buffs Skill::Purge => purge(cryp, target, resolution), // dispel all buffs
// ----------------- // -----------------
// Chaos // Chaos
// ----------------- // -----------------
Skill::Banish => banish(cryp, target), // TODO prevent all actions Skill::Banish => banish(cryp, target, resolution), // TODO prevent all actions
Skill::Hex => hex(cryp, target), // todo prevent casting Skill::Hex => hex(cryp, target, resolution), // todo prevent casting
Skill::Fear => panic!("nyi"), // cast random spell on self Skill::Fear => panic!("nyi"), // cast random spell on self
Skill::Taunt => panic!("nyi"), // target forced to attack Skill::Taunt => panic!("nyi"), // target forced to attack
Skill::Pause => panic!("nyi"), // speed slow Skill::Pause => panic!("nyi"), // speed slow
@ -645,10 +675,10 @@ impl Skill {
// ----------------- // -----------------
// Test // Test
// ----------------- // -----------------
Skill::TestTouch => Resolution { skill: Skill::TestTouch, results: vec![] }, Skill::TestTouch => Resolution { skill: Skill::TestTouch, results: vec![], disable: Disable::new() },
Skill::TestStun => stun(cryp, target), Skill::TestStun => stun(cryp, target, resolution),
Skill::TestBlock => block(cryp, target), Skill::TestBlock => block(cryp, target, resolution),
Skill::TestDrain => drain(cryp, target), Skill::TestDrain => drain(cryp, target, resolution),
} }
} }
@ -683,13 +713,9 @@ impl Skill {
_ => false, _ => false,
} }
} }
pub fn disabled(&self, cryp: &Cryp) -> bool {
cryp.effects.iter().any(|e| e.effect.disables_skill(*self))
}
} }
fn attack(cryp: &mut Cryp, target: &mut Cryp) -> Resolution { fn attack(cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution {
let amount = cryp.phys_dmg(); let amount = cryp.phys_dmg();
let immunity = target.immune(Skill::Attack); let immunity = target.immune(Skill::Attack);
let immune = immunity.immune; let immune = immunity.immune;
@ -700,7 +726,7 @@ fn attack(cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
immunity, immunity,
}; };
let resolution = Resolution { skill: Skill::Attack, results: vec![attack_result] }; resolution.results.push(attack_result);
if !immune { if !immune {
target.deal_phys_dmg(amount); target.deal_phys_dmg(amount);
@ -710,7 +736,7 @@ fn attack(cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
return resolution; return resolution;
} }
fn stun(_cryp: &mut Cryp, target: &mut Cryp) -> Resolution { 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: Skill::Stun.duration(), tick: None };
let immunity = target.immune(Skill::Stun); let immunity = target.immune(Skill::Stun);
let immune = immunity.immune; let immune = immunity.immune;
@ -721,7 +747,7 @@ fn stun(_cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
immunity, immunity,
}; };
let resolution = Resolution { skill: Skill::Stun, results: vec![attack_result] }; resolution.results.push(attack_result);
if !immune { if !immune {
target.effects.push(stun); target.effects.push(stun);
@ -730,7 +756,7 @@ fn stun(_cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
return resolution; return resolution;
} }
fn throw(_cryp: &mut Cryp, target: &mut Cryp) -> Resolution { 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: 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 };
let immunity = target.immune(Skill::Throw); let immunity = target.immune(Skill::Throw);
@ -748,7 +774,8 @@ fn throw(_cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
immunity, immunity,
}; };
let resolution = Resolution { skill: Skill::Throw, results: vec![stun_result, vulnerable_result] }; resolution.results.push(stun_result);
resolution.results.push(vulnerable_result);
if !immune { if !immune {
target.effects.push(stun); target.effects.push(stun);
@ -759,7 +786,7 @@ fn throw(_cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
} }
fn block(_cryp: &mut Cryp, target: &mut Cryp) -> Resolution { 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: Skill::Block.duration(), tick: None };
let immunity = target.immune(Skill::Block); let immunity = target.immune(Skill::Block);
let immune = immunity.immune; let immune = immunity.immune;
@ -770,7 +797,7 @@ fn block(_cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
immunity, immunity,
}; };
let resolution = Resolution { skill: Skill::Block, results: vec![block_result] }; resolution.results.push(block_result);
if !immune { if !immune {
target.effects.push(block); target.effects.push(block);
@ -779,7 +806,7 @@ fn block(_cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
return resolution; return resolution;
} }
fn snare(_cryp: &mut Cryp, target: &mut Cryp) -> Resolution { 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: Skill::Snare.duration(), tick: None };
let immunity = target.immune(Skill::Snare); let immunity = target.immune(Skill::Snare);
let immune = immunity.immune; let immune = immunity.immune;
@ -790,7 +817,7 @@ fn snare(_cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
immunity, immunity,
}; };
let resolution = Resolution { skill: Skill::Snare, results: vec![snare_result] }; resolution.results.push(snare_result);
if !immune { if !immune {
target.effects.push(snare); target.effects.push(snare);
@ -799,7 +826,7 @@ fn snare(_cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
return resolution; return resolution;
} }
fn empower(_cryp: &mut Cryp, target: &mut Cryp) -> Resolution { 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: Skill::Empower.duration(), tick: None };
let immunity = target.immune(Skill::Empower); let immunity = target.immune(Skill::Empower);
let immune = immunity.immune; let immune = immunity.immune;
@ -810,7 +837,7 @@ fn empower(_cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
immunity, immunity,
}; };
let resolution = Resolution { skill: Skill::Empower, results: vec![snare_result] }; resolution.results.push(snare_result);
if !immune { if !immune {
target.effects.push(empower); target.effects.push(empower);
@ -820,7 +847,7 @@ fn empower(_cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
} }
// TODO put overhealing back // TODO put overhealing back
fn heal(cryp: &mut Cryp, target: &mut Cryp) -> Resolution { fn heal(cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution {
let amount = cryp.phys_dmg(); let amount = cryp.phys_dmg();
let immunity = target.immune(Skill::Heal); let immunity = target.immune(Skill::Heal);
let immune = immunity.immune; let immune = immunity.immune;
@ -831,7 +858,7 @@ fn heal(cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
immunity, immunity,
}; };
let resolution = Resolution { skill: Skill::Heal, results: vec![heal_result] }; resolution.results.push(heal_result);
if !immune { if !immune {
let (_healing, _overhealing) = target.heal(amount); let (_healing, _overhealing) = target.heal(amount);
@ -842,7 +869,7 @@ fn heal(cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
} }
fn triage(cryp: &mut Cryp, target: &mut Cryp) -> Resolution { fn triage(cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution {
let triage = CrypEffect { let triage = CrypEffect {
effect: Effect::Triage, effect: Effect::Triage,
duration: Skill::Triage.duration(), duration: Skill::Triage.duration(),
@ -857,7 +884,7 @@ fn triage(cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
immunity, immunity,
}; };
let resolution = Resolution { skill: Skill::Triage, results: vec![snare_result] }; resolution.results.push(snare_result);
if !immune { if !immune {
target.effects.push(triage); target.effects.push(triage);
@ -866,7 +893,7 @@ fn triage(cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
return resolution; return resolution;
} }
fn triage_tick(cryp: &mut Cryp, target: &mut Cryp) -> Resolution { fn triage_tick(cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution {
let amount = cryp.spell_dmg().wrapping_div(2); let amount = cryp.spell_dmg().wrapping_div(2);
let immunity = target.immune(Skill::TriageTick); let immunity = target.immune(Skill::TriageTick);
let immune = immunity.immune; let immune = immunity.immune;
@ -877,7 +904,7 @@ fn triage_tick(cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
immunity, immunity,
}; };
let resolution = Resolution { skill: Skill::TriageTick, results: vec![heal_result] }; resolution.results.push(heal_result);
if !immune { if !immune {
let (_healing, _overhealing) = target.heal(amount); let (_healing, _overhealing) = target.heal(amount);
@ -887,7 +914,7 @@ fn triage_tick(cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
return resolution; return resolution;
} }
fn blast(cryp: &mut Cryp, target: &mut Cryp) -> Resolution { fn blast(cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution {
let amount = cryp.spell_dmg(); let amount = cryp.spell_dmg();
let immunity = target.immune(Skill::Blast); let immunity = target.immune(Skill::Blast);
let immune = immunity.immune; let immune = immunity.immune;
@ -898,7 +925,7 @@ fn blast(cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
immunity, immunity,
}; };
let resolution = Resolution { skill: Skill::Blast, results: vec![blast_result] }; resolution.results.push(blast_result);
if !immune { if !immune {
target.deal_spell_dmg(amount); target.deal_spell_dmg(amount);
@ -907,7 +934,7 @@ fn blast(cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
return resolution; return resolution;
} }
fn amplify(_cryp: &mut Cryp, target: &mut Cryp) -> Resolution { 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: Skill::Amplify.duration(), tick: None };
let immunity = target.immune(Skill::Amplify); let immunity = target.immune(Skill::Amplify);
let immune = immunity.immune; let immune = immunity.immune;
@ -918,7 +945,7 @@ fn amplify(_cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
immunity, immunity,
}; };
let resolution = Resolution { skill: Skill::Amplify, results: vec![amplify_result] }; resolution.results.push(amplify_result);
if !immune { if !immune {
target.effects.push(amplify); target.effects.push(amplify);
@ -927,7 +954,7 @@ fn amplify(_cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
return resolution;; return resolution;;
} }
fn decay(cryp: &mut Cryp, target: &mut Cryp) -> Resolution { fn decay(cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution {
let decay = CrypEffect { let decay = CrypEffect {
effect: Effect::Decay, effect: Effect::Decay,
duration: Skill::Decay.duration(), duration: Skill::Decay.duration(),
@ -942,7 +969,7 @@ fn decay(cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
immunity, immunity,
}; };
let resolution = Resolution { skill: Skill::Decay, results: vec![decay_result] }; resolution.results.push(decay_result);
if !immune { if !immune {
target.effects.push(decay); target.effects.push(decay);
@ -951,7 +978,7 @@ fn decay(cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
return resolution; return resolution;
} }
fn decay_tick(cryp: &mut Cryp, target: &mut Cryp) -> Resolution { fn decay_tick(cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution {
let amount = cryp.spell_dmg(); let amount = cryp.spell_dmg();
let immunity = target.immune(Skill::DecayTick); let immunity = target.immune(Skill::DecayTick);
let immune = immunity.immune; let immune = immunity.immune;
@ -962,7 +989,7 @@ fn decay_tick(cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
immunity, immunity,
}; };
let resolution = Resolution { skill: Skill::DecayTick, results: vec![decay_tick_result] }; resolution.results.push(decay_tick_result);
if !immune { if !immune {
target.deal_spell_dmg(amount); target.deal_spell_dmg(amount);
@ -971,7 +998,7 @@ fn decay_tick(cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
return resolution; return resolution;
} }
fn hex(_cryp: &mut Cryp, target: &mut Cryp) -> 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: Skill::Hex.duration(), tick: None };
let immunity = target.immune(Skill::Hex); let immunity = target.immune(Skill::Hex);
let immune = immunity.immune; let immune = immunity.immune;
@ -982,7 +1009,7 @@ fn hex(_cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
immunity, immunity,
}; };
let resolution = Resolution { skill: Skill::Hex, results: vec![hex_result] }; resolution.results.push(hex_result);
if !immune { if !immune {
target.effects.push(hex); target.effects.push(hex);
@ -991,7 +1018,7 @@ fn hex(_cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
return resolution;; return resolution;;
} }
fn curse(_cryp: &mut Cryp, target: &mut Cryp) -> Resolution { 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: Skill::Curse.duration(), tick: None };
let immunity = target.immune(Skill::Curse); let immunity = target.immune(Skill::Curse);
let immune = immunity.immune; let immune = immunity.immune;
@ -1002,7 +1029,7 @@ fn curse(_cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
immunity, immunity,
}; };
let resolution = Resolution { skill: Skill::Curse, results: vec![curse_result] }; resolution.results.push(curse_result);
if !immune { if !immune {
target.effects.push(curse); target.effects.push(curse);
@ -1011,7 +1038,7 @@ fn curse(_cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
return resolution;; return resolution;;
} }
fn drain(cryp: &mut Cryp, target: &mut Cryp) -> Resolution { fn drain(cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution {
let drain = CrypEffect { let drain = CrypEffect {
effect: Effect::Drain, effect: Effect::Drain,
duration: Skill::Drain.duration(), duration: Skill::Drain.duration(),
@ -1026,7 +1053,7 @@ fn drain(cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
immunity, immunity,
}; };
let resolution = Resolution { skill: Skill::Drain, results: vec![drain_result] }; resolution.results.push(drain_result);
if !immune { if !immune {
target.effects.push(drain); target.effects.push(drain);
@ -1036,7 +1063,7 @@ fn drain(cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
} }
// TODO is fukt // TODO is fukt
fn drain_tick(cryp: &mut Cryp, target: &mut Cryp) -> Resolution { fn drain_tick(cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution {
let amount = cryp.spell_dmg().wrapping_div(2); let amount = cryp.spell_dmg().wrapping_div(2);
let immunity = target.immune(Skill::DrainTick); let immunity = target.immune(Skill::DrainTick);
let immune = immunity.immune; let immune = immunity.immune;
@ -1054,7 +1081,8 @@ fn drain_tick(cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
}; };
let resolution = Resolution { skill: Skill::DrainTick, results: vec![drain_tick_dmg_result, drain_tick_heal_result] }; resolution.results.push(drain_tick_dmg_result);
resolution.results.push(drain_tick_heal_result);
if !immune { if !immune {
// need to saturate amount and check caster immunity to healing // need to saturate amount and check caster immunity to healing
@ -1065,7 +1093,7 @@ fn drain_tick(cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
return resolution; return resolution;
} }
fn shield(_cryp: &mut Cryp, target: &mut Cryp) -> 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: Skill::Shield.duration(), tick: None };
let immunity = target.immune(Skill::Shield); let immunity = target.immune(Skill::Shield);
let immune = immunity.immune; let immune = immunity.immune;
@ -1076,7 +1104,7 @@ fn shield(_cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
immunity, immunity,
}; };
let resolution = Resolution { skill: Skill::Shield, results: vec![shield_result] }; resolution.results.push(shield_result);
if !immune { if !immune {
target.effects.push(shield); target.effects.push(shield);
@ -1085,7 +1113,7 @@ fn shield(_cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
return resolution; return resolution;
} }
fn silence(_cryp: &mut Cryp, target: &mut Cryp) -> Resolution { 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: Skill::Silence.duration(), tick: None };
let immunity = target.immune(Skill::Silence); let immunity = target.immune(Skill::Silence);
let immune = immunity.immune; let immune = immunity.immune;
@ -1096,7 +1124,7 @@ fn silence(_cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
immunity, immunity,
}; };
let resolution = Resolution { skill: Skill::Silence, results: vec![silence_result] }; resolution.results.push(silence_result);
if !immune { if !immune {
target.effects.push(silence); target.effects.push(silence);
@ -1105,12 +1133,10 @@ fn silence(_cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
return resolution; return resolution;
} }
fn purge(_cryp: &mut Cryp, target: &mut Cryp) -> Resolution { fn purge(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution {
let immunity = target.immune(Skill::Purge); let immunity = target.immune(Skill::Purge);
let immune = immunity.immune; let immune = immunity.immune;
let mut resolution = Resolution { skill: Skill::Silence, results: vec![] };
if !immune { if !immune {
for (i, ce) in target.effects.clone().iter_mut().enumerate() { for (i, ce) in target.effects.clone().iter_mut().enumerate() {
if ce.effect.category() == Category::SpellBuff { if ce.effect.category() == Category::SpellBuff {
@ -1123,12 +1149,10 @@ fn purge(_cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
return resolution; return resolution;
} }
fn purify(_cryp: &mut Cryp, target: &mut Cryp) -> Resolution { fn purify(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution {
let immunity = target.immune(Skill::Purify); let immunity = target.immune(Skill::Purify);
let immune = immunity.immune; let immune = immunity.immune;
let mut resolution = Resolution { skill: Skill::Silence, results: vec![] };
if !immune { if !immune {
for (i, ce) in target.effects.clone().iter_mut().enumerate() { for (i, ce) in target.effects.clone().iter_mut().enumerate() {
if ce.effect.category() == Category::SpellDebuff { if ce.effect.category() == Category::SpellDebuff {
@ -1141,7 +1165,7 @@ fn purify(_cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
return resolution; return resolution;
} }
fn banish(_cryp: &mut Cryp, target: &mut Cryp) -> Resolution { 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: Skill::Banish.duration(), tick: None };
let immunity = target.immune(Skill::Banish); let immunity = target.immune(Skill::Banish);
let immune = immunity.immune; let immune = immunity.immune;
@ -1152,7 +1176,7 @@ fn banish(_cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
immunity, immunity,
}; };
let resolution = Resolution { skill: Skill::Banish, results: vec![banish_result] }; resolution.results.push(banish_result);
if !immune { if !immune {
target.effects.push(banish); target.effects.push(banish);
@ -1182,7 +1206,7 @@ mod tests {
x.deal_phys_dmg(5); x.deal_phys_dmg(5);
heal(&mut y, &mut x); heal(&mut y, &mut x, Resolution::new(Skill::Heal));
} }
#[test] #[test]
@ -1198,7 +1222,7 @@ mod tests {
.create(); .create();
let mut log = vec![]; let mut log = vec![];
decay(&mut x, &mut y); decay(&mut x, &mut y, Resolution::new(Skill::Triage));
assert!(y.effects.iter().any(|e| e.effect == Effect::Decay)); assert!(y.effects.iter().any(|e| e.effect == Effect::Decay));
@ -1224,11 +1248,14 @@ mod tests {
y.deal_phys_dmg(5); y.deal_phys_dmg(5);
let prev_hp = y.hp(); let prev_hp = y.hp();
triage(&mut x, &mut y); let res = Resolution::new(Skill::Triage);
triage(&mut x, &mut y, res);
assert!(y.effects.iter().any(|e| e.effect == Effect::Triage)); assert!(y.effects.iter().any(|e| e.effect == Effect::Triage));
triage_tick(&mut x, &mut y); let res = Resolution::new(Skill::TriageTick);
triage_tick(&mut x, &mut y, res);
assert!(y.hp() > prev_hp); assert!(y.hp() > prev_hp);
} }
@ -1239,9 +1266,9 @@ mod tests {
.level(8) .level(8)
.create(); .create();
silence(&mut x.clone(), &mut x); silence(&mut x.clone(), &mut x, Resolution::new(Skill::Silence));
assert!(x.effects.iter().any(|e| e.effect == Effect::Silence)); assert!(x.effects.iter().any(|e| e.effect == Effect::Silence));
assert!(Skill::Decay.disabled(&x)); assert!(x.disabled(Skill::Silence).disabled);
} }
#[test] #[test]
@ -1253,7 +1280,7 @@ mod tests {
x.spell_dmg.set(50); x.spell_dmg.set(50);
amplify(&mut x.clone(), &mut x); amplify(&mut x.clone(), &mut x, Resolution::new(Skill::Amplify));
assert!(x.effects.iter().any(|e| e.effect == Effect::Amplify)); assert!(x.effects.iter().any(|e| e.effect == Effect::Amplify));
assert_eq!(x.spell_dmg(), 100); assert_eq!(x.spell_dmg(), 100);
} }
@ -1265,10 +1292,10 @@ mod tests {
.level(8) .level(8)
.create(); .create();
decay(&mut x.clone(), &mut x); decay(&mut x.clone(), &mut x, Resolution::new(Skill::Decay));
assert!(x.effects.iter().any(|e| e.effect == Effect::Decay)); assert!(x.effects.iter().any(|e| e.effect == Effect::Decay));
purify(&mut x.clone(), &mut x); purify(&mut x.clone(), &mut x, Resolution::new(Skill::Purify));
assert!(!x.effects.iter().any(|e| e.effect == Effect::Decay)); assert!(!x.effects.iter().any(|e| e.effect == Effect::Decay));
} }
} }