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

corrupt -> electrify

Browse Source
This commit is contained in:
ntr 2019-07-02 12:23:35 +10:00
parent f1422e5322
commit a0e3ebafbc
10 changed files with 116 additions and 116 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
CHANGELOG.md
View File

@ -212,7 +212,7 @@ New skill `Impurity`
- Changed skill damage multipliers - Changed skill damage multipliers
`Blast` 100% -> 130% `Blast` 100% -> 130%
`CorruptionTick` 100% -> 80% `ElectrocuteTick` 100% -> 80%
`Decay` 50% -> 25% `Decay` 50% -> 25%
`Heal` 100% -> 120% `Heal` 100% -> 120%
`SiphonTick` 100% -> 30% `SiphonTick` 100% -> 30%

2
COMBOS.md
View File

@ -98,7 +98,7 @@ RB - Invert
RR - Parry RR - Parry
GG - Reflect GG - Reflect
BB - Corrupt BB - Electrify
RG - Taunt RG - Taunt
GB - Life `rename?` GB - Life `rename?`
RB - Recharge RB - Recharge

6
client/src/animations.test.jsx
View File

@ -80,9 +80,9 @@ const SKILLS = [
'BlastI', 'BlastI',
'ChaosI', 'ChaosI',
'ClutchI', 'ClutchI',
'CorruptI', 'ElectrifyI',
'CorruptionI', 'ElectrocuteI',
'CorruptionTickI', 'ElectrocuteTickI',
'CurseI', 'CurseI',
'DecayI', 'DecayI',
'DecayTickI', 'DecayTickI',

4
client/src/test.game.js
View File

@ -91,7 +91,7 @@ function testGame(uuid) {
"cd": null "cd": null
}, },
{ {
"skill": "Corrupt", "skill": "Electrify",
"self_targeting": true, "self_targeting": true,
"cd": 1 "cd": 1
} }
@ -239,7 +239,7 @@ function testGame(uuid) {
"cd": null "cd": null
}, },
{ {
"skill": "Corrupt", "skill": "Electrify",
"self_targeting": true, "self_targeting": true,
"cd": 1 "cd": 1
} }

4
client/src/test.instance.js
View File

@ -378,7 +378,7 @@ function testInstance(uuid) {
"cd": null "cd": null
}, },
{ {
"skill": "Corrupt", "skill": "Electrify",
"self_targeting": true, "self_targeting": true,
"cd": 1 "cd": 1
}, },
@ -3352,7 +3352,7 @@ function testInstance(uuid) {
"cd": null "cd": null
}, },
{ {
"skill": "Corrupt", "skill": "Electrify",
"self_targeting": true, "self_targeting": true,
"cd": 1 "cd": 1
}, },

2
client/src/utils.jsx
View File

@ -356,7 +356,7 @@ const removeTier = skill => {
if (skill.includes('Parry')) return 'Parry'; if (skill.includes('Parry')) return 'Parry';
if (skill.includes('Purify')) return 'Purify'; 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('Clutch')) return 'Clutch';
if (skill.includes('Reflect')) return 'Reflect'; if (skill.includes('Reflect')) return 'Reflect';
if (skill.includes('Recharge')) return 'Recharge'; if (skill.includes('Recharge')) return 'Recharge';

12
server/src/effect.rs
View File

