From 94f49651db1bca2e00ac22930d59c996266352ff Mon Sep 17 00:00:00 2001 From: ntr Date: Mon, 25 Mar 2019 18:15:34 +1100 Subject: [PATCH] corruption --- server/WORKLOG.md | 1 - server/src/cryp.rs | 2 - server/src/game.rs | 5 +- server/src/skill.rs | 142 +++++++++++++++++++++++++++++++++++++------- server/src/vbox.rs | 7 ++- 5 files changed, 128 insertions(+), 29 deletions(-) diff --git a/server/WORKLOG.md b/server/WORKLOG.md index eef0749f..4289a96e 100644 --- a/server/WORKLOG.md +++ b/server/WORKLOG.md @@ -23,7 +23,6 @@ ensure all skills impl Hatred -> damage received converted into bonus dmg on attack - Skill::Taunt -> redirect incomnig attacks to self Skill::Toxic -> apply debuff to attackers make parry semi-aggressive diff --git a/server/src/cryp.rs b/server/src/cryp.rs index 0dae62e0..43df7cbf 100644 --- a/server/src/cryp.rs +++ b/server/src/cryp.rs @@ -163,7 +163,6 @@ pub struct Cryp { pub specs: Vec, pub colours: Colours, pub name: String, - pub ko_logged: bool, } impl Cryp { @@ -185,7 +184,6 @@ impl Cryp { specs: vec![], colours: Colours::new(), name: String::new(), - ko_logged: false, }; } diff --git a/server/src/game.rs b/server/src/game.rs index bc690b5d..219e6400 100644 --- a/server/src/game.rs +++ b/server/src/game.rs @@ -492,6 +492,9 @@ impl Game { fn log_resolution(&mut self, speed: u64, skill: Skill, resolution: &Resolution) -> &mut Game { let Resolution { source, target, event } = resolution; match event { + Event::Ko => + self.log.push(format!("{:} KO!", target.name)), + Event::Disable { disable } => self.log.push(format!("{:} {:?} {:} disabled {:?}", source.name, skill, target.name, disable)), @@ -501,7 +504,7 @@ impl Game { speed, source.name, skill, target.name, immunity)), Event::TargetKo => - self.log.push(format!("[{:}] {:} {:?} {:} - KO", + self.log.push(format!("[{:}] {:} {:?} {:} - target is KO", speed, source.name, skill, target.name)), Event::Damage { amount, mitigation, category: _ } => diff --git a/server/src/skill.rs b/server/src/skill.rs index 4aa38627..1d94cac7 100644 --- a/server/src/skill.rs +++ b/server/src/skill.rs @@ -82,6 +82,7 @@ pub enum Event { Effect { effect: Effect, duration: u8 }, Removal { effect: Effect }, Evasion { skill: Skill, evasion_rating: u64 }, + Ko, Incomplete, } @@ -127,6 +128,11 @@ pub enum Effect { Amplify, Silence, + // corrupt is the buff that applies + // corruption the dmg debuff + Corrupt, + Corruption, + // magic immunity Shield, @@ -261,6 +267,9 @@ impl Effect { Effect::Amplify => Category::BlueBuff, Effect::Silence => Category::BlueDebuff, + Effect::Corrupt => Category::BlueBuff, + Effect::Corruption => Category::BlueDebuff, + // magic immunity Effect::Shield => Category::BlueBuff, Effect::Invert => Category::GreenBuff, @@ -308,6 +317,9 @@ impl Effect { Effect::Amplify => 2, Effect::Silence => 2, + Effect::Corrupt => 2, + Effect::Corruption => 3, + Effect::Shield => 2, Effect::Triage => 3, @@ -358,7 +370,6 @@ pub enum Skill { Slay, Clutch, Taunt, - Toxic, Invert, Strangle, @@ -390,6 +401,11 @@ pub enum Skill { SiphonTick, Curse, + Corrupt, + Corruption, + CorruptionTick, + + // ----------------- // Purity // ----------------- @@ -453,7 +469,10 @@ impl Skill { Skill::StrangleTick => None, Skill::Clutch => Some(2), Skill::Taunt => Some(1), - Skill::Toxic => Some(1), + + Skill::Corrupt => Some(1), + Skill::Corruption => None, + Skill::CorruptionTick => None, // ----------------- // Test @@ -530,13 +549,15 @@ impl Skill { // WRONG - Skill::Recharge => Category::Blue, - Skill::Reflect => Category::Blue, + Skill::Recharge => Category::Green, + Skill::Reflect => Category::Green, Skill::Ruin => Category::Blue, - Skill::Slay => Category::Blue, + Skill::Slay => Category::Red, Skill::Taunt => Category::Red, - Skill::Toxic => Category::Blue, + Skill::Corrupt => Category::Blue, + Skill::Corruption => Category::Blue, + Skill::CorruptionTick => Category::Blue, // ----------------- // Test @@ -554,6 +575,7 @@ impl Skill { Skill::TriageTick => true, Skill::DecayTick => true, Skill::SiphonTick => true, + Skill::CorruptionTick => true, _ => false, } } @@ -621,20 +643,7 @@ impl Skill { // false => (), // } - // if target.is_ko() && !target.ko_logged { - // self.log.push(format!("{:} KO", target.name)); - // target.effects.clear(); - // target.ko_logged = true; - // } - - // if source.is_ko() && !source.ko_logged { - // self.log.push(format!("{:} KO", source.name)); - // source.effects.clear(); - // source.ko_logged = true; - // } - - - match self { + results = match self { Skill::Amplify => amplify(source, target, results), // increase magic damage Skill::Attack => attack(source, target, results), Skill::Banish => banish(source, target, results), // TODO prevent all actions @@ -671,7 +680,10 @@ impl Skill { Skill::Ruin => ruin(source, target, results), Skill::Slay => unimplemented!(), Skill::Taunt => taunt(source, target, results), - Skill::Toxic => unimplemented!(), + + Skill::Corrupt => corrupt(source, target, results), + Skill::Corruption => panic!("corruption should not be castable"), + Skill::CorruptionTick => corruption_tick(source, target, results), // ----------------- // Test @@ -681,7 +693,29 @@ impl Skill { Skill::TestBlock => block(source, target, results), Skill::TestParry => parry(source, target, results), Skill::TestSiphon => siphon(source, target, results), + }; + + // if any event dealt damage to target cryp + // hit them with corruption + results = match target.affected(Effect::Corrupt) { + true => match results.iter().any(|r| + match r.event { + Event::Damage { amount: _, mitigation: _, category: _ } => true, + _ => false, + }) { + true => corruption(target, source, results), + false => results, + }, + false => results, + }; + + // i don't think we need to check the source being ko + if target.is_ko() { + results.push(Resolution::new(source, target).event(Event::Ko)); + target.effects.clear(); } + + return results; } pub fn self_targeting(&self) -> bool { @@ -689,6 +723,9 @@ impl Skill { Skill::Block => true, Skill::Parry => true, Skill::Clutch => true, + Skill::Taunt => true, + Skill::Corrupt => true, + Skill::TestBlock => true, Skill::TestParry => true, _ => false, @@ -864,6 +901,30 @@ fn decay_tick(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) -> return results; } +// corrupt is the buff effect +// when attacked it runs corruption and applies a debuff +fn corrupt(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) -> Resolutions { + let effect = CrypEffect { effect: Effect::Corrupt, duration: Effect::Corrupt.duration(), tick: None }; + results.push(Resolution::new(source, target).event(target.add_effect(Skill::Corrupt, effect))); + return results;; +} + +fn corruption(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) -> Resolutions { + let effect = CrypEffect { + effect: Effect::Corruption, + duration: Effect::Corruption.duration(), + tick: Some(Cast::new_tick(source, target, Skill::CorruptionTick)), + }; + results.push(Resolution::new(source, target).event(target.add_effect(Skill::Corruption, effect))); + return corruption_tick(source, target, results); +} + +fn corruption_tick(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) -> Resolutions { + let amount = source.blue_damage() / 2; + results.push(Resolution::new(source, target).event(target.deal_blue_damage(Skill::CorruptionTick, amount))); + return results; +} + fn ruin(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions) -> Resolutions { let effect = CrypEffect { effect: Effect::Ruin, duration: Effect::Ruin.duration(), tick: None }; results.push(Resolution::new(source, target).event(target.add_effect(Skill::Ruin, effect))); @@ -1107,6 +1168,43 @@ mod tests { }; } + + #[test] + fn reflect_test() { + let mut x = Cryp::new() + .named(&"muji".to_string()); + + let mut y = Cryp::new() + .named(&"camel".to_string()); + + reflect(&mut y.clone(), &mut y, vec![]); + assert!(y.affected(Effect::Reflect)); + + let mut results = Skill::Attack.resolve(&mut x, &mut y); + + assert!(x.hp() == 768); + + let Resolution { source: _, target: _, event } = results.remove(0); + match event { + Event::Damage { amount, mitigation: _, category: _ } => assert_eq!(amount, 256), + _ => panic!("not damage"), + }; + } #[test] + fn corrupt_test() { + let mut x = Cryp::new() + .named(&"muji".to_string()); + + let mut y = Cryp::new() + .named(&"camel".to_string()); + + corrupt(&mut y.clone(), &mut y, vec![]); + assert!(y.affected(Effect::Corrupt)); + + let _results = Skill::Attack.resolve(&mut x, &mut y); + + assert!(x.affected(Effect::Corruption)); + } + #[test] fn triage_test() { let mut x = Cryp::new() @@ -1249,7 +1347,7 @@ mod tests { // Siphon, // SiphonTick, // Curse, -// Plague, // aoe dot +// Corrupt, // aoe dot // Ruin, // aoe // // ----------------- diff --git a/server/src/vbox.rs b/server/src/vbox.rs index d34d964d..e1a0a23f 100644 --- a/server/src/vbox.rs +++ b/server/src/vbox.rs @@ -89,7 +89,7 @@ pub enum Var { Clutch, Taunt, Throw, - Toxic, + Corrupt, Triage, @@ -206,7 +206,7 @@ impl Var { Var::Clutch => Some(Skill::Clutch), Var::Taunt => Some(Skill::Taunt), Var::Throw => Some(Skill::Throw), - // Var::Toxic => Some(Skill::Toxic), + Var::Corrupt => Some(Skill::Corrupt), Var::Triage => Some(Skill::Triage), _ => None, } @@ -275,6 +275,7 @@ impl From for Var { Skill::Taunt => Var::Taunt, Skill::Throw => Var::Throw, Skill::Triage => Var::Triage, + Skill::Corrupt => Var::Corrupt, Skill::TestTouch => Var::TestTouch, Skill::TestStun => Var::TestStun, @@ -334,7 +335,7 @@ fn get_combos() -> Vec { Combo { units: vec![Var::Block, Var::Red, Var::Red], var: Var::Parry }, Combo { units: vec![Var::Block, Var::Green, Var::Green], var: Var::Reflect }, - Combo { units: vec![Var::Block, Var::Blue, Var::Blue], var: Var::Toxic }, + Combo { units: vec![Var::Block, Var::Blue, Var::Blue], var: Var::Corrupt }, Combo { units: vec![Var::Block, Var::Red, Var::Green], var: Var::Taunt }, Combo { units: vec![Var::Block, Var::Green, Var::Blue], var: Var::Shield }, Combo { units: vec![Var::Block, Var::Red, Var::Blue], var: Var::Recharge },