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
`Blast` 100% -> 130%
`CorruptionTick` 100% -> 80%
`ElectrocuteTick` 100% -> 80%
`Decay` 50% -> 25%
`Heal` 100% -> 120%
`SiphonTick` 100% -> 30%

2
COMBOS.md
View File

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

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

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

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

@ -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
}

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

@ -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
},

2
client/src/utils.jsx
View File

@ -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';

12
server/src/effect.rs
View File

@ -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),

12
server/src/game.rs
View File

@ -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]

50
server/src/item.rs
View File

@ -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<Skill> 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<Skill> 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> {
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 },

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::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()