@ -27,10 +27,10 @@ pub enum Effect {
Silence, Silence,
Wither, // Reduce green dmg (healing) taken Wither, // Reduce green dmg (healing) taken
// corrupt is the buff that applies // electric is the buff that applies
// corruption the dmg debuff // electrocute the dmg debuff
Corrupt, Electric,
Corruption, Electrocute,
// hostility is the buff // hostility is the buff
// hatred is the increased damage // hatred is the increased damage
@ -187,8 +187,8 @@ impl Effect {
Effect::Wither => Some(Colour::Blue), Effect::Wither => Some(Colour::Blue),
Effect::Purge => Some(Colour::Blue), Effect::Purge => Some(Colour::Blue),
Effect::Corrupt => Some(Colour::Green), Effect::Electric => Some(Colour::Green),
Effect::Corruption => Some(Colour::Blue), Effect::Electrocute => Some(Colour::Blue),
Effect::Hostility => Some(Colour::Green), Effect::Hostility => Some(Colour::Green),

12
server/src/game.rs
View File

@ -1106,7 +1106,7 @@ mod tests {
} }
#[test] #[test]
fn corrupt_test() { fn electrify_test() {
let mut game = create_test_game(); let mut game = create_test_game();
let x_player = game.players[0].clone(); let x_player = game.players[0].clone();
@ -1115,18 +1115,18 @@ mod tests {
let x_construct = x_player.constructs[0].clone(); let x_construct = x_player.constructs[0].clone();
let y_construct = y_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(); game.construct_by_id(x_construct.id).unwrap().reduce_cooldowns();
} }
// apply buff // 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(x_player.id).unwrap();
game.player_ready(y_player.id).unwrap(); game.player_ready(y_player.id).unwrap();
game = game.resolve_phase_start(); 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 // attack and receive debuff
game.add_skill(y_player.id, y_construct.id, Some(x_construct.id), Skill::Attack).unwrap(); 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.player_ready(y_player.id).unwrap();
game = game.resolve_phase_start(); 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] #[test]

50
server/src/item.rs
View File

@ -103,9 +103,9 @@ pub enum Item {
ClutchI, ClutchI,
ClutchII, ClutchII,
ClutchIII, ClutchIII,
CorruptI, ElectrifyI,
CorruptII, ElectrifyII,
CorruptIII, ElectrifyIII,
CurseI, CurseI,
CurseII, CurseII,
CurseIII, CurseIII,
@ -387,9 +387,9 @@ impl Item {
Item::ThrowI => Some(Skill::ThrowI), Item::ThrowI => Some(Skill::ThrowI),
Item::ThrowII => Some(Skill::ThrowII), Item::ThrowII => Some(Skill::ThrowII),
Item::ThrowIII => Some(Skill::ThrowIII), Item::ThrowIII => Some(Skill::ThrowIII),
Item::CorruptI => Some(Skill::CorruptI), Item::ElectrifyI => Some(Skill::ElectrifyI),
Item::CorruptII => Some(Skill::CorruptII), Item::ElectrifyII => Some(Skill::ElectrifyII),
Item::CorruptIII => Some(Skill::CorruptIII), Item::ElectrifyIII => Some(Skill::ElectrifyIII),
Item::TriageI => Some(Skill::TriageI), Item::TriageI => Some(Skill::TriageI),
Item::TriageII => Some(Skill::TriageII), Item::TriageII => Some(Skill::TriageII),
Item::TriageIII => Some(Skill::TriageIII), Item::TriageIII => Some(Skill::TriageIII),
@ -601,10 +601,10 @@ impl Item {
Lasts {:?}T", Lasts {:?}T",
self.into_skill().unwrap().effect()[0].get_duration()), self.into_skill().unwrap().effect()[0].get_duration()),
Item::CorruptI | Item::ElectrifyI |
Item::CorruptII | Item::ElectrifyII |
Item::CorruptIII => format!( Item::ElectrifyIII => format!(
"Self targetting defensive for {:?}T. Applies Corruption to attackers dealing BlueDamage {:?}% \ "Self targetting defensive for {:?}T. Applies Electric to attackers dealing BlueDamage {:?}% \
BluePower per turn for {:?}T.", BluePower per turn for {:?}T.",
self.into_skill().unwrap().effect()[0].get_duration(), self.into_skill().unwrap().effect()[0].get_duration(),
self.into_skill().unwrap().effect()[0].get_skill().unwrap().effect()[0].get_skill().unwrap().multiplier(), 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::PurifyI => vec![Item::Block, Item::Green, Item::Green],
Item::PurifyII => vec![Item::PurifyI, Item::PurifyI, Item::PurifyI], Item::PurifyII => vec![Item::PurifyI, Item::PurifyI, Item::PurifyI],
Item::PurifyIII => vec![Item::PurifyII, Item::PurifyII, Item::PurifyII], Item::PurifyIII => vec![Item::PurifyII, Item::PurifyII, Item::PurifyII],
Item::CorruptI => vec![Item::Block, Item::Blue, Item::Blue], Item::ElectrifyI => vec![Item::Block, Item::Blue, Item::Blue],
Item::CorruptII => vec![Item::CorruptI, Item::CorruptI, Item::CorruptI], Item::ElectrifyII => vec![Item::ElectrifyI, Item::ElectrifyI, Item::ElectrifyI],
Item::CorruptIII => vec![Item::CorruptII, Item::CorruptII, Item::CorruptII], Item::ElectrifyIII => vec![Item::ElectrifyII, Item::ElectrifyII, Item::ElectrifyII],
Item::ClutchI => vec![Item::Block, Item::Red, Item::Green], Item::ClutchI => vec![Item::Block, Item::Red, Item::Green],
Item::ClutchII => vec![Item::ClutchI, Item::ClutchI, Item::ClutchI], Item::ClutchII => vec![Item::ClutchI, Item::ClutchI, Item::ClutchI],
Item::ClutchIII => vec![Item::ClutchII, Item::ClutchII, Item::ClutchII], Item::ClutchIII => vec![Item::ClutchII, Item::ClutchII, Item::ClutchII],
@ -966,9 +966,9 @@ impl From<Skill> for Item {
Skill::ChaosI => Item::ChaosI, Skill::ChaosI => Item::ChaosI,
Skill::ChaosII => Item::ChaosII, Skill::ChaosII => Item::ChaosII,
Skill::ChaosIII => Item::ChaosIII, Skill::ChaosIII => Item::ChaosIII,
Skill::CorruptI => Item::CorruptI, Skill::ElectrifyI => Item::ElectrifyI,
Skill::CorruptII => Item::CorruptII, Skill::ElectrifyII => Item::ElectrifyII,
Skill::CorruptIII => Item::CorruptIII, Skill::ElectrifyIII => Item::ElectrifyIII,
Skill::ClutchI => Item::ClutchI, Skill::ClutchI => Item::ClutchI,
Skill::ClutchII => Item::ClutchII, Skill::ClutchII => Item::ClutchII,
Skill::ClutchIII => Item::ClutchIII, Skill::ClutchIII => Item::ClutchIII,
@ -1051,12 +1051,12 @@ impl From<Skill> for Item {
Skill::TriageIII => Item::TriageIII, Skill::TriageIII => Item::TriageIII,
// Convert subskills into parent skills // Convert subskills into parent skills
Skill::CorruptionI => Item::CorruptI, Skill::ElectrocuteI => Item::ElectrifyI,
Skill::CorruptionII => Item::CorruptII, Skill::ElectrocuteII => Item::ElectrifyII,
Skill::CorruptionIII => Item::CorruptIII, Skill::ElectrocuteIII => Item::ElectrifyIII,
Skill::CorruptionTickI => Item::CorruptI, Skill::ElectrocuteTickI => Item::ElectrifyI,
Skill::CorruptionTickII => Item::CorruptII, Skill::ElectrocuteTickII => Item::ElectrifyII,
Skill::CorruptionTickIII => Item::CorruptII, Skill::ElectrocuteTickIII => Item::ElectrifyII,
Skill::DecayTickI => Item::DecayI, Skill::DecayTickI => Item::DecayI,
Skill::DecayTickII => Item::DecayII, Skill::DecayTickII => Item::DecayII,
Skill::DecayTickIII => Item::DecayIII, Skill::DecayTickIII => Item::DecayIII,
@ -1212,9 +1212,9 @@ pub fn get_combos() -> Vec<Combo> {
Combo { components: Item::PurifyII.combo(), item: Item::PurifyII }, Combo { components: Item::PurifyII.combo(), item: Item::PurifyII },
Combo { components: Item::PurifyIII.combo(), item: Item::PurifyIII }, Combo { components: Item::PurifyIII.combo(), item: Item::PurifyIII },
Combo { components: Item::CorruptI.combo(), item: Item::CorruptI }, Combo { components: Item::ElectrifyI.combo(), item: Item::ElectrifyI },
Combo { components: Item::CorruptII.combo(), item: Item::CorruptII }, Combo { components: Item::ElectrifyII.combo(), item: Item::ElectrifyII },
Combo { components: Item::CorruptIII.combo(), item: Item::CorruptIII }, Combo { components: Item::ElectrifyIII.combo(), item: Item::ElectrifyIII },
Combo { components: Item::ClutchI.combo(), item: Item::ClutchI }, Combo { components: Item::ClutchI.combo(), item: Item::ClutchI },
Combo { components: Item::ClutchII.combo(), item: Item::ClutchII }, Combo { components: Item::ClutchII.combo(), item: Item::ClutchII },

138
server/src/skill.rs
View File

@ -146,12 +146,12 @@ pub fn resolve(skill: Skill, source: &mut Construct, target: &mut Construct, mut
Skill::ClutchII | Skill::ClutchII |
Skill::ClutchIII => clutch(source, target, resolutions, skill), Skill::ClutchIII => clutch(source, target, resolutions, skill),
Skill::CorruptI | Skill::ElectrifyI |
Skill::CorruptII | Skill::ElectrifyII |
Skill::CorruptIII => corrupt(source, target, resolutions, skill), Skill::ElectrifyIII => electrify(source, target, resolutions, skill),
Skill::CorruptionTickI | Skill::ElectrocuteTickI |
Skill::CorruptionTickII | Skill::ElectrocuteTickII |
Skill::CorruptionTickIII => corruption_tick(source, target, resolutions, skill), Skill::ElectrocuteTickIII => electrocute_tick(source, target, resolutions, skill),
Skill::CurseI | Skill::CurseI |
Skill::CurseII | 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), Skill::Stun => stun(source, target, resolutions, skill),
//Triggered //Triggered
Skill::CorruptionI | Skill::ElectrocuteI |
Skill::CorruptionII | Skill::ElectrocuteII |
Skill::CorruptionIII => panic!("should only trigger from corrupt hit"), Skill::ElectrocuteIII => panic!("should only trigger from electrify hit"),
Skill::HasteStrike => panic!("should only trigger from haste"), Skill::HasteStrike => panic!("should only trigger from haste"),
Skill::HatredI | Skill::HatredI |
Skill::HatredII | Skill::HatredII |
@ -293,14 +293,14 @@ fn post_resolve(_skill: Skill, game: &mut Game, mut resolutions: Resolutions) ->
match event { match event {
Event::Damage { amount, skill, mitigation: _, colour: _ } => { 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() 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 { match meta {
Some(EffectMeta::Skill(s)) => { 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, ClutchII,
ClutchIII, ClutchIII,
CorruptI, ElectrifyI,
CorruptII, ElectrifyII,
CorruptIII, ElectrifyIII,
CorruptionI, ElectrocuteI,
CorruptionII, ElectrocuteII,
CorruptionIII, ElectrocuteIII,
CorruptionTickI, ElectrocuteTickI,
CorruptionTickII, ElectrocuteTickII,
CorruptionTickIII, ElectrocuteTickIII,
CurseI, CurseI,
CurseII, CurseII,
@ -665,9 +665,9 @@ impl Skill {
Skill::StrikeIII => 140, Skill::StrikeIII => 140,
// Block Base // Block Base
Skill::CorruptionTickI => 80, Skill::ElectrocuteTickI => 80,
Skill::CorruptionTickII => 100, Skill::ElectrocuteTickII => 100,
Skill::CorruptionTickIII => 130, Skill::ElectrocuteTickIII => 130,
Skill::ParryI => 110, Skill::ParryI => 110,
Skill::ParryII => 145, Skill::ParryII => 145,
@ -743,18 +743,18 @@ impl Skill {
Skill::Buff => vec![ConstructEffect {effect: Effect::Buff, duration: 2, Skill::Buff => vec![ConstructEffect {effect: Effect::Buff, duration: 2,
meta: Some(EffectMeta::Multiplier(125)), tick: None }], meta: Some(EffectMeta::Multiplier(125)), tick: None }],
Skill::CorruptI => vec![ConstructEffect {effect: Effect::Corrupt, duration: 2, Skill::ElectrifyI => vec![ConstructEffect {effect: Effect::Electric, duration: 2,
meta: Some(EffectMeta::Skill(Skill::CorruptionI)), tick: None}], meta: Some(EffectMeta::Skill(Skill::ElectrocuteI)), tick: None}],
Skill::CorruptII => vec![ConstructEffect {effect: Effect::Corrupt, duration: 3, Skill::ElectrifyII => vec![ConstructEffect {effect: Effect::Electric, duration: 3,
meta: Some(EffectMeta::Skill(Skill::CorruptionII)), tick: None}], meta: Some(EffectMeta::Skill(Skill::ElectrocuteII)), tick: None}],
Skill::CorruptIII => vec![ConstructEffect {effect: Effect::Corrupt, duration: 4, Skill::ElectrifyIII => vec![ConstructEffect {effect: Effect::Electric, duration: 4,
meta: Some(EffectMeta::Skill(Skill::CorruptionIII)), tick: None}], meta: Some(EffectMeta::Skill(Skill::ElectrocuteIII)), tick: None}],
Skill::CorruptionI => vec![ConstructEffect {effect: Effect::Corruption, duration: 3, Skill::ElectrocuteI => vec![ConstructEffect {effect: Effect::Electrocute, duration: 3,
meta: Some(EffectMeta::Skill(Skill::CorruptionTickI)), tick: None}], meta: Some(EffectMeta::Skill(Skill::ElectrocuteTickI)), tick: None}],
Skill::CorruptionII => vec![ConstructEffect {effect: Effect::Corruption, duration: 4, Skill::ElectrocuteII => vec![ConstructEffect {effect: Effect::Electrocute, duration: 4,
meta: Some(EffectMeta::Skill(Skill::CorruptionTickII)), tick: None}], meta: Some(EffectMeta::Skill(Skill::ElectrocuteTickII)), tick: None}],
Skill::CorruptionIII => vec![ConstructEffect {effect: Effect::Corruption, duration: 5, Skill::ElectrocuteIII => vec![ConstructEffect {effect: Effect::Electrocute, duration: 5,
meta: Some(EffectMeta::Skill(Skill::CorruptionTickIII)), tick: None}], meta: Some(EffectMeta::Skill(Skill::ElectrocuteTickIII)), tick: None}],
Skill::ClutchI => vec![ConstructEffect {effect: Effect::Clutch, duration: 1, meta: None, 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 }], Skill::ClutchII => vec![ConstructEffect {effect: Effect::Clutch, duration: 2, meta: None, tick: None }],
@ -1005,9 +1005,9 @@ impl Skill {
Skill::TauntII => Some(2), Skill::TauntII => Some(2),
Skill::TauntIII => Some(2), Skill::TauntIII => Some(2),
Skill::CorruptI =>Some(1), Skill::ElectrifyI =>Some(1),
Skill::CorruptII =>Some(1), Skill::ElectrifyII =>Some(1),
Skill::CorruptIII =>Some(1), Skill::ElectrifyIII =>Some(1),
Skill::HostilityI | Skill::HostilityI |
@ -1023,16 +1023,16 @@ impl Skill {
Skill::RiposteI | Skill::RiposteI |
Skill::RiposteII | Skill::RiposteII |
Skill::RiposteIII | // parry Skill::RiposteIII | // parry
Skill::CorruptionI | Skill::ElectrocuteI |
Skill::CorruptionII | Skill::ElectrocuteII |
Skill::CorruptionIII | Skill::ElectrocuteIII |
Skill::HatredI | Skill::HatredI |
Skill::HatredII | Skill::HatredII |
Skill::HatredIII | Skill::HatredIII |
// Ticks // Ticks
Skill::CorruptionTickI | Skill::ElectrocuteTickI |
Skill::CorruptionTickII | Skill::ElectrocuteTickII |
Skill::CorruptionTickIII | Skill::ElectrocuteTickIII |
Skill::DecayTickI | Skill::DecayTickI |
Skill::DecayTickII | Skill::DecayTickII |
Skill::DecayTickIII | Skill::DecayTickIII |
@ -1047,9 +1047,9 @@ impl Skill {
pub fn ko_castable(&self) -> bool { pub fn ko_castable(&self) -> bool {
match self { match self {
Skill::CorruptionTickI | Skill::ElectrocuteTickI |
Skill::CorruptionTickII | Skill::ElectrocuteTickII |
Skill::CorruptionTickIII | Skill::ElectrocuteTickIII |
Skill::DecayTickI | Skill::DecayTickI |
Skill::DecayTickII | Skill::DecayTickII |
Skill::DecayTickIII | Skill::DecayTickIII |
@ -1066,9 +1066,9 @@ impl Skill {
pub fn is_tick(&self) -> bool { pub fn is_tick(&self) -> bool {
match self { match self {
Skill::CorruptionTickI | Skill::ElectrocuteTickI |
Skill::CorruptionTickII | Skill::ElectrocuteTickII |
Skill::CorruptionTickIII | Skill::ElectrocuteTickIII |
Skill::DecayTickI | Skill::DecayTickI |
Skill::DecayTickII | Skill::DecayTickII |
Skill::DecayTickIII | Skill::DecayTickIII |
@ -1102,9 +1102,9 @@ impl Skill {
Skill::TriageTickII | Skill::TriageTickII |
Skill::TriageTickIII => Skill::TriageI.speed(), Skill::TriageTickIII => Skill::TriageI.speed(),
Skill::CorruptionTickI | Skill::ElectrocuteTickI |
Skill::CorruptionTickII | Skill::ElectrocuteTickII |
Skill::CorruptionTickIII => Skill::CorruptI.speed(), Skill::ElectrocuteTickIII => Skill::ElectrifyI.speed(),
_ => Item::from(*self).speed(), _ => Item::from(*self).speed(),
} }
@ -1144,9 +1144,9 @@ impl Skill {
Skill::ClutchI | Skill::ClutchI |
Skill::ClutchII | Skill::ClutchII |
Skill::ClutchIII | Skill::ClutchIII |
Skill::CorruptI | Skill::ElectrifyI |
Skill::CorruptII | Skill::ElectrifyII |
Skill::CorruptIII | Skill::ElectrifyIII |
Skill::HasteI | Skill::HasteI |
Skill::HasteII | Skill::HasteII |
Skill::HasteIII | Skill::HasteIII |
@ -1471,29 +1471,29 @@ fn decay_tick(source: &mut Construct, target: &mut Construct, mut results: Resol
return results; return results;
} }
// corrupt is the buff effect // electrify is the buff effect
// when attacked it runs corruption and applies a debuff // when attacked it runs electrocute and applies a debuff
fn corrupt(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions { fn electrify(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions {
let corrupt = skill.effect()[0]; let electrify = skill.effect()[0];
results.push(Resolution::new(source, target).event(target.add_effect(skill, corrupt))); results.push(Resolution::new(source, target).event(target.add_effect(skill, electrify)));
return results;; 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 ConstructEffect { effect, duration, meta, tick: _ } = skill.effect()[0];
let tick_skill = match meta { let tick_skill = match meta {
Some(EffectMeta::Skill(s)) => s, 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) results.push(Resolution::new(source, target)
.event(target.add_effect(skill, corruption)) .event(target.add_effect(skill, electrocute))
.stages(LogStages::StartPost)); .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()); let amount = source.blue_power().pct(skill.multiplier());
target.deal_blue_damage(skill, amount) target.deal_blue_damage(skill, amount)
.into_iter() .into_iter()