From 6057d267744a5e9322b93155918293f04db4eecb Mon Sep 17 00:00:00 2001 From: ntr Date: Tue, 28 May 2019 12:27:46 +1000 Subject: [PATCH] merge stash --- server/src/item.rs | 33 +- server/src/skill.rs | 1242 +++++++++++-------------------------------- 2 files changed, 339 insertions(+), 936 deletions(-) diff --git a/server/src/item.rs b/server/src/item.rs index 66db8759..8365d7c6 100644 --- a/server/src/item.rs +++ b/server/src/item.rs @@ -462,7 +462,7 @@ impl Item { self.into_skill().unwrap().multiplier()), Item::ClutchI | - Item::ClutchII | + Item::ClutchII | Item::ClutchIII => format!("Construct cannot be KO'd while active. Additionally provides immunity to disables."), Item::CorruptI | @@ -482,9 +482,9 @@ impl Item { self.into_skill().unwrap().effect().first().unwrap().get_duration()), Item::DecayI | - Item::DecayII | + Item::DecayII | Item::DecayIII => format!( - "Reduces healing taken by {:?}% and deals blue damage {:?}% blue power each turn. Lasts {:?}T", + "Reduces healing taken by {:?}% and deals {:?}% BluePower as BlueDamage each turn. Lasts {:?}T", 100 - self.into_skill().unwrap().effect().first().unwrap().get_multiplier(), self.into_skill().unwrap().multiplier(), self.into_skill().unwrap().effect().first().unwrap().get_duration()), @@ -513,7 +513,7 @@ impl Item { Item::HexI | Item::HexII | Item::HexIII => format!("Blue based skill that applies Hex for {:?}T. \ - Hexed targets cannot cast any skills.", + Hexed targets cannot cast any skills.", self.into_skill().unwrap().effect().first().unwrap().get_duration()), Item::ImpurityI | @@ -522,11 +522,11 @@ impl Item { "Impurity increases Green Power by {:?}%, Blue based Attack skills will blast again dealing {:?}{}. Lasts {:?}T", self.into_skill().unwrap().effect().first().unwrap().get_multiplier() - 100, Skill::ImpureBlast.multiplier(), - "% GreenPower as BluePower", + "% GreenPower as BlueDamage", self.into_skill().unwrap().effect().first().unwrap().get_duration()), Item::InvertI | - Item::InvertII | + Item::InvertII | Item::InvertIII => format!( "Reverse healing into damage and damage into healing. Any excess red or blue damage is converted into shield recharge."), @@ -557,7 +557,7 @@ impl Item { self.into_skill().unwrap().effect().first().unwrap().get_duration()), Item::RechargeI | - Item::RechargeII | + Item::RechargeII | Item::RechargeIII => format!( "Recharge Red and Blue Life based on {:?} RedPower and BluePower", self.into_skill().unwrap().multiplier()), @@ -567,7 +567,7 @@ impl Item { Item::RuinIII => format!( "Team wide Stun for {:?}T. Stunned constructs are unable to cast skills.", self.into_skill().unwrap().effect().first().unwrap().get_duration()), - + Item::ScatterI | Item::ScatterII | Item::ScatterIII => format!( @@ -662,15 +662,15 @@ impl Item { Item::ScatterI => vec![Item::Buff, Item::Blue, Item::Blue], Item::ScatterII => vec![Item::ScatterI, Item::ScatterI, Item::ScatterI], Item::ScatterIII => vec![Item::ScatterIII, Item::ScatterIII, Item::ScatterIII], - + Item::HasteI => vec![Item::Buff, Item::Red, Item::Green], Item::HasteII => vec![Item::HasteI, Item::HasteI, Item::HasteI], Item::HasteIII => vec![Item::HasteII, Item::HasteII, Item::HasteII], Item::ImpurityI => vec![Item::Buff, Item::Green, Item::Blue], Item::ImpurityII => vec![Item::ImpurityI, Item::ImpurityI, Item::ImpurityI], Item::ImpurityIII => vec![Item::ImpurityII, Item::ImpurityII, Item::ImpurityII], - Item::AmplifyI => vec![Item::Buff, Item::Red, Item::Blue], - Item::AmplifyII => vec![Item::AmplifyI, Item::AmplifyI, Item::AmplifyI], + Item::AmplifyI => vec![Item::Buff, Item::Red, Item::Blue], + Item::AmplifyII => vec![Item::AmplifyI, Item::AmplifyI, Item::AmplifyI], Item::AmplifyIII => vec![Item::AmplifyII, Item::AmplifyII, Item::AmplifyII], Item::SnareI => vec![Item::Debuff, Item::Red, Item::Red], @@ -882,7 +882,8 @@ impl From for Item { Skill::TestBlock => Item::TestBlock, Skill::TestParry => Item::TestParry, Skill::TestSiphon => Item::TestSiphon, - _ => panic!("{:?} not implemented with item conversion", skill), + + // _ => panic!("{:?} not implemented with item conversion", skill), } } } @@ -938,7 +939,7 @@ pub fn get_combos() -> Vec { Combo { components: Item::ScatterI.combo(), item: Item::ScatterI }, Combo { components: Item::ScatterII.combo(), item: Item::ScatterII }, Combo { components: Item::ScatterIII.combo(), item: Item::ScatterIII }, - + Combo { components: Item::HasteI.combo(), item: Item::HasteI }, Combo { components: Item::HasteII.combo(), item: Item::HasteII }, Combo { components: Item::HasteIII.combo(), item: Item::HasteIII }, @@ -948,7 +949,7 @@ pub fn get_combos() -> Vec { Combo { components: Item::ImpurityI.combo(), item: Item::ImpurityI }, Combo { components: Item::ImpurityII.combo(), item: Item::ImpurityII }, Combo { components: Item::ImpurityIII.combo(), item: Item::ImpurityIII }, - + Combo { components: Item::AmplifyI.combo(), item: Item::AmplifyI }, Combo { components: Item::AmplifyII.combo(), item: Item::AmplifyII }, Combo { components: Item::AmplifyIII.combo(), item: Item::AmplifyIII }, @@ -981,11 +982,11 @@ pub fn get_combos() -> Vec { Combo { components: Item::PurifyI.combo(), item: Item::PurifyI }, 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::ClutchI.combo(), item: Item::ClutchI }, Combo { components: Item::ClutchII.combo(), item: Item::ClutchII }, Combo { components: Item::ClutchIII.combo(), item: Item::ClutchIII }, diff --git a/server/src/skill.rs b/server/src/skill.rs index 5fb3cf6b..c37cbc5c 100644 --- a/server/src/skill.rs +++ b/server/src/skill.rs @@ -21,8 +21,7 @@ pub fn pre_resolve(cast: &Cast, game: &mut Game, mut resolutions: Resolutions) - let targets = game.get_targets(cast.skill, &source, cast.target_construct_id); if skill.aoe() { // Send an aoe skill event for anims - resolutions.push(Resolution::new(&source, - &game.construct_by_id(cast.target_construct_id).unwrap().clone()).event(Event::AoeSkill { skill })); + resolutions.push(Resolution::new(&source, &game.construct_by_id(cast.target_construct_id).unwrap().clone()).event(Event::AoeSkill { skill })); } for target_id in targets { @@ -76,9 +75,9 @@ pub fn resolve(skill: Skill, source: &mut Construct, target: &mut Construct, mut if source.affected(Effect::Haste) { match skill { Skill::Attack | - Skill::SlayI | - Skill::ChaosI | - Skill::StrikeI => { + Skill::Slay | + Skill::Chaos | + Skill::Strike => { let amount = source.speed().pct(Skill::HasteStrike.multiplier()); target.deal_red_damage(Skill::HasteStrike, amount) .into_iter() @@ -90,9 +89,9 @@ pub fn resolve(skill: Skill, source: &mut Construct, target: &mut Construct, mut if source.affected(Effect::Impurity) { match skill { - Skill::BlastI | - Skill::ChaosI | - Skill::SiphonI => { + Skill::Blast | + Skill::Chaos | + Skill::Siphon => { let amount = source.green_power().pct(Skill::ImpureBlast.multiplier()); target.deal_blue_damage(Skill::ImpureBlast, amount) .into_iter() @@ -113,169 +112,56 @@ pub fn resolve(skill: Skill, source: &mut Construct, target: &mut Construct, mut // } resolutions = match skill { - Skill::AmplifyI | - Skill::AmplifyII | - Skill::AmplifyIII => amplify(source, target, resolutions, skill), - - Skill::BanishI | - Skill::BanishII | - Skill::BanishIII => banish(source, target, resolutions, skill), // TODO prevent all actions - - Skill::BlastI | - Skill::BlastII | - Skill::BlastIII => blast(source, target, resolutions, skill), - - Skill::ChaosI | - Skill::ChaosII | - Skill::ChaosIII => chaos(source, target, resolutions, skill), - - Skill::ClutchI | - 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::CurseI | - Skill::CurseII | - Skill::CurseIII => curse(source, target, resolutions, skill), - - Skill::DecayI | - Skill::DecayII | - Skill::DecayIII => decay(source, target, resolutions, skill), // dot - Skill::DecayTickI | - Skill::DecayTickII | - Skill::DecayTickIII => decay_tick(source, target, resolutions, skill), // dot - - Skill::HasteI | - Skill::HasteII | - Skill::HasteIII => haste(source, target, resolutions, skill), // speed slow - - Skill::HealI | - Skill::HealII | - Skill::HealIII => heal(source, target, resolutions, skill), - - Skill::HexI | - Skill::HexII | - Skill::HexIII => hex(source, target, resolutions, skill), - - Skill::HostilityI | - Skill::HostilityII | - Skill::HostilityIII => hostility(source, target, resolutions, skill), - - Skill::ImpurityI | - Skill::ImpurityII | - Skill::ImpurityIII => impurity(source, target, resolutions, skill), - - Skill::InvertI | - Skill::InvertII | - Skill::InvertIII => invert(source, target, resolutions, skill), - - Skill::ParryI | - Skill::ParryII | - Skill::ParryIII => parry(source, target, resolutions, skill), - - Skill::PurgeI | - Skill::PurgeII | - Skill::PurgeIII => purge(source, target, resolutions, skill), // dispel all buffs - - Skill::PurifyI | - Skill::PurifyII | - Skill::PurifyIII => purify(source, target, resolutions, skill), - - Skill::RechargeI | - Skill::RechargeII | - Skill::RechargeIII => recharge(source, target, resolutions, skill), - - Skill::ReflectI | - Skill::ReflectII | - Skill::ReflectIII => reflect(source, target, resolutions, skill), - - Skill::RuinI | - Skill::RuinII | - Skill::RuinIII => ruin(source, target, resolutions, skill), - - Skill::ScatterI | - Skill::ScatterII | - Skill::ScatterIII => scatter(source, target, resolutions, skill), // target is immune to magic damage and fx - - Skill::SilenceI | - Skill::SilenceII | - Skill::SilenceIII => silence(source, target, resolutions, skill), // target cannot cast spells - - Skill::SiphonI | - Skill::SiphonII | - Skill::SiphonIII => siphon(source, target, resolutions, skill), // dot - Skill::SiphonTickI | - Skill::SiphonTickII | - Skill::SiphonTickIII => siphon_tick(source, target, resolutions, skill), // dot - - Skill::SlayI | - Skill::SlayII | - Skill::SlayIII => slay(source, target, resolutions, skill), // hybrid dmg self heal - - Skill::SleepI | - Skill::SleepII | - Skill::SleepIII => sleep(source, target, resolutions, skill), // heal stun - - Skill::SnareI | - Skill::SnareII | - Skill::SnareIII => snare(source, target, resolutions, skill), - - Skill::StrangleI | - Skill::StrangleII | - Skill::StrangleIII => strangle(source, target, resolutions, skill), - Skill::StrangleTickI | - Skill::StrangleTickII | - Skill::StrangleTickIII => strangle_tick(source, target, resolutions, skill), - - Skill::StrikeI | - Skill::StrikeII | - Skill::StrikeIII => strike(source, target, resolutions, skill), - - Skill::TauntI | - Skill::TauntII | - Skill::TauntIII => taunt(source, target, resolutions, skill), - - Skill::ThrowI | - Skill::ThrowII | - Skill::ThrowIII => throw(source, target, resolutions, skill), // no damage stun, adds vulnerable - - Skill::TriageI | - Skill::TriageII | - Skill::TriageIII => triage(source, target, resolutions, skill), // hot - - Skill::TriageTickI | - Skill::TriageTickII | - Skill::TriageTickIII => triage_tick(source, target, resolutions, skill), // hot - - // Base Skills + Skill::Amplify => amplify(source, target, resolutions, skill), // increase magic damage Skill::Attack => attack(source, target, resolutions, skill), + Skill::Banish => banish(source, target, resolutions, skill), // TODO prevent all actions + Skill::Blast => blast(source, target, resolutions, skill), Skill::Block => block(source, target, resolutions, skill), Skill::Buff => buff(source, target, resolutions, skill), + Skill::Chaos => chaos(source, target, resolutions, skill), + Skill::Clutch => clutch(source, target, resolutions, skill), + Skill::Corrupt => corrupt(source, target, resolutions, skill), + Skill::CorruptionTick => corruption_tick(source, target, resolutions, skill), + Skill::Curse => curse(source, target, resolutions, skill), Skill::Debuff => debuff(source, target, resolutions, skill), // speed slow + Skill::Decay => decay(source, target, resolutions, skill), // dot + Skill::DecayTick => decay_tick(source, target, resolutions, skill), // dot + Skill::Haste => haste(source, target, resolutions, skill), // speed slow + Skill::HasteStrike => panic!("haste strike should not be caste"), + Skill::Heal => heal(source, target, resolutions, skill), + Skill::Hex => hex(source, target, resolutions, skill), + Skill::Hostility => hostility(source, target, resolutions, skill), + Skill::Impurity => impurity(source, target, resolutions, skill), + Skill::ImpureBlast => panic!("impure blast should not be caste"), + Skill::Invert => invert(source, target, resolutions, skill), + // Skill::Injure => injure(source, target, resolutions, skill), + Skill::Parry => parry(source, target, resolutions, skill), + Skill::Purge => purge(source, target, resolutions, skill), // dispel all buffs + Skill::Purify => purify(source, target, resolutions, skill), // dispel all debuffs + Skill::Recharge => recharge(source, target, resolutions, skill), // target is immune to magic damage and fx + Skill::Reflect => reflect(source, target, resolutions, skill), + Skill::Riposte => panic!("riposte should not be caste"), + Skill::Ruin => ruin(source, target, resolutions, skill), + Skill::Scatter => scatter(source, target, resolutions, skill), // target is immune to magic damage and fx + Skill::Silence => silence(source, target, resolutions, skill), // target cannot cast spells + Skill::Siphon => siphon(source, target, resolutions, skill), + Skill::SiphonTick => siphon_tick(source, target, resolutions, skill), // hot + Skill::Slay => slay(source, target, resolutions, skill), // hybrid dmg self heal + Skill::Sleep => sleep(source, target, resolutions, skill), // speed slow + Skill::Snare => snare(source, target, resolutions, skill), + Skill::Strangle => strangle(source, target, resolutions, skill), + Skill::StrangleTick => strangle_tick(source, target, resolutions, skill), + + Skill::Strike => strike(source, target, resolutions, skill), + Skill::StrikeII => strike(source, target, resolutions, skill), + Skill::StrikeIII => strike(source, target, resolutions, skill), + Skill::Stun => stun(source, target, resolutions, skill), + Skill::Taunt => taunt(source, target, resolutions, skill), + Skill::Throw => throw(source, target, resolutions, skill), // no damage stun, adds vulnerable + Skill::Triage => triage(source, target, resolutions, skill), // hot + Skill::TriageTick => triage_tick(source, target, resolutions, skill), // hot - //Triggered - Skill::CorruptionI | - Skill::CorruptionII | - Skill::CorruptionIII => panic!("should only trigger from corrupt hit"), - Skill::HasteStrike => panic!("should only trigger from haste"), - Skill::HatredI | - Skill::HatredII | - Skill::HatredIII => panic!("should only trigger from hatred"), - Skill::ImpureBlast => panic!("should only trigger from impurity"), - Skill::RiposteI | - Skill::RiposteII | - Skill::RiposteIII => panic!("should only trigger from parry"), - - - // Not used - Skill::Injure => injure(source, target, resolutions, skill), // ----------------- // Test // ----------------- @@ -284,8 +170,8 @@ pub fn resolve(skill: Skill, source: &mut Construct, target: &mut Construct, mut Skill::TestTouch => touch(source, target, resolutions, skill), Skill::TestStun => stun(source, target, resolutions, Skill::Stun), Skill::TestBlock => block(source, target, resolutions, Skill::Block), - Skill::TestParry => parry(source, target, resolutions, Skill::ParryI), - Skill::TestSiphon => siphon(source, target, resolutions, Skill::SiphonI), + Skill::TestParry => parry(source, target, resolutions, Skill::Parry), + Skill::TestSiphon => siphon(source, target, resolutions, Skill::Siphon), }; return resolutions; @@ -299,25 +185,11 @@ fn post_resolve(_skill: Skill, game: &mut Game, mut resolutions: Resolutions) -> match event { Event::Damage { amount, skill, mitigation: _, colour: _ } => { if target.affected(Effect::Corrupt) { - let ConstructEffect { effect: _, duration: _, meta, tick: _ } = target.effects.iter() - .find(|e| e.effect == Effect::Corrupt).unwrap().clone(); - match meta { - Some(EffectMeta::Skill(s)) => { - resolutions = corruption(&mut target, &mut source, resolutions, s); - }, - _ => panic!("no corrupt skill"), - }; + resolutions = corruption(&mut target, &mut source, resolutions, Skill::Corrupt); } if target.affected(Effect::Hostility) { - let ConstructEffect { effect: _, duration: _, meta, tick: _ } = target.effects.iter() - .find(|e| e.effect == Effect::Hostility).unwrap().clone(); - match meta { - Some(EffectMeta::Skill(s)) => { - resolutions = hatred(&mut target, &mut source, resolutions, skill, amount, s); - }, - _ => panic!("no hatred skill"), - }; + resolutions = hatred(&mut source, &mut target, resolutions, skill, amount, Skill::Hostility); } // beware that scatter doesn't cause any damage @@ -329,16 +201,8 @@ fn post_resolve(_skill: Skill, game: &mut Game, mut resolutions: Resolutions) -> Event::Immunity { skill: _, immunity } => match immunity.contains(&Effect::Parry) { true => { - let ConstructEffect { effect: _, duration: _, meta, tick: _ } = target.effects.iter() - .find(|e| e.effect == Effect::Parry).unwrap().clone(); - match meta { - Some(EffectMeta::Skill(s)) => { - resolutions = riposte(&mut target, &mut source, resolutions, s); - }, - _ => panic!("no parry skill"), - }; - - }, + resolutions = riposte(&mut target, &mut source, resolutions, Skill::Riposte); + } false => (), }, _ => (), @@ -469,6 +333,7 @@ pub enum Effect { Invert, Parry, Reflect, + Ruin, Slow, Snare, Strangle, @@ -498,7 +363,7 @@ pub enum Effect { Regen, Siphon, - Injured, + // Injured, // Airborne, // Boost // Bleed, @@ -525,23 +390,13 @@ impl Effect { Effect::Banish => true, Effect::Clutch => [ Skill::Stun, - Skill::HexI, - Skill::HexII, - Skill::HexIII, - Skill::SilenceI, - Skill::SilenceII, - Skill::SilenceIII, - Skill::RuinI, - Skill::RuinII, - Skill::RuinIII, - Skill::StrangleI, - Skill::StrangleII, - Skill::StrangleIII, - Skill::SnareI, - Skill::SnareII, - Skill::SnareIII + Skill::Hex, + Skill::Silence, + Skill::Ruin, + Skill::Strangle, + Skill::Snare ].contains(&skill), - Effect::Injured => skill.colours().contains(&Colour::Green), + // Effect::Injured => skill.colours().contains(&Colour::Green), _ => false, } } @@ -554,14 +409,10 @@ impl Effect { match self { Effect::Stun => true, Effect::Hex => true, + Effect::Ruin => true, Effect::Banish => true, Effect::Strangle => true, - Effect::Strangling => match skill { - Skill::StrangleTickI | - Skill::StrangleTickII | - Skill::StrangleTickIII => false, - _ => true, - }, + Effect::Strangling => skill != Skill::StrangleTick, Effect::Silence => skill.colours().contains(&Colour::Blue), Effect::Snare => skill.colours().contains(&Colour::Red), Effect::Ko => skill.ko_castable(), @@ -637,6 +488,7 @@ impl Effect { // magic Effect::Hex => EffectCategory::Debuff, + Effect::Ruin => EffectCategory::Debuff, Effect::Curse => EffectCategory::Debuff, Effect::Banish => EffectCategory::Debuff, // todo randomise // Effect::Banish => rng.gen_bool(0.5), @@ -666,7 +518,7 @@ impl Effect { Effect::Siphon => EffectCategory::Debuff, // not in game - Effect::Injured => EffectCategory::Debuff, + // Effect::Injured => EffectCategory::Debuff, Effect::Ko => EffectCategory::Ko, } @@ -692,157 +544,48 @@ pub enum Skill { // Evade, // actively evade // Nightmare, // Sleep, - AmplifyI, - AmplifyII, - AmplifyIII, - - BanishI, - BanishII, - BanishIII, - - BlastI, - BlastII, - BlastIII, - - ChaosI, - ChaosII, - ChaosIII, - - ClutchI, - ClutchII, - ClutchIII, - - CorruptI, - CorruptII, - CorruptIII, - CorruptionI, - CorruptionII, - CorruptionIII, - CorruptionTickI, - CorruptionTickII, - CorruptionTickIII, - - CurseI, - CurseII, - CurseIII, - - DecayI, // dot - DecayII, - DecayIII, - DecayTickI, // dot - DecayTickII, - DecayTickIII, - - HasteI, - HasteII, - HasteIII, + Amplify, + Banish, + Blast, + Chaos, + Clutch, + Corrupt, + CorruptionTick, + Curse, + Decay, // dot + DecayTick, // dot + Haste, HasteStrike, - - HealI, - HealII, - HealIII, - - HexI, - HexII, - HexIII, - - HatredI, - HatredII, - HatredIII, - HostilityI, - HostilityII, - HostilityIII, + Heal, + Hex, + Hostility, ImpureBlast, - - ImpurityI, - ImpurityII, - ImpurityIII, - Injure, - - InvertI, - InvertII, - InvertIII, - - ParryI, // avoid all damage - ParryII, - ParryIII, - PurgeI, - PurgeII, - PurgeIII, - - PurifyI, - PurifyII, - PurifyIII, - - RechargeI, - RechargeII, - RechargeIII, - - ReflectI, - ReflectII, - ReflectIII, - - RiposteI, - RiposteII, - RiposteIII, - - RuinI, - RuinII, - RuinIII, - - ScatterI, - ScatterII, - ScatterIII, - - SilenceI, - SilenceII, - SilenceIII, - - SiphonI, - SiphonII, - SiphonIII, - SiphonTickI, - SiphonTickII, - SiphonTickIII, - - SlayI, - SlayII, - SlayIII, - - SleepI, - SleepII, - SleepIII, - - SnareI, - SnareII, - SnareIII, - - StrangleI, - StrangleII, - StrangleIII, - StrangleTickI, - StrangleTickII, - StrangleTickIII, - - StrikeI, + Impurity, + // Injure, + Invert, + Parry, // avoid all damage + Purge, + Purify, + Recharge, + Reflect, + Riposte, + Ruin, + Scatter, + Silence, + Siphon, + SiphonTick, + Slay, + Sleep, + Snare, + Strangle, + StrangleTick, + Strike, StrikeII, StrikeIII, - - TauntI, - TauntII, - TauntIII, - - ThrowI, // no damage stun, adds vulnerable - ThrowII, - ThrowIII, - - TriageI, // hot - TriageII, - TriageIII, - - TriageTickI, - TriageTickII, - TriageTickIII, + Taunt, + Throw, // no damage stun, adds vulnerable + Triage, // hot + TriageTick, // used by tests, no cd, 100% multiplier TestAttack, @@ -860,84 +603,39 @@ impl Skill { // Attack Base Skill::Attack => 80, // Base - Skill::BlastI => 110, // BB - Skill::BlastII => 130, // BB - Skill::BlastIII => 150, // BB - - Skill::ChaosI => 40, // BR - Skill::ChaosII => 50, // BR - Skill::ChaosIII => 60, // BR - - Skill::HealI => 130, //GG - Skill::HealII => 160, //GG - Skill::HealIII => 200, //GG - Skill::SiphonTickI => 40, // GB - Skill::SiphonTickII => 70, - Skill::SiphonTickIII => 110, - - Skill::SlayI => 70, // RG - Skill::SlayII => 90, - Skill::SlayIII => 120, - - Skill::StrikeI => 90, //RR - Skill::StrikeII => 110, - Skill::StrikeIII => 140, + Skill::Blast => 110, // BB + Skill::Chaos => 40, // BR + Skill::Heal => 130, //GG + Skill::SiphonTick => 40, // GB + Skill::Slay => 70, // RG + Skill::Strike => 90, //RR + Skill::StrikeII => 110, + Skill::StrikeIII => 130, // Block Base - Skill::CorruptionTickI => 80, - Skill::CorruptionTickII => 100, - Skill::CorruptionTickIII => 130, + Skill::CorruptionTick => 80, + Skill::Purify => 45, //Green dmg (heal) + Skill::Recharge => 85, //restore red and blue life (heal) + Skill::Reflect => 45, //restore blue life (heal) - Skill::ParryI => 110, - Skill::ParryII => 145, - Skill::ParryIII => 200, - Skill::RiposteI => 70, - Skill::RiposteII => 95, - Skill::RiposteIII => 120, - - Skill::PurifyI => 45, //Green dmg (heal) - Skill::PurifyII => 70, - Skill::PurifyIII => 105, - - Skill::ReflectI => 45, //restore blue life (heal) - Skill::ReflectII => 70, - Skill::ReflectIII => 100, - - Skill::RechargeI => 85, //restore red and blue life (heal) - Skill::RechargeII => 130, - Skill::RechargeIII => 200, + Skill::Parry => 110, + Skill::Riposte => 70, // Stun Base - Skill::SleepI => 240, //Green dmg (heal) - Skill::SleepII => 300, - Skill::SleepIII => 400, - Skill::StrangleTickI => 65, - Skill::StrangleTickII => 95, - Skill::StrangleTickIII => 140, + Skill::Sleep => 240, //Green dmg (heal) + Skill::StrangleTick => 65, // Debuff Base - Skill::DecayTickI => 25, - Skill::DecayTickII => 45, - Skill::DecayTickIII => 70, - Skill::SilenceI => 55, // Deals more per blue skill on target - Skill::SilenceII => 80, - Skill::SilenceIII => 110, - Skill::SnareI => 40, // Deals more per red skill on target - Skill::SnareII => 65, - Skill::SnareIII => 100, + Skill::Silence => 55, // Deals more per blue skill on target + Skill::Snare => 40, // Deals more per red skill on target + Skill::DecayTick => 25, // Buff base Skill::ImpureBlast => 25, Skill::HasteStrike => 30, - Skill::ScatterI => 140, - Skill::ScatterII => 200, - Skill::ScatterIII => 300, - Skill::TauntI => 80, - Skill::TauntII => 110, - Skill::TauntIII => 150, - Skill::TriageTickI => 75, - Skill::TriageTickII => 110, - Skill::TriageTickIII => 140, + Skill::Taunt => 80, + Skill::TriageTick => 75, + Skill::Scatter => 140, _ => 100, } @@ -946,155 +644,46 @@ impl Skill { pub fn effect(&self) -> Vec { match self { // Modifiers - Skill::AmplifyI => vec![ConstructEffect {effect: Effect::Amplify, duration: 2, - meta: Some(EffectMeta::Multiplier(150)), tick: None}], - Skill::AmplifyII => vec![ConstructEffect {effect: Effect::Amplify, duration: 3, - meta: Some(EffectMeta::Multiplier(175)), tick: None}], - Skill::AmplifyIII => vec![ConstructEffect {effect: Effect::Amplify, duration: 4, - meta: Some(EffectMeta::Multiplier(200)), tick: None}], + Skill::Amplify => vec![ConstructEffect {effect: Effect::Amplify, duration: 2, meta: Some(EffectMeta::Multiplier(150)), tick: None}], + Skill::Banish => vec![ConstructEffect {effect: Effect::Banish, duration: 1, meta: None, tick: None}], + Skill::Block => vec![ConstructEffect {effect: Effect::Block, duration: 1, meta: Some(EffectMeta::Multiplier(50)), tick: None}], + Skill::Buff => vec![ConstructEffect {effect: Effect::Buff, duration: 2, meta: Some(EffectMeta::Multiplier(125)), tick: None }], - Skill::BanishI => vec![ConstructEffect {effect: Effect::Banish, duration: 1,meta: None, tick: None}], - Skill::BanishII => vec![ConstructEffect {effect: Effect::Banish, duration: 2,meta: None, tick: None}], - Skill::BanishIII => vec![ConstructEffect {effect: Effect::Banish, duration: 3,meta: None, tick: None}], - Skill::Block => vec![ConstructEffect {effect: Effect::Block, duration: 1, - meta: Some(EffectMeta::Multiplier(50)), tick: None}], - Skill::Buff => vec![ConstructEffect {effect: Effect::Buff, duration: 2, - meta: Some(EffectMeta::Multiplier(125)), tick: None }], + Skill::Corrupt => vec![ConstructEffect {effect: Effect::Corrupt, duration: 2, meta: None, tick: None}, + ConstructEffect {effect: Effect::Corruption, duration: 3, meta: None, 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::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::ClutchIII => vec![ConstructEffect {effect: Effect::Clutch, duration: 3, meta: None, tick: None }], + Skill::Clutch => vec![ConstructEffect {effect: Effect::Clutch, duration: 1, meta: None, tick: None }], + Skill::Curse => vec![ConstructEffect {effect: Effect::Curse, duration: 2, meta: Some(EffectMeta::Multiplier(150)), tick: None}], + Skill::Debuff => vec![ConstructEffect {effect: Effect::Slow, duration: 3, meta: Some(EffectMeta::Multiplier(50)), tick: None }], + Skill::Decay => vec![ConstructEffect {effect: Effect::Wither, duration: 3, meta: Some(EffectMeta::Multiplier(50)), tick: None }, + ConstructEffect {effect: Effect::Decay, duration: 3, meta: None, tick: None }], + Skill::Haste => vec![ConstructEffect {effect: Effect::Haste, duration: 2, meta: Some(EffectMeta::Multiplier(150)), tick: None }], + Skill::Hex => vec![ConstructEffect {effect: Effect::Hex, duration: 2, meta: None, tick: None}], + Skill::Hostility => vec![ConstructEffect {effect: Effect::Hostility, duration: 2, meta: None, tick: None}, + ConstructEffect {effect: Effect::Hatred, duration: 5, meta: None, tick: None}], + Skill::Impurity => vec![ConstructEffect {effect: Effect::Impurity, duration: 3, meta: Some(EffectMeta::Multiplier(150)), tick: None }], + Skill::Invert => vec![ConstructEffect {effect: Effect::Invert, duration: 2, meta: None, tick: None}], - Skill::CurseI => vec![ConstructEffect {effect: Effect::Curse, duration: 2, - meta: Some(EffectMeta::Multiplier(150)), tick: None}], - Skill::CurseII => vec![ConstructEffect {effect: Effect::Curse, duration: 2, - meta: Some(EffectMeta::Multiplier(200)), tick: None}], - Skill::CurseIII => vec![ConstructEffect {effect: Effect::Curse, duration: 3, - meta: Some(EffectMeta::Multiplier(250)), tick: None}], + Skill::Parry => vec![ConstructEffect {effect: Effect::Parry, duration: 2, meta: None, tick: None }], + Skill::Reflect => vec![ConstructEffect {effect: Effect::Reflect, duration: 1, meta: None, tick: None }], + Skill::Throw => vec![ConstructEffect {effect: Effect::Stun, duration: 1, meta: None, tick: None}, + ConstructEffect {effect: Effect::Vulnerable, duration: 3, meta: Some(EffectMeta::Multiplier(150)), tick: None}], - Skill::Debuff => vec![ConstructEffect {effect: Effect::Slow, duration: 3, - meta: Some(EffectMeta::Multiplier(50)), tick: None }], - - Skill::DecayI => vec![ConstructEffect {effect: Effect::Wither, duration: 3, meta: Some(EffectMeta::Multiplier(50)), tick: None }, - ConstructEffect {effect: Effect::Decay, duration: 3, - meta: Some(EffectMeta::Skill(Skill::DecayTickI)), tick: None}], - Skill::DecayII => vec![ConstructEffect {effect: Effect::Wither, duration: 3, meta: Some(EffectMeta::Multiplier(35)), tick: None }, - ConstructEffect {effect: Effect::Decay, duration: 3, - meta: Some(EffectMeta::Skill(Skill::DecayTickII)), tick: None}], - Skill::DecayIII => vec![ConstructEffect {effect: Effect::Wither, duration: 4, meta: Some(EffectMeta::Multiplier(20)), tick: None }, - ConstructEffect {effect: Effect::Decay, duration: 4, - meta: Some(EffectMeta::Skill(Skill::DecayTickIII)), tick: None}], + Skill::Ruin => vec![ConstructEffect {effect: Effect::Stun, duration: 1, meta: None, tick: None}], - Skill::HasteI => vec![ConstructEffect {effect: Effect::Haste, duration: 2, - meta: Some(EffectMeta::Multiplier(150)), tick: None }], - Skill::HasteII => vec![ConstructEffect {effect: Effect::Haste, duration: 3, - meta: Some(EffectMeta::Multiplier(175)), tick: None }], - Skill::HasteIII => vec![ConstructEffect {effect: Effect::Haste, duration: 4, - meta: Some(EffectMeta::Multiplier(225)), tick: None }], - Skill::HexI => vec![ConstructEffect {effect: Effect::Hex, duration: 2, meta: None, tick: None}], - Skill::HexII => vec![ConstructEffect {effect: Effect::Hex, duration: 3, meta: None, tick: None}], - Skill::HexIII => vec![ConstructEffect {effect: Effect::Hex, duration: 4, meta: None, tick: None}], - - Skill::HostilityI => vec![ConstructEffect {effect: Effect::Hostility, duration: 2, - meta: Some(EffectMeta::Skill(Skill::HatredI)), tick: None}], - Skill::HostilityII => vec![ConstructEffect {effect: Effect::Hostility, duration: 3, - meta: Some(EffectMeta::Skill(Skill::HatredII)), tick: None}], - Skill::HostilityIII => vec![ConstructEffect {effect: Effect::Hostility, duration: 4, - meta: Some(EffectMeta::Skill(Skill::HatredIII)), tick: None}], - Skill::HatredI => vec![ConstructEffect {effect: Effect::Hatred, duration: 5, meta: None, tick: None}], - Skill::HatredII => vec![ConstructEffect {effect: Effect::Hatred, duration: 7, meta: None, tick: None}], - Skill::HatredIII => vec![ConstructEffect {effect: Effect::Hatred, duration: 9, meta: None, tick: None}], - - Skill::ImpurityI => vec![ConstructEffect {effect: Effect::Impurity, duration: 2, - meta: Some(EffectMeta::Multiplier(150)), tick: None }], - Skill::ImpurityII => vec![ConstructEffect {effect: Effect::Impurity, duration: 3, - meta: Some(EffectMeta::Multiplier(175)), tick: None }], - Skill::ImpurityIII => vec![ConstructEffect {effect: Effect::Impurity, duration: 4, - meta: Some(EffectMeta::Multiplier(225)), tick: None }], + Skill::Scatter => vec![ConstructEffect {effect: Effect::Scatter, duration: 2, meta: None, tick: None}], + Skill::Silence => vec![ConstructEffect {effect: Effect::Silence, duration: 2, meta: None, tick: None}], + Skill::Siphon => vec![ConstructEffect {effect: Effect::Siphon, duration: 2, meta: None, tick: None}], + Skill::Sleep => vec![ConstructEffect {effect: Effect::Stun, duration: 2, meta: None, tick: None}], + Skill::Snare => vec![ConstructEffect {effect: Effect::Snare, duration: 2, meta: None, tick: None}], + Skill::Strangle => vec![ConstructEffect {effect: Effect::Strangle, duration: 2, meta: None, tick: None}], + Skill::Stun => vec![ConstructEffect {effect: Effect::Stun, duration: 2, meta: None, tick: None}], + Skill::Taunt => vec![ConstructEffect {effect: Effect::Taunt, duration: 2, meta: None, tick: None}], + Skill::Triage => vec![ConstructEffect {effect: Effect::Triage, duration: 2, meta: None, tick: None}], - Skill::InvertI => vec![ConstructEffect {effect: Effect::Invert, duration: 2, meta: None, tick: None}], - Skill::InvertII => vec![ConstructEffect {effect: Effect::Invert, duration: 3, meta: None, tick: None}], - Skill::InvertIII => vec![ConstructEffect {effect: Effect::Invert, duration: 4, meta: None, tick: None}], - - Skill::ParryI => vec![ConstructEffect {effect: Effect::Parry, duration: 2, - meta: Some(EffectMeta::Skill(Skill::RiposteI)), tick: None}], - Skill::ParryII => vec![ConstructEffect {effect: Effect::Parry, duration: 2, - meta: Some(EffectMeta::Skill(Skill::RiposteII)), tick: None}], - Skill::ParryIII => vec![ConstructEffect {effect: Effect::Parry, duration: 2, - meta: Some(EffectMeta::Skill(Skill::RiposteIII)), tick: None}], - - Skill::ReflectI => vec![ConstructEffect {effect: Effect::Reflect, duration: 1, meta: None, tick: None }], - Skill::ReflectII => vec![ConstructEffect {effect: Effect::Reflect, duration: 2, meta: None, tick: None }], - Skill::ReflectIII => vec![ConstructEffect {effect: Effect::Reflect, duration: 3, meta: None, tick: None }], - - Skill::ThrowI => vec![ConstructEffect {effect: Effect::Stun, duration: 1, meta: None, tick: None}, - ConstructEffect {effect: Effect::Vulnerable, duration: 3, meta: Some(EffectMeta::Multiplier(150)), tick: None}], - Skill::ThrowII => vec![ConstructEffect {effect: Effect::Stun, duration: 1, meta: None, tick: None}, - ConstructEffect {effect: Effect::Vulnerable, duration: 4, meta: Some(EffectMeta::Multiplier(200)), tick: None}], - Skill::ThrowIII => vec![ConstructEffect {effect: Effect::Stun, duration: 2, meta: None, tick: None}, - ConstructEffect {effect: Effect::Vulnerable, duration: 4, meta: Some(EffectMeta::Multiplier(250)), tick: None}], - - Skill::RuinI => vec![ConstructEffect {effect: Effect::Stun, duration: 1, meta: None, tick: None}], - Skill::RuinII => vec![ConstructEffect {effect: Effect::Stun, duration: 1, meta: None, tick: None}], - Skill::RuinIII => vec![ConstructEffect {effect: Effect::Stun, duration: 2, meta: None, tick: None}], - - Skill::ScatterI => vec![ConstructEffect {effect: Effect::Scatter, duration: 2, meta: None, tick: None}], - Skill::ScatterII => vec![ConstructEffect {effect: Effect::Scatter, duration: 3, meta: None, tick: None}], - Skill::ScatterIII => vec![ConstructEffect {effect: Effect::Scatter, duration: 4, meta: None, tick: None}], - - Skill::SilenceI => vec![ConstructEffect {effect: Effect::Silence, duration: 2, meta: None, tick: None}], - Skill::SilenceII => vec![ConstructEffect {effect: Effect::Silence, duration: 3, meta: None, tick: None}], - Skill::SilenceIII => vec![ConstructEffect {effect: Effect::Silence, duration: 4, meta: None, tick: None}], - - Skill::SiphonI => vec![ConstructEffect {effect: Effect::Siphon, duration: 2, - meta: Some(EffectMeta::Skill(Skill::SiphonTickI)), tick: None}], - Skill::SiphonII => vec![ConstructEffect {effect: Effect::Siphon, duration: 3, - meta: Some(EffectMeta::Skill(Skill::SiphonTickII)), tick: None}], - Skill::SiphonIII => vec![ConstructEffect {effect: Effect::Siphon, duration: 4, - meta: Some(EffectMeta::Skill(Skill::SiphonTickIII)), tick: None}], - - Skill::SleepI => vec![ConstructEffect {effect: Effect::Stun, duration: 2, meta: None, tick: None}], - Skill::SleepII => vec![ConstructEffect {effect: Effect::Stun, duration: 3, meta: None, tick: None}], - Skill::SleepIII => vec![ConstructEffect {effect: Effect::Stun, duration: 4, meta: None, tick: None}], - - Skill::SnareI => vec![ConstructEffect {effect: Effect::Snare, duration: 2, meta: None, tick: None}], - Skill::SnareII => vec![ConstructEffect {effect: Effect::Snare, duration: 3, meta: None, tick: None}], - Skill::SnareIII => vec![ConstructEffect {effect: Effect::Snare, duration: 4, meta: None, tick: None}], - - Skill::StrangleI => vec![ConstructEffect {effect: Effect::Strangle, duration: 2, - meta: Some(EffectMeta::Skill(Skill::StrangleTickI)), tick: None}], - Skill::StrangleII => vec![ConstructEffect {effect: Effect::Strangle, duration: 2, - meta: Some(EffectMeta::Skill(Skill::StrangleTickII)), tick: None}], - Skill::StrangleIII => vec![ConstructEffect {effect: Effect::Strangle, duration: 2, - meta: Some(EffectMeta::Skill(Skill::StrangleTickIII)), tick: None}], - Skill::Stun => vec![ConstructEffect {effect: Effect::Stun, duration: 2, meta: None, tick: None}], - - Skill::TauntI => vec![ConstructEffect {effect: Effect::Taunt, duration: 2, meta: None, tick: None}], - Skill::TauntII => vec![ConstructEffect {effect: Effect::Taunt, duration: 3, meta: None, tick: None}], - Skill::TauntIII => vec![ConstructEffect {effect: Effect::Taunt, duration: 4, meta: None, tick: None}], - - Skill::TriageI => vec![ConstructEffect {effect: Effect::Triage, duration: 2, - meta: Some(EffectMeta::Skill(Skill::TriageTickI)), tick: None}], - Skill::TriageII => vec![ConstructEffect {effect: Effect::Triage, duration: 3, - meta: Some(EffectMeta::Skill(Skill::TriageTickII)), tick: None}], - Skill::TriageIII => vec![ConstructEffect {effect: Effect::Triage, duration: 4, - meta: Some(EffectMeta::Skill(Skill::TriageTickIII)), tick: None}], //Unused - Skill::Injure => vec![ConstructEffect {effect: Effect::Injured, duration: 2, meta: None, tick: None }], + // Skill::Injure => vec![ConstructEffect {effect: Effect::Injured, duration: 2, meta: None, tick: None }], _ => { panic!("{:?} no skill effect", self); @@ -1107,163 +696,55 @@ impl Skill { Skill::Attack => None, Skill::Debuff => Some(1), Skill::Buff => None, - - Skill::StrikeI => None, + Skill::Strike => None, Skill::StrikeII => None, Skill::StrikeIII => None, Skill::Block => None, // reduce damage - Skill::ParryI | - Skill::ParryII | - Skill::ParryIII => Some(2), // avoid all damage - - Skill::SnareI => Some(2), - Skill::SnareII => Some(2), - Skill::SnareIII => Some(2), + Skill::Parry => Some(2), // avoid all damage + Skill::Riposte => None, // used on parry + Skill::Snare => Some(2), Skill::Stun => Some(2), + Skill::Heal => None, + Skill::Triage => None, // hot + Skill::TriageTick => None, + Skill::Throw => Some(1), // no damage stun, adds vulnerable + Skill::Blast => None, + Skill::Chaos => None, + Skill::Amplify => Some(1), + Skill::Impurity => Some(3), + Skill::ImpureBlast => None, + Skill::Invert => Some(2), + Skill::Decay => Some(1), // dot + Skill::DecayTick => None, + Skill::Siphon => None, + Skill::SiphonTick => None, + Skill::Curse => Some(1), + Skill::Scatter => Some(2), + Skill::Silence => Some(2), + Skill::Purify => None, + Skill::Purge => None, + Skill::Banish => Some(1), + Skill::Hex => Some(1), + Skill::Haste => Some(2), + Skill::HasteStrike => None, // Used in haste - Skill::HealI => None, - Skill::HealII => None, - Skill::HealIII => None, + Skill::Reflect => Some(2), + Skill::Recharge => Some(2), + Skill::Ruin => Some(3), + Skill::Slay => None, + Skill::Sleep => Some(3), - Skill::TriageI => None, // hot - Skill::TriageII => None, // hot - Skill::TriageIII => None, // hot + Skill::Strangle => Some(2), + Skill::StrangleTick => None, + Skill::Clutch => Some(2), + Skill::Taunt => Some(2), + // Skill::Injure => Some(2), - Skill::ThrowI => Some(1), // no damage stun, adds vulnerable - Skill::ThrowII => Some(1), - Skill::ThrowIII => Some(1), + Skill::Corrupt => Some(1), + Skill::CorruptionTick => None, - Skill::BlastI => None, - Skill::BlastII => None, - Skill::BlastIII => None, + Skill::Hostility => Some(1), - Skill::ChaosI => None, - Skill::ChaosII => None, - Skill::ChaosIII => None, - - Skill::AmplifyI => Some(1), - Skill::AmplifyII => Some(1), - Skill::AmplifyIII => Some(1), - Skill::ImpurityI | - Skill::ImpurityII | - Skill::ImpurityIII => Some(3), - - Skill::InvertI => Some(2), - Skill::InvertII => Some(2), - Skill::InvertIII => Some(2), - Skill::DecayI => Some(1), // dot - Skill::DecayII => Some(1), - Skill::DecayIII => Some(1), - Skill::SiphonI | - Skill::SiphonII | - Skill::SiphonIII => None, - - Skill::CurseI => Some(1), - Skill::CurseII => Some(1), - Skill::CurseIII => Some(1), - - Skill::ScatterI => Some(2), - Skill::ScatterII => Some(2), - Skill::ScatterIII => Some(2), - - Skill::SilenceI => Some(3), - Skill::SilenceII => Some(2), - Skill::SilenceIII => Some(2), - - Skill::PurifyI => None, - Skill::PurifyII => None, - Skill::PurifyIII => None, - - Skill::PurgeI => None, - Skill::PurgeII => None, - Skill::PurgeIII => None, - - Skill::BanishI => Some(1), - Skill::BanishII => Some(1), - Skill::BanishIII => Some(1), - - Skill::HexI => Some(1), - Skill::HexII => Some(2), - Skill::HexIII => Some(2), - - Skill::HasteI => Some(2), - Skill::HasteII => Some(2), - Skill::HasteIII => Some(2), - - Skill::ReflectI => Some(2), - Skill::ReflectII => Some(2), - Skill::ReflectIII => Some(2), - - Skill::RechargeI => Some(2), - Skill::RechargeII => Some(2), - Skill::RechargeIII => Some(2), - - Skill::RuinI => Some(3), - Skill::RuinII => Some(2), - Skill::RuinIII => Some(2), - - Skill::SlayI => None, - Skill::SlayII => None, - Skill::SlayIII => None, - - Skill::SleepI => Some(3), - Skill::SleepII => Some(3), - Skill::SleepIII => Some(3), - - Skill::StrangleI => Some(2), - Skill::StrangleII => Some(2), - Skill::StrangleIII => Some(2), - - Skill::ClutchI => Some(1), - Skill::ClutchII => Some(2), - Skill::ClutchIII => Some(3), - - Skill::TauntI => Some(2), - Skill::TauntII => Some(2), - Skill::TauntIII => Some(2), - Skill::Injure => Some(2), - - Skill::CorruptI =>Some(1), - Skill::CorruptII =>Some(1), - Skill::CorruptIII =>Some(1), - - - Skill::HostilityI | - Skill::HostilityII | - Skill::HostilityIII => Some(1), - - //----------- - // Never cast directly - //--------- - // Trigger - Skill::ImpureBlast | - Skill::HasteStrike | - Skill::RiposteI | - Skill::RiposteII | - Skill::RiposteIII | // parry - Skill::CorruptionI | - Skill::CorruptionII | - Skill::CorruptionIII | - Skill::HatredI | - Skill::HatredII | - Skill::HatredIII | - // Ticks - Skill::CorruptionTickI | - Skill::CorruptionTickII | - Skill::CorruptionTickIII | - Skill::DecayTickI | - Skill::DecayTickII | - Skill::DecayTickIII | - Skill::SiphonTickI | - Skill::SiphonTickII | - Skill::SiphonTickIII | - Skill::StrangleTickI | - Skill::StrangleTickII | - Skill::StrangleTickIII | - Skill::TriageTickI | - Skill::TriageTickII | - Skill::TriageTickIII => None, - // Triggers // ----------------- // Test // ----------------- @@ -1279,42 +760,21 @@ impl Skill { pub fn ko_castable(&self) -> bool { match self { - Skill::CorruptionTickI | - Skill::CorruptionTickII | - Skill::CorruptionTickIII | - Skill::DecayTickI | - Skill::DecayTickII | - Skill::DecayTickIII | - Skill::SiphonTickI | - Skill::SiphonTickII | - Skill::SiphonTickIII | - - Skill::TriageTickI | - Skill::TriageTickII | - Skill::TriageTickIII => true, + Skill::TriageTick => true, + Skill::DecayTick => true, + Skill::SiphonTick => true, + Skill::CorruptionTick => true, _ => false, } } pub fn is_tick(&self) -> bool { match self { - Skill::CorruptionTickI | - Skill::CorruptionTickII | - Skill::CorruptionTickIII | - Skill::DecayTickI | - Skill::DecayTickII | - Skill::DecayTickIII | - Skill::SiphonTickI | - Skill::SiphonTickII | - Skill::SiphonTickIII | - Skill::StrangleTickI | - Skill::StrangleTickII | - Skill::StrangleTickIII | - - Skill::TriageTickI | - Skill::TriageTickII | - Skill::TriageTickIII => true, - + Skill::CorruptionTick => true, + Skill::DecayTick => true, + Skill::SiphonTick => true, + Skill::StrangleTick => true, + Skill::TriageTick => true, _ => false, } } @@ -1330,27 +790,15 @@ impl Skill { Skill::TestParry => 10, Skill::TestSiphon => 10, - Skill::StrikeI => u8::max_value(), - Skill::StrikeII => Skill::StrikeI.speed(), - Skill::StrikeIII => Skill::StrikeI.speed(), + Skill::Strike => u8::max_value(), + Skill::StrikeII => Skill::Strike.speed(), + Skill::StrikeIII => Skill::Strike.speed(), - Skill::SiphonTickI | - Skill::SiphonTickII | - Skill::SiphonTickIII => Skill::SiphonI.speed(), - Skill::DecayTickI | - Skill::DecayTickII | - Skill::DecayTickIII => Skill::DecayI.speed(), - - Skill::TriageTickI | - Skill::TriageTickII | - Skill::TriageTickIII => Skill::TriageI.speed(), - - Skill::StrangleTickI | - Skill::StrangleTickII | - Skill::StrangleTickIII => Skill::StrangleI.speed(), - Skill::CorruptionTickI | - Skill::CorruptionTickII | - Skill::CorruptionTickIII => Skill::CorruptI.speed(), + Skill::SiphonTick => Skill::Siphon.speed(), + Skill::DecayTick => Skill::Decay.speed(), + Skill::TriageTick => Skill::Triage.speed(), + Skill::StrangleTick => Skill::Strangle.speed(), + Skill::CorruptionTick => Skill::Corrupt.speed(), _ => Item::from(*self).speed(), } @@ -1358,28 +806,20 @@ impl Skill { pub fn aoe(&self) -> bool { match self { - Skill::RuinI | - Skill::RuinII | - Skill::RuinIII => true, + Skill::Ruin => true, _ => false, } } pub fn self_targeting(&self) -> bool { match self { - Skill::Block | - Skill::CorruptI | - Skill::CorruptII | - Skill::CorruptIII | - Skill::ClutchI | - Skill::ClutchII | - Skill::ClutchIII | - Skill::ParryI | - Skill::ParryII | - Skill::ParryIII | - Skill::TestBlock | - Skill::TestParry => true, + Skill::Block => true, + Skill::Parry => true, + Skill::Clutch => true, + Skill::Corrupt => true, + Skill::TestBlock => true, + Skill::TestParry => true, _ => false, } } @@ -1388,50 +828,22 @@ impl Skill { let mut rng = thread_rng(); match self { - Skill::AmplifyI | - Skill::AmplifyII | - Skill::AmplifyIII | - Skill::Block | - Skill::ClutchI | - Skill::ClutchII | - Skill::ClutchIII | - Skill::CorruptI | - Skill::CorruptII | - Skill::CorruptIII | - Skill::HasteI | - Skill::HasteII | - Skill::HasteIII | - Skill::HealI | - Skill::HealII | - Skill::HealIII | - Skill::HostilityI | - Skill::HostilityII | - Skill::HostilityIII | - Skill::InvertI | - Skill::InvertII | - Skill::InvertIII | - Skill::ParryI | - Skill::ParryII | - Skill::ParryIII | - Skill::PurifyI | - Skill::PurifyII | - Skill::PurifyIII | - Skill::RechargeI | - Skill::RechargeII | - Skill::RechargeIII | - Skill::ReflectI | - Skill::ReflectII | - Skill::ReflectIII | - Skill::ScatterI | - Skill::ScatterII | - Skill::ScatterIII | - Skill::TriageI | - Skill::TriageII | - Skill::TriageIII => true, + Skill::Heal | + Skill::Triage | + Skill::Purify | + Skill::Parry | + Skill::Clutch | + Skill::Scatter | + Skill::Recharge | + Skill::Reflect | + Skill::Haste | + Skill::Invert | + Skill::Amplify | + Skill::Hostility | + Skill::Corrupt | + Skill::Block => true, - Skill::BanishI | - Skill::BanishII | - Skill::BanishIII => rng.gen_bool(0.5), + Skill::Banish => rng.gen_bool(0.5), _ => false, } @@ -1490,17 +902,17 @@ fn strike(source: &mut Construct, target: &mut Construct, mut results: Resolutio return results; } -fn injure(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions { - let amount = source.red_power().pct(skill.multiplier()); - target.deal_red_damage(skill, amount) - .into_iter() - .for_each(|e| results.push(Resolution::new(source, target).event(e))); +// fn injure(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions { +// let amount = source.red_power().pct(skill.multiplier()); +// target.deal_red_damage(skill, amount) +// .into_iter() +// .for_each(|e| results.push(Resolution::new(source, target).event(e))); - skill.effect().into_iter() - .for_each(|e| (results.push(Resolution::new(source, target).event(target.add_effect(skill, e))))); +// skill.effect().into_iter() +// .for_each(|e| (results.push(Resolution::new(source, target).event(target.add_effect(skill, e))))); - return results; -} +// return results; +// } fn stun(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions { skill.effect().into_iter() @@ -1543,17 +955,17 @@ fn throw(source: &mut Construct, target: &mut Construct, mut results: Resolution } fn strangle(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions { - let ConstructEffect { effect, duration, meta, tick: _ } = skill.effect().first().unwrap().clone(); - let tick_skill = match meta { - Some(EffectMeta::Skill(s)) => s, - _ => panic!("no strangle tick skill"), - }; - let strangle = ConstructEffect::new(effect, duration).set_tick(Cast::new_tick(source, target, tick_skill)); - results.push(Resolution::new(source, target).event(target.add_effect(skill, strangle))); - let attacker_strangle = ConstructEffect::new(Effect::Strangling, duration); - results.push(Resolution::new(source, source).event(source.add_effect(skill, attacker_strangle))); - return strangle_tick(source, target, results, tick_skill); + skill.effect().into_iter().for_each(|e| { + let ConstructEffect { effect: _, duration, meta: _, tick: _ } = e; + let strangle = e.clone().set_tick(Cast::new_tick(source, target, Skill::StrangleTick)); + results.push(Resolution::new(source, target).event(target.add_effect(skill, strangle))); + + let attacker_strangle = ConstructEffect::new(Effect::Strangling, duration); + results.push(Resolution::new(source, source).event(source.add_effect(skill, attacker_strangle))); + + }); + return strangle_tick(source, target, results, Skill::StrangleTick); } fn strangle_tick(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions { @@ -1654,19 +1066,17 @@ fn heal(source: &mut Construct, target: &mut Construct, mut results: Resolutions } fn triage(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions { - let ConstructEffect { effect, duration, meta, tick: _ } = skill.effect().first().unwrap().clone(); - let tick_skill = match meta { - Some(EffectMeta::Skill(s)) => s, - _ => panic!("no triage tick skill"), - }; - let triage = ConstructEffect::new(effect, duration).set_tick(Cast::new_tick(source, target, tick_skill)); - results.push(Resolution::new(source, target).event(target.add_effect(skill, triage))); - return triage_tick(source, target, results, tick_skill); + skill.effect().into_iter().for_each(|e| { + let triage = e.clone().set_tick(Cast::new_tick(source, target, Skill::TriageTick)); + results.push(Resolution::new(source, target).event(target.add_effect(skill, triage))); + }); + + return triage_tick(source, target, results, Skill::TriageTick); } fn triage_tick(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions { let amount = source.green_power().pct(skill.multiplier()); - target.deal_green_damage(skill, amount) + target.deal_green_damage(Skill::TriageTick, amount) .into_iter() .for_each(|e| results.push(Resolution::new(source, target).event(e))); return results; @@ -1674,13 +1084,13 @@ fn triage_tick(source: &mut Construct, target: &mut Construct, mut results: Reso fn chaos(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions { let mut rng = thread_rng(); - let b_rng: u64 = rng.gen_range(100, 130); - let amount = source.blue_power().pct(skill.multiplier()).pct(b_rng); + let b_rng: u64 = rng.gen_range(0, 30); + let amount = source.blue_power().pct(skill.multiplier() + b_rng); target.deal_blue_damage(skill, amount) .into_iter() .for_each(|e| results.push(Resolution::new(source, target).event(e))); - let r_rng: u64 = rng.gen_range(100, 130); - let amount = source.red_power().pct(skill.multiplier()).pct(r_rng); + let r_rng: u64 = rng.gen_range(0, 30); + let amount = source.red_power().pct(skill.multiplier() + r_rng); target.deal_red_damage(skill, amount) .into_iter() .for_each(|e| results.push(Resolution::new(source, target).event(e))); @@ -1715,18 +1125,17 @@ fn debuff(source: &mut Construct, target: &mut Construct, mut results: Resolutio fn decay(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions { - let wither = skill.effect().first().unwrap().clone(); - results.push(Resolution::new(source, target).event(target.add_effect(skill, wither))); + skill.effect().into_iter().for_each(|e| { + let ConstructEffect { effect, duration: _, meta: _, tick: _ } = e; + let apply_effect = match effect { + Effect::Wither => e.clone(), + Effect::Decay => e.clone().set_tick(Cast::new_tick(source, target, Skill::DecayTick)), + _ => panic!("wrong decay effects"), + }; + results.push(Resolution::new(source, target).event(target.add_effect(skill, apply_effect))); + }); - let ConstructEffect { effect, duration, meta, tick: _ } = skill.effect().last().unwrap().clone(); - let tick_skill = match meta { - Some(EffectMeta::Skill(s)) => s, - _ => panic!("no decay tick skill"), - }; - let decay = ConstructEffect::new(effect, duration).set_tick(Cast::new_tick(source, target, tick_skill)); - results.push(Resolution::new(source, target).event(target.add_effect(skill, decay))); - - return decay_tick(source, target, results, tick_skill); + return decay_tick(source, target, results, Skill::DecayTick); } fn decay_tick(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions { @@ -1746,15 +1155,11 @@ fn corrupt(source: &mut Construct, target: &mut Construct, mut results: Resoluti } fn corruption(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions { + let corruption = skill.effect().last().unwrap().clone() + .set_tick(Cast::new_tick(source, target, Skill::CorruptionTick)); - let ConstructEffect { effect, duration, meta, tick: _ } = skill.effect().first().unwrap().clone(); - let tick_skill = match meta { - Some(EffectMeta::Skill(s)) => s, - _ => panic!("no corruption tick skill"), - }; - let corruption = 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))); - return corruption_tick(source, target, results, tick_skill); + return corruption_tick(source, target, results, Skill::CorruptionTick); } fn corruption_tick(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions { @@ -1785,7 +1190,7 @@ fn hostility(source: &mut Construct, target: &mut Construct, mut results: Resolu } fn hatred(source: &mut Construct, target: &mut Construct, mut results: Resolutions, reflect_skill: Skill, amount: u64, skill: Skill) -> Resolutions { - let hatred = skill.effect().first().unwrap().clone() + let hatred = skill.effect().last().unwrap().clone() .set_meta(EffectMeta::AddedDamage(amount)); results.push(Resolution::new(source, target).event(target.add_effect(reflect_skill, hatred))); @@ -1829,26 +1234,23 @@ fn recharge(source: &mut Construct, target: &mut Construct, mut results: Resolut } fn siphon(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions { - let ConstructEffect { effect, duration, meta, tick: _ } = skill.effect().first().unwrap().clone(); - let tick_skill = match meta { - Some(EffectMeta::Skill(s)) => s, - _ => panic!("no siphon tick skill"), - }; - let siphon = ConstructEffect::new(effect, duration).set_tick(Cast::new_tick(source, target, tick_skill)); - results.push(Resolution::new(source, target).event(target.add_effect(skill, siphon))); + skill.effect().into_iter().for_each(|e| { + let siphon = e.clone().set_tick(Cast::new_tick(source, target, Skill::SiphonTick)); + results.push(Resolution::new(source, target).event(target.add_effect(skill, siphon))); + }); - return siphon_tick(source, target, results, tick_skill); + return siphon_tick(source, target, results, Skill::SiphonTick); } fn siphon_tick(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions { let amount = source.blue_power().pct(skill.multiplier()); - let siphon_events = target.deal_blue_damage(skill, amount); + let siphon_events = target.deal_blue_damage(Skill::SiphonTick, amount); for e in siphon_events { match e { Event::Damage { amount, mitigation: _, colour: _, skill: _ } => { results.push(Resolution::new(source, target).event(e)); - let heal = source.deal_green_damage(skill, amount); + let heal = source.deal_green_damage(Skill::SiphonTick, amount); for h in heal { results.push(Resolution::new(source, source).event(h)); }; @@ -1886,7 +1288,7 @@ fn scatter_hit(source: &Construct, target: &Construct, mut results: Resolutions, Colour::Green => scatter_target.deal_green_damage(skill, amount), }; - results.push(Resolution::new(target, scatter_target).event(Event::Skill { skill: Skill::ScatterI })); + results.push(Resolution::new(target, scatter_target).event(Event::Skill { skill: Skill::Scatter })); res.into_iter().for_each(|e| results.push(Resolution::new(&source, &scatter_target).event(e))); } else { panic!("not a scatter target {:?}", scatter); @@ -1958,15 +1360,15 @@ mod tests { fn heal_test() { let mut x = Construct::new() .named(&"muji".to_string()) - .learn(Skill::HealI); + .learn(Skill::Heal); let mut y = Construct::new() .named(&"camel".to_string()) - .learn(Skill::HealI); + .learn(Skill::Heal); x.deal_red_damage(Skill::Attack, 5); - heal(&mut y, &mut x, vec![], Skill::HealI); + heal(&mut y, &mut x, vec![], Skill::Heal); } #[test] @@ -1977,7 +1379,7 @@ mod tests { let mut y = Construct::new() .named(&"camel".to_string()); - decay(&mut x, &mut y, vec![], Skill::DecayI); + decay(&mut x, &mut y, vec![], Skill::Decay); assert!(y.effects.iter().any(|e| e.effect == Effect::Decay)); @@ -2020,10 +1422,10 @@ mod tests { x.red_power.force(10000000000000); // multiplication of int max will cause overflow - clutch(&mut y.clone(), &mut y, vec![], Skill::ClutchI); + clutch(&mut y.clone(), &mut y, vec![], Skill::Clutch); assert!(y.affected(Effect::Clutch)); - let mut results = hex(&mut x, &mut y, vec![], Skill::HexI); + let mut results = hex(&mut x, &mut y, vec![], Skill::Hex); let Resolution { source: _, target: _, event } = results.remove(0); match event { Event::Immunity { skill: _, immunity } => assert!(immunity.contains(&Effect::Clutch)), @@ -2040,18 +1442,18 @@ mod tests { }; } - #[test] - fn injure_test() { - let mut x = Construct::new() - .named(&"muji".to_string()); + // #[test] + // fn injure_test() { + // let mut x = Construct::new() + // .named(&"muji".to_string()); - let mut y = Construct::new() - .named(&"camel".to_string()); + // let mut y = Construct::new() + // .named(&"camel".to_string()); - resolve(Skill::Injure, &mut x, &mut y, vec![]); - assert!(y.immune(Skill::HealI).is_some()); - // resolutions = heal(&mut y.clone(), &mut y, resolutions); - } + // resolve(Skill::Injure, &mut x, &mut y, vec![]); + // assert!(y.immune(Skill::Heal).is_some()); + // // resolutions = heal(&mut y.clone(), &mut y, resolutions); + // } #[test] fn invert_test() { @@ -2065,7 +1467,7 @@ mod tests { y.red_life.force(64); y.red_life.reduce(64); x.red_power.force(256 + 64); - invert(&mut y.clone(), &mut y, vec![], Skill::InvertI); + invert(&mut y.clone(), &mut y, vec![], Skill::Invert); assert!(y.affected(Effect::Invert)); // heal should deal green damage @@ -2100,7 +1502,7 @@ mod tests { let mut y = Construct::new() .named(&"camel".to_string()); - reflect(&mut y.clone(), &mut y, vec![], Skill::ReflectI); + reflect(&mut y.clone(), &mut y, vec![], Skill::Reflect); assert!(y.affected(Effect::Reflect)); let mut results = vec![]; @@ -2131,10 +1533,10 @@ mod tests { x.green_life.reduce(512); - let mut results = resolve(Skill::SiphonI, &mut x, &mut y, vec![]); + let mut results = resolve(Skill::Siphon, &mut x, &mut y, vec![]); assert!(y.affected(Effect::Siphon)); - assert!(x.green_life() == (512 + 256.pct(Skill::SiphonTickI.multiplier()))); + assert!(x.green_life() == (512 + 256.pct(Skill::SiphonTick.multiplier()))); let Resolution { source: _, target: _, event } = results.remove(0); match event { @@ -2144,14 +1546,14 @@ mod tests { let Resolution { source: _, target: _, event } = results.remove(0); match event { - Event::Damage { amount, skill: _, mitigation: _, colour: _} => assert_eq!(amount, 256.pct(Skill::SiphonTickI.multiplier())), + Event::Damage { amount, skill: _, mitigation: _, colour: _} => assert_eq!(amount, 256.pct(Skill::SiphonTick.multiplier())), _ => panic!("not damage siphon"), }; let Resolution { source: _, target, event } = results.remove(0); match event { Event::Healing { amount, skill: _, overhealing: _ } => { - assert_eq!(amount, 256.pct(Skill::SiphonTickI.multiplier())); + assert_eq!(amount, 256.pct(Skill::SiphonTick.multiplier())); assert_eq!(target.id, x.id); }, _ => panic!("not healing"), @@ -2176,7 +1578,7 @@ mod tests { y.deal_red_damage(Skill::Attack, 5); let prev_hp = y.green_life(); - triage(&mut x, &mut y, vec![], Skill::TriageI); + triage(&mut x, &mut y, vec![], Skill::Triage); assert!(y.effects.iter().any(|e| e.effect == Effect::Triage)); assert!(y.green_life() > prev_hp); @@ -2194,9 +1596,9 @@ mod tests { y.blue_life.force(50); y.deal_red_damage(Skill::Attack, 5); - y.deal_blue_damage(Skill::BlastI, 5); + y.deal_blue_damage(Skill::Blast, 5); - let mut results = recharge(&mut x, &mut y, vec![], Skill::RechargeI); + let mut results = recharge(&mut x, &mut y, vec![], Skill::Recharge); let Resolution { source: _, target: _, event } = results.remove(0); match event { @@ -2214,9 +1616,9 @@ mod tests { let mut x = Construct::new() .named(&"muji".to_string()); - silence(&mut x.clone(), &mut x, vec![], Skill::SilenceI); + silence(&mut x.clone(), &mut x, vec![], Skill::Silence); assert!(x.effects.iter().any(|e| e.effect == Effect::Silence)); - assert!(x.disabled(Skill::SilenceI).is_some()); + assert!(x.disabled(Skill::Silence).is_some()); } #[test] @@ -2226,7 +1628,7 @@ mod tests { x.blue_power.force(50); - amplify(&mut x.clone(), &mut x, vec![], Skill::AmplifyI); + amplify(&mut x.clone(), &mut x, vec![], Skill::Amplify); assert!(x.effects.iter().any(|e| e.effect == Effect::Amplify)); assert_eq!(x.blue_power(), 75); } @@ -2236,10 +1638,10 @@ mod tests { let mut x = Construct::new() .named(&"muji".to_string()); - decay(&mut x.clone(), &mut x, vec![], Skill::DecayI); + decay(&mut x.clone(), &mut x, vec![], Skill::Decay); assert!(x.effects.iter().any(|e| e.effect == Effect::Decay)); - purify(&mut x.clone(), &mut x, vec![], Skill::PurifyI); + purify(&mut x.clone(), &mut x, vec![], Skill::Purify); assert!(!x.effects.iter().any(|e| e.effect == Effect::Decay)); } }