diff --git a/CHANGELOG.md b/CHANGELOG.md index 5da7a676..df8ad514 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -212,7 +212,7 @@ New skill `Impurity` - Changed skill damage multipliers `Blast` 100% -> 130% - `CorruptionTick` 100% -> 80% + `ElectrocuteTick` 100% -> 80% `Decay` 50% -> 25% `Heal` 100% -> 120% `SiphonTick` 100% -> 30% diff --git a/COMBOS.md b/COMBOS.md index d41124fc..20ccdddf 100644 --- a/COMBOS.md +++ b/COMBOS.md @@ -98,7 +98,7 @@ RB - Invert RR - Parry GG - Reflect -BB - Corrupt +BB - Electrify RG - Taunt GB - Life `rename?` RB - Recharge diff --git a/client/src/animations.test.jsx b/client/src/animations.test.jsx index fc207e40..0bf86348 100644 --- a/client/src/animations.test.jsx +++ b/client/src/animations.test.jsx @@ -80,9 +80,9 @@ const SKILLS = [ 'BlastI', 'ChaosI', 'ClutchI', - 'CorruptI', - 'CorruptionI', - 'CorruptionTickI', + 'ElectrifyI', + 'ElectrocuteI', + 'ElectrocuteTickI', 'CurseI', 'DecayI', 'DecayTickI', diff --git a/client/src/test.game.js b/client/src/test.game.js index 9c919647..c36174ed 100644 --- a/client/src/test.game.js +++ b/client/src/test.game.js @@ -91,7 +91,7 @@ function testGame(uuid) { "cd": null }, { - "skill": "Corrupt", + "skill": "Electrify", "self_targeting": true, "cd": 1 } @@ -239,7 +239,7 @@ function testGame(uuid) { "cd": null }, { - "skill": "Corrupt", + "skill": "Electrify", "self_targeting": true, "cd": 1 } diff --git a/client/src/test.instance.js b/client/src/test.instance.js index 3c857ed9..6562ea17 100644 --- a/client/src/test.instance.js +++ b/client/src/test.instance.js @@ -378,7 +378,7 @@ function testInstance(uuid) { "cd": null }, { - "skill": "Corrupt", + "skill": "Electrify", "self_targeting": true, "cd": 1 }, @@ -3352,7 +3352,7 @@ function testInstance(uuid) { "cd": null }, { - "skill": "Corrupt", + "skill": "Electrify", "self_targeting": true, "cd": 1 }, diff --git a/client/src/utils.jsx b/client/src/utils.jsx index e7c0640f..e85c901c 100644 --- a/client/src/utils.jsx +++ b/client/src/utils.jsx @@ -356,7 +356,7 @@ const removeTier = skill => { if (skill.includes('Parry')) return 'Parry'; if (skill.includes('Purify')) return 'Purify'; - if (skill.includes('Corrupt')) return 'Corrupt'; + if (skill.includes('Electrify')) return 'Electrify'; if (skill.includes('Clutch')) return 'Clutch'; if (skill.includes('Reflect')) return 'Reflect'; if (skill.includes('Recharge')) return 'Recharge'; diff --git a/server/src/effect.rs b/server/src/effect.rs index ed6e4938..25636d7a 100644 --- a/server/src/effect.rs +++ b/server/src/effect.rs @@ -27,10 +27,10 @@ pub enum Effect { Silence, Wither, // Reduce green dmg (healing) taken - // corrupt is the buff that applies - // corruption the dmg debuff - Corrupt, - Corruption, + // electric is the buff that applies + // electrocute the dmg debuff + Electric, + Electrocute, // hostility is the buff // hatred is the increased damage @@ -187,8 +187,8 @@ impl Effect { Effect::Wither => Some(Colour::Blue), Effect::Purge => Some(Colour::Blue), - Effect::Corrupt => Some(Colour::Green), - Effect::Corruption => Some(Colour::Blue), + Effect::Electric => Some(Colour::Green), + Effect::Electrocute => Some(Colour::Blue), Effect::Hostility => Some(Colour::Green), diff --git a/server/src/game.rs b/server/src/game.rs index 523cc299..13956f07 100644 --- a/server/src/game.rs +++ b/server/src/game.rs @@ -1106,7 +1106,7 @@ mod tests { } #[test] - fn corrupt_test() { + fn electrify_test() { let mut game = create_test_game(); let x_player = game.players[0].clone(); @@ -1115,18 +1115,18 @@ mod tests { let x_construct = x_player.constructs[0].clone(); let y_construct = y_player.constructs[0].clone(); - game.construct_by_id(x_construct.id).unwrap().learn_mut(Skill::CorruptI); + game.construct_by_id(x_construct.id).unwrap().learn_mut(Skill::ElectrifyI); - while game.construct_by_id(x_construct.id).unwrap().skill_on_cd(Skill::CorruptI).is_some() { + while game.construct_by_id(x_construct.id).unwrap().skill_on_cd(Skill::ElectrifyI).is_some() { game.construct_by_id(x_construct.id).unwrap().reduce_cooldowns(); } // apply buff - game.add_skill(x_player.id, x_construct.id, Some(x_construct.id), Skill::CorruptI).unwrap(); + game.add_skill(x_player.id, x_construct.id, Some(x_construct.id), Skill::ElectrifyI).unwrap(); game.player_ready(x_player.id).unwrap(); game.player_ready(y_player.id).unwrap(); game = game.resolve_phase_start(); - assert!(game.construct_by_id(x_construct.id).unwrap().affected(Effect::Corrupt)); + assert!(game.construct_by_id(x_construct.id).unwrap().affected(Effect::Electric)); // attack and receive debuff game.add_skill(y_player.id, y_construct.id, Some(x_construct.id), Skill::Attack).unwrap(); @@ -1134,7 +1134,7 @@ mod tests { game.player_ready(y_player.id).unwrap(); game = game.resolve_phase_start(); - assert!(game.construct_by_id(y_construct.id).unwrap().affected(Effect::Corruption)); + assert!(game.construct_by_id(y_construct.id).unwrap().affected(Effect::Electrocute)); } #[test] diff --git a/server/src/item.rs b/server/src/item.rs index 8b9766c1..a25b785a 100644 --- a/server/src/item.rs +++ b/server/src/item.rs @@ -103,9 +103,9 @@ pub enum Item { ClutchI, ClutchII, ClutchIII, - CorruptI, - CorruptII, - CorruptIII, + ElectrifyI, + ElectrifyII, + ElectrifyIII, CurseI, CurseII, CurseIII, @@ -387,9 +387,9 @@ impl Item { Item::ThrowI => Some(Skill::ThrowI), Item::ThrowII => Some(Skill::ThrowII), Item::ThrowIII => Some(Skill::ThrowIII), - Item::CorruptI => Some(Skill::CorruptI), - Item::CorruptII => Some(Skill::CorruptII), - Item::CorruptIII => Some(Skill::CorruptIII), + Item::ElectrifyI => Some(Skill::ElectrifyI), + Item::ElectrifyII => Some(Skill::ElectrifyII), + Item::ElectrifyIII => Some(Skill::ElectrifyIII), Item::TriageI => Some(Skill::TriageI), Item::TriageII => Some(Skill::TriageII), Item::TriageIII => Some(Skill::TriageIII), @@ -601,10 +601,10 @@ impl Item { Lasts {:?}T", self.into_skill().unwrap().effect()[0].get_duration()), - Item::CorruptI | - Item::CorruptII | - Item::CorruptIII => format!( - "Self targetting defensive for {:?}T. Applies Corruption to attackers dealing BlueDamage {:?}% \ + Item::ElectrifyI | + Item::ElectrifyII | + Item::ElectrifyIII => format!( + "Self targetting defensive for {:?}T. Applies Electric to attackers dealing BlueDamage {:?}% \ BluePower per turn for {:?}T.", self.into_skill().unwrap().effect()[0].get_duration(), self.into_skill().unwrap().effect()[0].get_skill().unwrap().effect()[0].get_skill().unwrap().multiplier(), @@ -831,9 +831,9 @@ impl Item { Item::PurifyI => vec![Item::Block, Item::Green, Item::Green], Item::PurifyII => vec![Item::PurifyI, Item::PurifyI, Item::PurifyI], Item::PurifyIII => vec![Item::PurifyII, Item::PurifyII, Item::PurifyII], - Item::CorruptI => vec![Item::Block, Item::Blue, Item::Blue], - Item::CorruptII => vec![Item::CorruptI, Item::CorruptI, Item::CorruptI], - Item::CorruptIII => vec![Item::CorruptII, Item::CorruptII, Item::CorruptII], + Item::ElectrifyI => vec![Item::Block, Item::Blue, Item::Blue], + Item::ElectrifyII => vec![Item::ElectrifyI, Item::ElectrifyI, Item::ElectrifyI], + Item::ElectrifyIII => vec![Item::ElectrifyII, Item::ElectrifyII, Item::ElectrifyII], Item::ClutchI => vec![Item::Block, Item::Red, Item::Green], Item::ClutchII => vec![Item::ClutchI, Item::ClutchI, Item::ClutchI], Item::ClutchIII => vec![Item::ClutchII, Item::ClutchII, Item::ClutchII], @@ -966,9 +966,9 @@ impl From for Item { Skill::ChaosI => Item::ChaosI, Skill::ChaosII => Item::ChaosII, Skill::ChaosIII => Item::ChaosIII, - Skill::CorruptI => Item::CorruptI, - Skill::CorruptII => Item::CorruptII, - Skill::CorruptIII => Item::CorruptIII, + Skill::ElectrifyI => Item::ElectrifyI, + Skill::ElectrifyII => Item::ElectrifyII, + Skill::ElectrifyIII => Item::ElectrifyIII, Skill::ClutchI => Item::ClutchI, Skill::ClutchII => Item::ClutchII, Skill::ClutchIII => Item::ClutchIII, @@ -1051,12 +1051,12 @@ impl From for Item { Skill::TriageIII => Item::TriageIII, // Convert subskills into parent skills - Skill::CorruptionI => Item::CorruptI, - Skill::CorruptionII => Item::CorruptII, - Skill::CorruptionIII => Item::CorruptIII, - Skill::CorruptionTickI => Item::CorruptI, - Skill::CorruptionTickII => Item::CorruptII, - Skill::CorruptionTickIII => Item::CorruptII, + Skill::ElectrocuteI => Item::ElectrifyI, + Skill::ElectrocuteII => Item::ElectrifyII, + Skill::ElectrocuteIII => Item::ElectrifyIII, + Skill::ElectrocuteTickI => Item::ElectrifyI, + Skill::ElectrocuteTickII => Item::ElectrifyII, + Skill::ElectrocuteTickIII => Item::ElectrifyII, Skill::DecayTickI => Item::DecayI, Skill::DecayTickII => Item::DecayII, Skill::DecayTickIII => Item::DecayIII, @@ -1212,9 +1212,9 @@ pub fn get_combos() -> Vec { Combo { components: Item::PurifyII.combo(), item: Item::PurifyII }, Combo { components: Item::PurifyIII.combo(), item: Item::PurifyIII }, - Combo { components: Item::CorruptI.combo(), item: Item::CorruptI }, - Combo { components: Item::CorruptII.combo(), item: Item::CorruptII }, - Combo { components: Item::CorruptIII.combo(), item: Item::CorruptIII }, + Combo { components: Item::ElectrifyI.combo(), item: Item::ElectrifyI }, + Combo { components: Item::ElectrifyII.combo(), item: Item::ElectrifyII }, + Combo { components: Item::ElectrifyIII.combo(), item: Item::ElectrifyIII }, Combo { components: Item::ClutchI.combo(), item: Item::ClutchI }, Combo { components: Item::ClutchII.combo(), item: Item::ClutchII }, diff --git a/server/src/skill.rs b/server/src/skill.rs index c16c944d..eaf4138c 100644 --- a/server/src/skill.rs +++ b/server/src/skill.rs @@ -146,12 +146,12 @@ pub fn resolve(skill: Skill, source: &mut Construct, target: &mut Construct, mut Skill::ClutchII | Skill::ClutchIII => clutch(source, target, resolutions, skill), - Skill::CorruptI | - Skill::CorruptII | - Skill::CorruptIII => corrupt(source, target, resolutions, skill), - Skill::CorruptionTickI | - Skill::CorruptionTickII | - Skill::CorruptionTickIII => corruption_tick(source, target, resolutions, skill), + Skill::ElectrifyI | + Skill::ElectrifyII | + Skill::ElectrifyIII => electrify(source, target, resolutions, skill), + Skill::ElectrocuteTickI | + Skill::ElectrocuteTickII | + Skill::ElectrocuteTickIII => electrocute_tick(source, target, resolutions, skill), Skill::CurseI | Skill::CurseII | @@ -267,9 +267,9 @@ pub fn resolve(skill: Skill, source: &mut Construct, target: &mut Construct, mut Skill::Stun => stun(source, target, resolutions, skill), //Triggered - Skill::CorruptionI | - Skill::CorruptionII | - Skill::CorruptionIII => panic!("should only trigger from corrupt hit"), + Skill::ElectrocuteI | + Skill::ElectrocuteII | + Skill::ElectrocuteIII => panic!("should only trigger from electrify hit"), Skill::HasteStrike => panic!("should only trigger from haste"), Skill::HatredI | Skill::HatredII | @@ -293,14 +293,14 @@ fn post_resolve(_skill: Skill, game: &mut Game, mut resolutions: Resolutions) -> match event { Event::Damage { amount, skill, mitigation: _, colour: _ } => { - if target.affected(Effect::Corrupt) { + if target.affected(Effect::Electric) { let ConstructEffect { effect: _, duration: _, meta, tick: _ } = target.effects.iter() - .find(|e| e.effect == Effect::Corrupt).unwrap().clone(); + .find(|e| e.effect == Effect::Electric).unwrap().clone(); match meta { Some(EffectMeta::Skill(s)) => { - resolutions = corruption(&mut target, &mut source, resolutions, s); + resolutions = electrocute(&mut target, &mut source, resolutions, s); }, - _ => panic!("no corrupt skill"), + _ => panic!("no electrify skill"), }; } @@ -510,15 +510,15 @@ pub enum Skill { ClutchII, ClutchIII, - CorruptI, - CorruptII, - CorruptIII, - CorruptionI, - CorruptionII, - CorruptionIII, - CorruptionTickI, - CorruptionTickII, - CorruptionTickIII, + ElectrifyI, + ElectrifyII, + ElectrifyIII, + ElectrocuteI, + ElectrocuteII, + ElectrocuteIII, + ElectrocuteTickI, + ElectrocuteTickII, + ElectrocuteTickIII, CurseI, CurseII, @@ -665,9 +665,9 @@ impl Skill { Skill::StrikeIII => 140, // Block Base - Skill::CorruptionTickI => 80, - Skill::CorruptionTickII => 100, - Skill::CorruptionTickIII => 130, + Skill::ElectrocuteTickI => 80, + Skill::ElectrocuteTickII => 100, + Skill::ElectrocuteTickIII => 130, Skill::ParryI => 110, Skill::ParryII => 145, @@ -743,18 +743,18 @@ impl Skill { Skill::Buff => vec![ConstructEffect {effect: Effect::Buff, duration: 2, meta: Some(EffectMeta::Multiplier(125)), tick: None }], - Skill::CorruptI => vec![ConstructEffect {effect: Effect::Corrupt, duration: 2, - meta: Some(EffectMeta::Skill(Skill::CorruptionI)), tick: None}], - Skill::CorruptII => vec![ConstructEffect {effect: Effect::Corrupt, duration: 3, - meta: Some(EffectMeta::Skill(Skill::CorruptionII)), tick: None}], - Skill::CorruptIII => vec![ConstructEffect {effect: Effect::Corrupt, duration: 4, - meta: Some(EffectMeta::Skill(Skill::CorruptionIII)), tick: None}], - Skill::CorruptionI => vec![ConstructEffect {effect: Effect::Corruption, duration: 3, - meta: Some(EffectMeta::Skill(Skill::CorruptionTickI)), tick: None}], - Skill::CorruptionII => vec![ConstructEffect {effect: Effect::Corruption, duration: 4, - meta: Some(EffectMeta::Skill(Skill::CorruptionTickII)), tick: None}], - Skill::CorruptionIII => vec![ConstructEffect {effect: Effect::Corruption, duration: 5, - meta: Some(EffectMeta::Skill(Skill::CorruptionTickIII)), tick: None}], + Skill::ElectrifyI => vec![ConstructEffect {effect: Effect::Electric, duration: 2, + meta: Some(EffectMeta::Skill(Skill::ElectrocuteI)), tick: None}], + Skill::ElectrifyII => vec![ConstructEffect {effect: Effect::Electric, duration: 3, + meta: Some(EffectMeta::Skill(Skill::ElectrocuteII)), tick: None}], + Skill::ElectrifyIII => vec![ConstructEffect {effect: Effect::Electric, duration: 4, + meta: Some(EffectMeta::Skill(Skill::ElectrocuteIII)), tick: None}], + Skill::ElectrocuteI => vec![ConstructEffect {effect: Effect::Electrocute, duration: 3, + meta: Some(EffectMeta::Skill(Skill::ElectrocuteTickI)), tick: None}], + Skill::ElectrocuteII => vec![ConstructEffect {effect: Effect::Electrocute, duration: 4, + meta: Some(EffectMeta::Skill(Skill::ElectrocuteTickII)), tick: None}], + Skill::ElectrocuteIII => vec![ConstructEffect {effect: Effect::Electrocute, duration: 5, + meta: Some(EffectMeta::Skill(Skill::ElectrocuteTickIII)), tick: None}], Skill::ClutchI => vec![ConstructEffect {effect: Effect::Clutch, duration: 1, meta: None, tick: None }], Skill::ClutchII => vec![ConstructEffect {effect: Effect::Clutch, duration: 2, meta: None, tick: None }], @@ -1005,9 +1005,9 @@ impl Skill { Skill::TauntII => Some(2), Skill::TauntIII => Some(2), - Skill::CorruptI =>Some(1), - Skill::CorruptII =>Some(1), - Skill::CorruptIII =>Some(1), + Skill::ElectrifyI =>Some(1), + Skill::ElectrifyII =>Some(1), + Skill::ElectrifyIII =>Some(1), Skill::HostilityI | @@ -1023,16 +1023,16 @@ impl Skill { Skill::RiposteI | Skill::RiposteII | Skill::RiposteIII | // parry - Skill::CorruptionI | - Skill::CorruptionII | - Skill::CorruptionIII | + Skill::ElectrocuteI | + Skill::ElectrocuteII | + Skill::ElectrocuteIII | Skill::HatredI | Skill::HatredII | Skill::HatredIII | // Ticks - Skill::CorruptionTickI | - Skill::CorruptionTickII | - Skill::CorruptionTickIII | + Skill::ElectrocuteTickI | + Skill::ElectrocuteTickII | + Skill::ElectrocuteTickIII | Skill::DecayTickI | Skill::DecayTickII | Skill::DecayTickIII | @@ -1047,9 +1047,9 @@ impl Skill { pub fn ko_castable(&self) -> bool { match self { - Skill::CorruptionTickI | - Skill::CorruptionTickII | - Skill::CorruptionTickIII | + Skill::ElectrocuteTickI | + Skill::ElectrocuteTickII | + Skill::ElectrocuteTickIII | Skill::DecayTickI | Skill::DecayTickII | Skill::DecayTickIII | @@ -1066,9 +1066,9 @@ impl Skill { pub fn is_tick(&self) -> bool { match self { - Skill::CorruptionTickI | - Skill::CorruptionTickII | - Skill::CorruptionTickIII | + Skill::ElectrocuteTickI | + Skill::ElectrocuteTickII | + Skill::ElectrocuteTickIII | Skill::DecayTickI | Skill::DecayTickII | Skill::DecayTickIII | @@ -1102,9 +1102,9 @@ impl Skill { Skill::TriageTickII | Skill::TriageTickIII => Skill::TriageI.speed(), - Skill::CorruptionTickI | - Skill::CorruptionTickII | - Skill::CorruptionTickIII => Skill::CorruptI.speed(), + Skill::ElectrocuteTickI | + Skill::ElectrocuteTickII | + Skill::ElectrocuteTickIII => Skill::ElectrifyI.speed(), _ => Item::from(*self).speed(), } @@ -1144,9 +1144,9 @@ impl Skill { Skill::ClutchI | Skill::ClutchII | Skill::ClutchIII | - Skill::CorruptI | - Skill::CorruptII | - Skill::CorruptIII | + Skill::ElectrifyI | + Skill::ElectrifyII | + Skill::ElectrifyIII | Skill::HasteI | Skill::HasteII | Skill::HasteIII | @@ -1471,29 +1471,29 @@ fn decay_tick(source: &mut Construct, target: &mut Construct, mut results: Resol return results; } -// corrupt is the buff effect -// when attacked it runs corruption and applies a debuff -fn corrupt(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions { - let corrupt = skill.effect()[0]; - results.push(Resolution::new(source, target).event(target.add_effect(skill, corrupt))); +// electrify is the buff effect +// when attacked it runs electrocute and applies a debuff +fn electrify(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions { + let electrify = skill.effect()[0]; + results.push(Resolution::new(source, target).event(target.add_effect(skill, electrify))); return results;; } -fn corruption(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions { +fn electrocute(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions { let ConstructEffect { effect, duration, meta, tick: _ } = skill.effect()[0]; let tick_skill = match meta { Some(EffectMeta::Skill(s)) => s, - _ => panic!("no corruption tick skill"), + _ => panic!("no electrocute tick skill"), }; - let corruption = ConstructEffect::new(effect, duration).set_tick(Cast::new_tick(source, target, tick_skill)); + let electrocute = ConstructEffect::new(effect, duration).set_tick(Cast::new_tick(source, target, tick_skill)); results.push(Resolution::new(source, target) - .event(target.add_effect(skill, corruption)) + .event(target.add_effect(skill, electrocute)) .stages(LogStages::StartPost)); - return corruption_tick(source, target, results, tick_skill); + return electrocute_tick(source, target, results, tick_skill); } -fn corruption_tick(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions { +fn electrocute_tick(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions { let amount = source.blue_power().pct(skill.multiplier()); target.deal_blue_damage(skill, amount) .into_iter()