From c8c2d08522ba6e4368e443a8528f26fe2d204fef Mon Sep 17 00:00:00 2001 From: ntr Date: Mon, 22 Jul 2019 11:05:21 +1000 Subject: [PATCH] rename III -> ++ --- bin/deploy.sh | 2 +- client/package.json | 2 +- server/src/construct.rs | 37 +- server/src/effect.rs | 24 +- server/src/game.rs | 64 +- server/src/item.rs | 1804 +++++++++++++++++++-------------------- server/src/skill.rs | 1258 +++++++++++++-------------- server/src/spec.rs | 434 +++++----- server/src/vbox.rs | 6 +- 9 files changed, 1815 insertions(+), 1816 deletions(-) diff --git a/bin/deploy.sh b/bin/deploy.sh index 9ae5875d..e29588e6 100755 --- a/bin/deploy.sh +++ b/bin/deploy.sh @@ -17,7 +17,7 @@ ssh -q mnml ls -lah "$SERVER_BIN_DIR" # client updates echo "syncing client $VERSION" -rsync -a --delete --delete-excluded "$MNML_PATH/client/dist" mnml:"$CLIENT_DIST_DIR/$VERSION" +rsync -a --delete --delete-excluded "$MNML_PATH/client/dist/" mnml:"$CLIENT_DIST_DIR/$VERSION/" ssh -q mnml ln -nfs "$CLIENT_DIST_DIR/$VERSION" "$CLIENT_PUBLIC_DIR" ssh -q mnml ls -lah "/var/lib/mnml/public" diff --git a/client/package.json b/client/package.json index 842310a9..fbf72b65 100644 --- a/client/package.json +++ b/client/package.json @@ -21,7 +21,7 @@ "docco": "^0.7.0", "izitoast": "^1.4.0", "keymaster": "^1.6.2", - "lodash": "^4.17.11", + "lodash": "^4.17.15", "node-sass": "^4.12.0", "parcel": "^1.12.3", "preact": "^8.4.2", diff --git a/server/src/construct.rs b/server/src/construct.rs index 4d268128..0855b3af 100644 --- a/server/src/construct.rs +++ b/server/src/construct.rs @@ -48,7 +48,7 @@ pub struct ConstructSkill { pub skill: Skill, pub self_targeting: bool, pub cd: Cooldown, - // used for UI on client + // used for Uon client pub disabled: bool, } @@ -946,13 +946,12 @@ mod tests { let mut construct = Construct::new() .named(&"redboi".to_string()); - construct.learn_mut(Skill::StrikeI); - construct.spec_add(Spec::LifeGGI).unwrap(); - construct.spec_add(Spec::PowerRRI).unwrap(); - construct.spec_add(Spec::PowerRRI).unwrap(); - construct.spec_add(Spec::LifeBBI).unwrap(); + construct.learn_mut(Skill::Strike); + construct.spec_add(Spec::LifeGG).unwrap(); + construct.spec_add(Spec::PowerRR).unwrap(); + construct.spec_add(Spec::LifeBB).unwrap(); - assert_eq!(construct.colours.red, 6); + assert_eq!(construct.colours.red, 4); assert_eq!(construct.colours.green, 2); assert_eq!(construct.colours.blue, 2); @@ -964,10 +963,10 @@ mod tests { let mut construct = Construct::new() .named(&"player player".to_string()); - construct.spec_add(Spec::PowerRRI).unwrap(); - construct.spec_add(Spec::PowerGGI).unwrap(); - construct.spec_add(Spec::PowerBBI).unwrap(); - construct.learn_mut(Skill::StrikeIII); // 18 reds (24 total) + construct.spec_add(Spec::PowerRR).unwrap(); + construct.spec_add(Spec::PowerGG).unwrap(); + construct.spec_add(Spec::PowerBB).unwrap(); + construct.learn_mut(Skill::StrikePlusPlus); // 18 reds (24 total) let player_colours = Colours { red: 5, @@ -1013,9 +1012,9 @@ mod tests { let mut construct = Construct::new() .named(&"player player".to_string()); - construct.spec_add(Spec::PowerRRI).unwrap(); - construct.spec_add(Spec::PowerGGI).unwrap(); - construct.spec_add(Spec::PowerBBI).unwrap(); + construct.spec_add(Spec::PowerRR).unwrap(); + construct.spec_add(Spec::PowerGG).unwrap(); + construct.spec_add(Spec::PowerBB).unwrap(); let colours = Colours::from_construct(&construct); assert!(colours.red == 2); @@ -1023,8 +1022,8 @@ mod tests { assert!(colours.green == 2); let construct = construct - .learn(Skill::StrikeI) - .learn(Skill::BlastIII); + .learn(Skill::Strike) + .learn(Skill::BlastPlusPlus); let colours = Colours::from_construct(&construct); assert!(colours.red == 4); @@ -1037,9 +1036,9 @@ mod tests { let mut construct = Construct::new() .named(&"player player".to_string()); - construct.spec_add(Spec::PowerRRI).unwrap(); - construct.spec_add(Spec::PowerGGI).unwrap(); - construct.spec_add(Spec::PowerBBI).unwrap(); + construct.spec_add(Spec::PowerRR).unwrap(); + construct.spec_add(Spec::PowerGG).unwrap(); + construct.spec_add(Spec::PowerBB).unwrap(); let player_colours = Colours { red: 5, diff --git a/server/src/effect.rs b/server/src/effect.rs index 95079f3a..83c445d9 100644 --- a/server/src/effect.rs +++ b/server/src/effect.rs @@ -74,18 +74,18 @@ impl Effect { Effect::Banish => true, Effect::Sustain => [ Skill::Stun, - Skill::HexI, - Skill::HexII, - Skill::HexIII, - Skill::SilenceI, - Skill::SilenceII, - Skill::SilenceIII, - Skill::RuinI, - Skill::RuinII, - Skill::RuinIII, - Skill::RestrictI, - Skill::RestrictII, - Skill::RestrictIII + Skill::Hex, + Skill::HexPlus, + Skill::HexPlusPlus, + Skill::Silence, + Skill::SilencePlus, + Skill::SilencePlusPlus, + Skill::Ruin, + Skill::RuinPlus, + Skill::RuinPlusPlus, + Skill::Restrict, + Skill::RestrictPlus, + Skill::RestrictPlusPlus ].contains(&skill), _ => false, } diff --git a/server/src/game.rs b/server/src/game.rs index d557415c..8cfdaf77 100644 --- a/server/src/game.rs +++ b/server/src/game.rs @@ -854,9 +854,9 @@ mod tests { .learn(Skill::Stun) .learn(Skill::Attack) .learn(Skill::Block) - .learn(Skill::CounterI) - .learn(Skill::SiphonI) - .learn(Skill::AmplifyI) + .learn(Skill::Counter) + .learn(Skill::Siphon) + .learn(Skill::Amplify) .learn(Skill::Stun) .learn(Skill::Block); @@ -866,9 +866,9 @@ mod tests { .learn(Skill::Stun) .learn(Skill::Attack) .learn(Skill::Block) - .learn(Skill::CounterI) - .learn(Skill::SiphonI) - .learn(Skill::AmplifyI) + .learn(Skill::Counter) + .learn(Skill::Siphon) + .learn(Skill::Amplify) .learn(Skill::Stun) .learn(Skill::Block); @@ -1087,11 +1087,11 @@ mod tests { game.construct_by_id(y_construct.id).unwrap().reduce_cooldowns(); } - while game.construct_by_id(x_construct.id).unwrap().skill_on_cd(Skill::CounterI).is_some() { + while game.construct_by_id(x_construct.id).unwrap().skill_on_cd(Skill::Counter).is_some() { game.construct_by_id(x_construct.id).unwrap().reduce_cooldowns(); } - game.add_skill(x_player.id, x_construct.id, None, Skill::CounterI).unwrap(); + game.add_skill(x_player.id, x_construct.id, None, Skill::Counter).unwrap(); game.add_skill(y_player.id, y_construct.id, Some(x_construct.id), Skill::Stun).unwrap(); game.player_ready(x_player.id).unwrap(); @@ -1102,7 +1102,7 @@ mod tests { // should not be stunned because of counter assert!(game.player_by_id(x_player.id).unwrap().constructs[0].is_stunned() == false); // riposte - assert_eq!(game.player_by_id(y_player.id).unwrap().constructs[0].green_life(), (1024 - x_construct.red_power().pct(Skill::CounterAttackI.multiplier()))); + assert_eq!(game.player_by_id(y_player.id).unwrap().constructs[0].green_life(), (1024 - x_construct.red_power().pct(Skill::CounterAttack.multiplier()))); } #[test] @@ -1115,14 +1115,14 @@ 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::ElectrifyI); + game.construct_by_id(x_construct.id).unwrap().learn_mut(Skill::Electrify); - while game.construct_by_id(x_construct.id).unwrap().skill_on_cd(Skill::ElectrifyI).is_some() { + while game.construct_by_id(x_construct.id).unwrap().skill_on_cd(Skill::Electrify).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::ElectrifyI).unwrap(); + game.add_skill(x_player.id, x_construct.id, Some(x_construct.id), Skill::Electrify).unwrap(); game.player_ready(x_player.id).unwrap(); game.player_ready(y_player.id).unwrap(); game = game.resolve_phase_start(); @@ -1147,14 +1147,14 @@ 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::LinkI); + game.construct_by_id(x_construct.id).unwrap().learn_mut(Skill::Link); - while game.construct_by_id(x_construct.id).unwrap().skill_on_cd(Skill::LinkI).is_some() { + while game.construct_by_id(x_construct.id).unwrap().skill_on_cd(Skill::Link).is_some() { game.construct_by_id(x_construct.id).unwrap().reduce_cooldowns(); } // apply buff - game.add_skill(x_player.id, x_construct.id, Some(y_construct.id), Skill::LinkI).unwrap(); + game.add_skill(x_player.id, x_construct.id, Some(y_construct.id), Skill::Link).unwrap(); game.player_ready(x_player.id).unwrap(); game.player_ready(y_player.id).unwrap(); game = game.resolve_phase_start(); @@ -1232,15 +1232,15 @@ mod tests { let x_construct = x_player.constructs[0].clone(); let y_construct = x_player.constructs[1].clone(); - game.construct_by_id(x_construct.id).unwrap().learn_mut(Skill::RuinI); + game.construct_by_id(x_construct.id).unwrap().learn_mut(Skill::Ruin); - while game.construct_by_id(x_construct.id).unwrap().skill_on_cd(Skill::RuinI).is_some() { + while game.construct_by_id(x_construct.id).unwrap().skill_on_cd(Skill::Ruin).is_some() { game.construct_by_id(x_construct.id).unwrap().reduce_cooldowns(); } game.add_skill(i_player.id, i_construct.id, Some(x_construct.id), Skill::Attack).unwrap(); game.add_skill(i_player.id, j_construct.id, Some(x_construct.id), Skill::Attack).unwrap(); - game.add_skill(x_player.id, x_construct.id, Some(i_construct.id), Skill::RuinI).unwrap(); + game.add_skill(x_player.id, x_construct.id, Some(i_construct.id), Skill::Ruin).unwrap(); game.add_skill(x_player.id, y_construct.id, Some(i_construct.id), Skill::Attack).unwrap(); game.player_ready(i_player.id).unwrap(); @@ -1282,15 +1282,15 @@ mod tests { let x_construct = x_player.constructs[0].clone(); let y_construct = x_player.constructs[1].clone(); - game.construct_by_id(x_construct.id).unwrap().learn_mut(Skill::InterceptI); + game.construct_by_id(x_construct.id).unwrap().learn_mut(Skill::Intercept); - while game.construct_by_id(x_construct.id).unwrap().skill_on_cd(Skill::InterceptI).is_some() { + while game.construct_by_id(x_construct.id).unwrap().skill_on_cd(Skill::Intercept).is_some() { game.construct_by_id(x_construct.id).unwrap().reduce_cooldowns(); } game.add_skill(i_player.id, i_construct.id, Some(x_construct.id), Skill::Attack).unwrap(); game.add_skill(i_player.id, j_construct.id, Some(x_construct.id), Skill::Attack).unwrap(); - game.add_skill(x_player.id, x_construct.id, Some(i_construct.id), Skill::InterceptI).unwrap(); + game.add_skill(x_player.id, x_construct.id, Some(i_construct.id), Skill::Intercept).unwrap(); game.add_skill(x_player.id, y_construct.id, Some(i_construct.id), Skill::Attack).unwrap(); game.player_ready(i_player.id).unwrap(); @@ -1367,23 +1367,23 @@ mod tests { // make the purify construct super fast so it beats out decay game.construct_by_id(y_construct.id).unwrap().speed.force(10000000); - game.construct_by_id(x_construct.id).unwrap().learn_mut(Skill::DecayI); - while game.construct_by_id(x_construct.id).unwrap().skill_on_cd(Skill::DecayI).is_some() { + game.construct_by_id(x_construct.id).unwrap().learn_mut(Skill::Decay); + while game.construct_by_id(x_construct.id).unwrap().skill_on_cd(Skill::Decay).is_some() { game.construct_by_id(x_construct.id).unwrap().reduce_cooldowns(); } - game.construct_by_id(x_construct.id).unwrap().learn_mut(Skill::SiphonI); - while game.construct_by_id(x_construct.id).unwrap().skill_on_cd(Skill::SiphonI).is_some() { + game.construct_by_id(x_construct.id).unwrap().learn_mut(Skill::Siphon); + while game.construct_by_id(x_construct.id).unwrap().skill_on_cd(Skill::Siphon).is_some() { game.construct_by_id(x_construct.id).unwrap().reduce_cooldowns(); } - game.construct_by_id(y_construct.id).unwrap().learn_mut(Skill::PurifyI); - while game.construct_by_id(y_construct.id).unwrap().skill_on_cd(Skill::PurifyI).is_some() { + game.construct_by_id(y_construct.id).unwrap().learn_mut(Skill::Purify); + while game.construct_by_id(y_construct.id).unwrap().skill_on_cd(Skill::Purify).is_some() { game.construct_by_id(y_construct.id).unwrap().reduce_cooldowns(); } // apply buff - game.add_skill(x_player.id, x_construct.id, Some(y_construct.id), Skill::DecayI).unwrap(); + game.add_skill(x_player.id, x_construct.id, Some(y_construct.id), Skill::Decay).unwrap(); game.player_ready(x_player.id).unwrap(); game.player_ready(y_player.id).unwrap(); game = game.resolve_phase_start(); @@ -1391,14 +1391,14 @@ mod tests { let Resolution { source: _, target: _, event, stages: _ } = game.resolved.pop().unwrap(); match event { - Event::Damage { amount: _, skill, mitigation: _, colour: _ } => assert_eq!(skill, Skill::DecayTickI), + Event::Damage { amount: _, skill, mitigation: _, colour: _ } => assert_eq!(skill, Skill::DecayTick), _ => panic!("not decay"), }; game.resolved.clear(); // remove - game.add_skill(y_player.id, y_construct.id, Some(y_construct.id), Skill::PurifyI).unwrap(); + game.add_skill(y_player.id, y_construct.id, Some(y_construct.id), Skill::Purify).unwrap(); game.player_ready(x_player.id).unwrap(); game.player_ready(y_player.id).unwrap(); game = game.resolve_phase_start(); @@ -1411,14 +1411,14 @@ mod tests { } }; - game.add_skill(y_player.id, x_construct.id, Some(y_construct.id), Skill::SiphonI).unwrap(); + game.add_skill(y_player.id, x_construct.id, Some(y_construct.id), Skill::Siphon).unwrap(); game.player_ready(x_player.id).unwrap(); game.player_ready(y_player.id).unwrap(); game = game.resolve_phase_start(); game.resolved.clear(); - game.add_skill(y_player.id, y_construct.id, Some(y_construct.id), Skill::PurifyI).unwrap(); + game.add_skill(y_player.id, y_construct.id, Some(y_construct.id), Skill::Purify).unwrap(); game.player_ready(x_player.id).unwrap(); game.player_ready(y_player.id).unwrap(); game = game.resolve_phase_start(); diff --git a/server/src/item.rs b/server/src/item.rs index 39a3006e..1d050587 100644 --- a/server/src/item.rs +++ b/server/src/item.rs @@ -24,160 +24,160 @@ pub enum Item { Speed, // Lifes Upgrades - LifeGGI, - LifeRRI, - LifeBBI, - LifeRGI, - LifeGBI, - LifeRBI, - LifeGGII, - LifeRRII, - LifeBBII, - LifeRGII, - LifeGBII, - LifeRBII, - LifeGGIII, - LifeRRIII, - LifeBBIII, - LifeRGIII, - LifeGBIII, - LifeRBIII, + LifeGG, + LifeRR, + LifeBB, + LifeRG, + LifeGB, + LifeRB, + LifeGGPlus, + LifeRRPlus, + LifeBBPlus, + LifeRGPlus, + LifeGBPlus, + LifeRBPlus, + LifeGGPlusPlus, + LifeRRPlusPlus, + LifeBBPlusPlus, + LifeRGPlusPlus, + LifeGBPlusPlus, + LifeRBPlusPlus, // Power Upgrades - PowerRRI, - PowerBBI, - PowerGGI, - PowerRGI, - PowerGBI, - PowerRBI, - PowerRRII, - PowerGGII, - PowerBBII, - PowerRGII, - PowerGBII, - PowerRBII, - PowerRRIII, - PowerBBIII, - PowerGGIII, - PowerRGIII, - PowerGBIII, - PowerRBIII, + PowerRR, + PowerBB, + PowerGG, + PowerRG, + PowerGB, + PowerRB, + PowerRRPlus, + PowerGGPlus, + PowerBBPlus, + PowerRGPlus, + PowerGBPlus, + PowerRBPlus, + PowerRRPlusPlus, + PowerBBPlusPlus, + PowerGGPlusPlus, + PowerRGPlusPlus, + PowerGBPlusPlus, + PowerRBPlusPlus, // Speed Upgrades - SpeedRRI, - SpeedBBI, - SpeedGGI, - SpeedRGI, - SpeedGBI, - SpeedRBI, + SpeedRR, + SpeedBB, + SpeedGG, + SpeedRG, + SpeedGB, + SpeedRB, - SpeedRRII, - SpeedBBII, - SpeedGGII, - SpeedRGII, - SpeedGBII, - SpeedRBII, + SpeedRRPlus, + SpeedBBPlus, + SpeedGGPlus, + SpeedRGPlus, + SpeedGBPlus, + SpeedRBPlus, - SpeedRRIII, - SpeedBBIII, - SpeedGGIII, - SpeedRGIII, - SpeedGBIII, - SpeedRBIII, + SpeedRRPlusPlus, + SpeedBBPlusPlus, + SpeedGGPlusPlus, + SpeedRGPlusPlus, + SpeedGBPlusPlus, + SpeedRBPlusPlus, - AmplifyI, - AmplifyII, - AmplifyIII, - AbsorbI, - AbsorbII, - AbsorbIII, - BanishI, - BanishII, - BanishIII, - BashI, - BashII, - BashIII, - BlastI, - BlastII, - BlastIII, - ChaosI, - ChaosII, - ChaosIII, - SustainI, - SustainII, - SustainIII, - ElectrifyI, - ElectrifyII, - ElectrifyIII, - CurseI, - CurseII, - CurseIII, - DecayI, - DecayII, - DecayIII, - HexI, - HexII, - HexIII, - HasteI, - HasteII, - HasteIII, - HealI, - HealII, - HealIII, - HybridI, - HybridII, - HybridIII, - InvertI, - InvertII, - InvertIII, - CounterI, - CounterII, - CounterIII, - PurgeI, - PurgeII, - PurgeIII, - PurifyI, - PurifyII, - PurifyIII, - ReflectI, - ReflectII, - ReflectIII, - RechargeI, - RechargeII, - RechargeIII, - RuinI, - RuinII, - RuinIII, - LinkI, - LinkII, - LinkIII, - SilenceI, - SilenceII, - SilenceIII, - SlayI, - SlayII, - SlayIII, - SleepI, - SleepII, - SleepIII, - RestrictI, - RestrictII, - RestrictIII, - StrikeI, - StrikeII, - StrikeIII, - SiphonI, - SiphonII, - SiphonIII, - InterceptI, - InterceptII, - InterceptIII, - BreakI, - BreakII, - BreakIII, - TriageI, - TriageII, - TriageIII, + Amplify, + AmplifyPlus, + AmplifyPlusPlus, + Absorb, + AbsorbPlus, + AbsorbPlusPlus, + Banish, + BanishPlus, + BanishPlusPlus, + Bash, + BashPlus, + BashPlusPlus, + Blast, + BlastPlus, + BlastPlusPlus, + Chaos, + ChaosPlus, + ChaosPlusPlus, + Sustain, + SustainPlus, + SustainPlusPlus, + Electrify, + ElectrifyPlus, + ElectrifyPlusPlus, + Curse, + CursePlus, + CursePlusPlus, + Decay, + DecayPlus, + DecayPlusPlus, + Hex, + HexPlus, + HexPlusPlus, + Haste, + HastePlus, + HastePlusPlus, + Heal, + HealPlus, + HealPlusPlus, + Hybrid, + HybridPlus, + HybridPlusPlus, + Invert, + InvertPlus, + InvertPlusPlus, + Counter, + CounterPlus, + CounterPlusPlus, + Purge, + PurgePlus, + PurgePlusPlus, + Purify, + PurifyPlus, + PurifyPlusPlus, + Reflect, + ReflectPlus, + ReflectPlusPlus, + Recharge, + RechargePlus, + RechargePlusPlus, + Ruin, + RuinPlus, + RuinPlusPlus, + Link, + LinkPlus, + LinkPlusPlus, + Silence, + SilencePlus, + SilencePlusPlus, + Slay, + SlayPlus, + SlayPlusPlus, + Sleep, + SleepPlus, + SleepPlusPlus, + Restrict, + RestrictPlus, + RestrictPlusPlus, + Strike, + StrikePlus, + StrikePlusPlus, + Siphon, + SiphonPlus, + SiphonPlusPlus, + Intercept, + InterceptPlus, + InterceptPlusPlus, + Break, + BreakPlus, + BreakPlusPlus, + Triage, + TriagePlus, + TriagePlusPlus, } pub enum ItemEffect { @@ -295,101 +295,101 @@ impl Item { pub fn into_skill(&self) -> Option { match self { - Item::AbsorbI => Some(Skill::AbsorbI), - Item::AbsorbII => Some(Skill::AbsorbII), - Item::AbsorbIII => Some(Skill::AbsorbIII), - Item::AmplifyI => Some(Skill::AmplifyI), - Item::AmplifyII => Some(Skill::AmplifyII), - Item::AmplifyIII => Some(Skill::AmplifyIII), + Item::Absorb => Some(Skill::Absorb), + Item::AbsorbPlus => Some(Skill::AbsorbPlus), + Item::AbsorbPlusPlus => Some(Skill::AbsorbPlusPlus), + Item::Amplify => Some(Skill::Amplify), + Item::AmplifyPlus => Some(Skill::AmplifyPlus), + Item::AmplifyPlusPlus => Some(Skill::AmplifyPlusPlus), Item::Attack => Some(Skill::Attack), - Item::BanishI => Some(Skill::BanishI), - Item::BanishII => Some(Skill::BanishII), - Item::BanishIII => Some(Skill::BanishIII), - Item::BashI => Some(Skill::BashI), - Item::BashII => Some(Skill::BashII), - Item::BashIII => Some(Skill::BashIII), - Item::BlastI => Some(Skill::BlastI), - Item::BlastII => Some(Skill::BlastII), - Item::BlastIII => Some(Skill::BlastIII), + Item::Banish => Some(Skill::Banish), + Item::BanishPlus => Some(Skill::BanishPlus), + Item::BanishPlusPlus => Some(Skill::BanishPlusPlus), + Item::Bash => Some(Skill::Bash), + Item::BashPlus => Some(Skill::BashPlus), + Item::BashPlusPlus => Some(Skill::BashPlusPlus), + Item::Blast => Some(Skill::Blast), + Item::BlastPlus => Some(Skill::BlastPlus), + Item::BlastPlusPlus => Some(Skill::BlastPlusPlus), Item::Block => Some(Skill::Block), Item::Buff => Some(Skill::Buff), - Item::ChaosI => Some(Skill::ChaosI), - Item::ChaosII => Some(Skill::ChaosII), - Item::ChaosIII => Some(Skill::ChaosIII), - Item::CounterI => Some(Skill::CounterI), - Item::CounterII => Some(Skill::CounterII), - Item::CounterIII => Some(Skill::CounterIII), - Item::CurseI => Some(Skill::CurseI), - Item::CurseII => Some(Skill::CurseII), - Item::CurseIII => Some(Skill::CurseIII), + Item::Chaos => Some(Skill::Chaos), + Item::ChaosPlus => Some(Skill::ChaosPlus), + Item::ChaosPlusPlus => Some(Skill::ChaosPlusPlus), + Item::Counter => Some(Skill::Counter), + Item::CounterPlus => Some(Skill::CounterPlus), + Item::CounterPlusPlus => Some(Skill::CounterPlusPlus), + Item::Curse => Some(Skill::Curse), + Item::CursePlus => Some(Skill::CursePlus), + Item::CursePlusPlus => Some(Skill::CursePlusPlus), Item::Debuff => Some(Skill::Debuff), - Item::DecayI => Some(Skill::DecayI), - Item::DecayII => Some(Skill::DecayII), - Item::DecayIII => Some(Skill::DecayIII), - Item::ElectrifyI => Some(Skill::ElectrifyI), - Item::ElectrifyII => Some(Skill::ElectrifyII), - Item::ElectrifyIII => Some(Skill::ElectrifyIII), - Item::HasteI => Some(Skill::HasteI), - Item::HasteII => Some(Skill::HasteII), - Item::HasteIII => Some(Skill::HasteIII), - Item::HealI => Some(Skill::HealI), - Item::HealII => Some(Skill::HealII), - Item::HealIII => Some(Skill::HealIII), - Item::HybridI => Some(Skill::HybridI), - Item::HybridII => Some(Skill::HybridII), - Item::HybridIII => Some(Skill::HybridIII), - Item::InterceptI => Some(Skill::InterceptI), - Item::InterceptII => Some(Skill::InterceptII), - Item::InterceptIII => Some(Skill::InterceptIII), - Item::InvertI => Some(Skill::InvertI), - Item::InvertII => Some(Skill::InvertII), - Item::InvertIII => Some(Skill::InvertIII), - Item::PurgeI => Some(Skill::PurgeI), - Item::PurgeII => Some(Skill::PurgeII), - Item::PurgeIII => Some(Skill::PurgeIII), - Item::PurifyI => Some(Skill::PurifyI), - Item::PurifyII => Some(Skill::PurifyII), - Item::PurifyIII => Some(Skill::PurifyIII), - Item::RechargeI => Some(Skill::RechargeI), - Item::RechargeII => Some(Skill::RechargeII), - Item::RechargeIII => Some(Skill::RechargeIII), - Item::ReflectI => Some(Skill::ReflectI), - Item::ReflectII => Some(Skill::ReflectII), - Item::ReflectIII => Some(Skill::ReflectIII), - Item::RestrictI => Some(Skill::RestrictI), - Item::RestrictII => Some(Skill::RestrictII), - Item::RestrictIII => Some(Skill::RestrictIII), - Item::RuinI => Some(Skill::RuinI), - Item::RuinII => Some(Skill::RuinII), - Item::RuinIII => Some(Skill::RuinIII), - Item::LinkI => Some(Skill::LinkI), - Item::LinkII => Some(Skill::LinkII), - Item::LinkIII => Some(Skill::LinkIII), - Item::SilenceI => Some(Skill::SilenceI), - Item::SilenceII => Some(Skill::SilenceII), - Item::SilenceIII => Some(Skill::SilenceIII), - Item::SiphonI => Some(Skill::SiphonI), - Item::SiphonII => Some(Skill::SiphonII), - Item::SiphonIII => Some(Skill::SiphonIII), - Item::SlayI => Some(Skill::SlayI), - Item::SlayII => Some(Skill::SlayII), - Item::SlayIII => Some(Skill::SlayIII), - Item::SleepI => Some(Skill::SleepI), - Item::SleepII => Some(Skill::SleepII), - Item::SleepIII => Some(Skill::SleepIII), - Item::StrikeI => Some(Skill::StrikeI), - Item::StrikeII => Some(Skill::StrikeII), - Item::StrikeIII => Some(Skill::StrikeIII), + Item::Decay => Some(Skill::Decay), + Item::DecayPlus => Some(Skill::DecayPlus), + Item::DecayPlusPlus => Some(Skill::DecayPlusPlus), + Item::Electrify => Some(Skill::Electrify), + Item::ElectrifyPlus => Some(Skill::ElectrifyPlus), + Item::ElectrifyPlusPlus => Some(Skill::ElectrifyPlusPlus), + Item::Haste => Some(Skill::Haste), + Item::HastePlus => Some(Skill::HastePlus), + Item::HastePlusPlus => Some(Skill::HastePlusPlus), + Item::Heal => Some(Skill::Heal), + Item::HealPlus => Some(Skill::HealPlus), + Item::HealPlusPlus => Some(Skill::HealPlusPlus), + Item::Hybrid => Some(Skill::Hybrid), + Item::HybridPlus => Some(Skill::HybridPlus), + Item::HybridPlusPlus => Some(Skill::HybridPlusPlus), + Item::Intercept => Some(Skill::Intercept), + Item::InterceptPlus => Some(Skill::InterceptPlus), + Item::InterceptPlusPlus => Some(Skill::InterceptPlusPlus), + Item::Invert => Some(Skill::Invert), + Item::InvertPlus => Some(Skill::InvertPlus), + Item::InvertPlusPlus => Some(Skill::InvertPlusPlus), + Item::Purge => Some(Skill::Purge), + Item::PurgePlus => Some(Skill::PurgePlus), + Item::PurgePlusPlus => Some(Skill::PurgePlusPlus), + Item::Purify => Some(Skill::Purify), + Item::PurifyPlus => Some(Skill::PurifyPlus), + Item::PurifyPlusPlus => Some(Skill::PurifyPlusPlus), + Item::Recharge => Some(Skill::Recharge), + Item::RechargePlus => Some(Skill::RechargePlus), + Item::RechargePlusPlus => Some(Skill::RechargePlusPlus), + Item::Reflect => Some(Skill::Reflect), + Item::ReflectPlus => Some(Skill::ReflectPlus), + Item::ReflectPlusPlus => Some(Skill::ReflectPlusPlus), + Item::Restrict => Some(Skill::Restrict), + Item::RestrictPlus => Some(Skill::RestrictPlus), + Item::RestrictPlusPlus => Some(Skill::RestrictPlusPlus), + Item::Ruin => Some(Skill::Ruin), + Item::RuinPlus => Some(Skill::RuinPlus), + Item::RuinPlusPlus => Some(Skill::RuinPlusPlus), + Item::Link => Some(Skill::Link), + Item::LinkPlus => Some(Skill::LinkPlus), + Item::LinkPlusPlus => Some(Skill::LinkPlusPlus), + Item::Silence => Some(Skill::Silence), + Item::SilencePlus => Some(Skill::SilencePlus), + Item::SilencePlusPlus => Some(Skill::SilencePlusPlus), + Item::Siphon => Some(Skill::Siphon), + Item::SiphonPlus => Some(Skill::SiphonPlus), + Item::SiphonPlusPlus => Some(Skill::SiphonPlusPlus), + Item::Slay => Some(Skill::Slay), + Item::SlayPlus => Some(Skill::SlayPlus), + Item::SlayPlusPlus => Some(Skill::SlayPlusPlus), + Item::Sleep => Some(Skill::Sleep), + Item::SleepPlus => Some(Skill::SleepPlus), + Item::SleepPlusPlus => Some(Skill::SleepPlusPlus), + Item::Strike => Some(Skill::Strike), + Item::StrikePlus => Some(Skill::StrikePlus), + Item::StrikePlusPlus => Some(Skill::StrikePlusPlus), Item::Stun => Some(Skill::Stun), - Item::SustainI => Some(Skill::SustainI), - Item::SustainII => Some(Skill::SustainII), - Item::SustainIII => Some(Skill::SustainIII), - Item::BreakI => Some(Skill::BreakI), - Item::BreakII => Some(Skill::BreakII), - Item::BreakIII => Some(Skill::BreakIII), - Item::TriageI => Some(Skill::TriageI), - Item::TriageII => Some(Skill::TriageII), - Item::TriageIII => Some(Skill::TriageIII), + Item::Sustain => Some(Skill::Sustain), + Item::SustainPlus => Some(Skill::SustainPlus), + Item::SustainPlusPlus => Some(Skill::SustainPlusPlus), + Item::Break => Some(Skill::Break), + Item::BreakPlus => Some(Skill::BreakPlus), + Item::BreakPlusPlus => Some(Skill::BreakPlusPlus), + Item::Triage => Some(Skill::Triage), + Item::TriagePlus => Some(Skill::TriagePlus), + Item::TriagePlusPlus => Some(Skill::TriagePlusPlus), _ => None, } } @@ -397,66 +397,66 @@ impl Item { pub fn into_spec(&self) -> Option { match *self { Item::Speed => Some(Spec::Speed), - Item::SpeedRRI => Some(Spec::SpeedRRI), - Item::SpeedBBI => Some(Spec::SpeedBBI), - Item::SpeedGGI => Some(Spec::SpeedGGI), - Item::SpeedRGI => Some(Spec::SpeedRGI), - Item::SpeedGBI => Some(Spec::SpeedGBI), - Item::SpeedRBI => Some(Spec::SpeedRBI), + Item::SpeedRR => Some(Spec::SpeedRR), + Item::SpeedBB => Some(Spec::SpeedBB), + Item::SpeedGG => Some(Spec::SpeedGG), + Item::SpeedRG => Some(Spec::SpeedRG), + Item::SpeedGB => Some(Spec::SpeedGB), + Item::SpeedRB => Some(Spec::SpeedRB), - Item::SpeedRRII => Some(Spec::SpeedRRII), - Item::SpeedBBII => Some(Spec::SpeedBBII), - Item::SpeedGGII => Some(Spec::SpeedGGII), - Item::SpeedRGII => Some(Spec::SpeedRGII), - Item::SpeedGBII => Some(Spec::SpeedGBII), - Item::SpeedRBII => Some(Spec::SpeedRBII), + Item::SpeedRRPlus => Some(Spec::SpeedRRPlus), + Item::SpeedBBPlus => Some(Spec::SpeedBBPlus), + Item::SpeedGGPlus => Some(Spec::SpeedGGPlus), + Item::SpeedRGPlus => Some(Spec::SpeedRGPlus), + Item::SpeedGBPlus => Some(Spec::SpeedGBPlus), + Item::SpeedRBPlus => Some(Spec::SpeedRBPlus), - Item::SpeedRRIII => Some(Spec::SpeedRRIII), - Item::SpeedBBIII => Some(Spec::SpeedBBIII), - Item::SpeedGGIII => Some(Spec::SpeedGGIII), - Item::SpeedRGIII => Some(Spec::SpeedRGIII), - Item::SpeedGBIII => Some(Spec::SpeedGBIII), - Item::SpeedRBIII => Some(Spec::SpeedRBIII), + Item::SpeedRRPlusPlus => Some(Spec::SpeedRRPlusPlus), + Item::SpeedBBPlusPlus => Some(Spec::SpeedBBPlusPlus), + Item::SpeedGGPlusPlus => Some(Spec::SpeedGGPlusPlus), + Item::SpeedRGPlusPlus => Some(Spec::SpeedRGPlusPlus), + Item::SpeedGBPlusPlus => Some(Spec::SpeedGBPlusPlus), + Item::SpeedRBPlusPlus => Some(Spec::SpeedRBPlusPlus), Item::Power => Some(Spec::Power), - Item::PowerRRI => Some(Spec::PowerRRI), - Item::PowerBBI => Some(Spec::PowerBBI), - Item::PowerGGI => Some(Spec::PowerGGI), - Item::PowerRGI => Some(Spec::PowerRGI), - Item::PowerGBI => Some(Spec::PowerGBI), - Item::PowerRBI => Some(Spec::PowerRBI), - Item::PowerRRII => Some(Spec::PowerRRII), - Item::PowerBBII => Some(Spec::PowerBBII), - Item::PowerGGII => Some(Spec::PowerGGII), - Item::PowerRGII => Some(Spec::PowerRGII), - Item::PowerGBII => Some(Spec::PowerGBII), - Item::PowerRBII => Some(Spec::PowerRBII), - Item::PowerRRIII => Some(Spec::PowerRRIII), - Item::PowerBBIII => Some(Spec::PowerBBIII), - Item::PowerGGIII => Some(Spec::PowerGGIII), - Item::PowerRGIII => Some(Spec::PowerRGIII), - Item::PowerGBIII => Some(Spec::PowerGBIII), - Item::PowerRBIII => Some(Spec::PowerRBIII), + Item::PowerRR => Some(Spec::PowerRR), + Item::PowerBB => Some(Spec::PowerBB), + Item::PowerGG => Some(Spec::PowerGG), + Item::PowerRG => Some(Spec::PowerRG), + Item::PowerGB => Some(Spec::PowerGB), + Item::PowerRB => Some(Spec::PowerRB), + Item::PowerRRPlus => Some(Spec::PowerRRPlus), + Item::PowerBBPlus => Some(Spec::PowerBBPlus), + Item::PowerGGPlus => Some(Spec::PowerGGPlus), + Item::PowerRGPlus => Some(Spec::PowerRGPlus), + Item::PowerGBPlus => Some(Spec::PowerGBPlus), + Item::PowerRBPlus => Some(Spec::PowerRBPlus), + Item::PowerRRPlusPlus => Some(Spec::PowerRRPlusPlus), + Item::PowerBBPlusPlus => Some(Spec::PowerBBPlusPlus), + Item::PowerGGPlusPlus => Some(Spec::PowerGGPlusPlus), + Item::PowerRGPlusPlus => Some(Spec::PowerRGPlusPlus), + Item::PowerGBPlusPlus => Some(Spec::PowerGBPlusPlus), + Item::PowerRBPlusPlus => Some(Spec::PowerRBPlusPlus), Item::Life => Some(Spec::Life), - Item::LifeRGI => Some(Spec::LifeRGI), - Item::LifeGBI => Some(Spec::LifeGBI), - Item::LifeRBI => Some(Spec::LifeRBI), - Item::LifeGGI => Some(Spec::LifeGGI), - Item::LifeRRI => Some(Spec::LifeRRI), - Item::LifeBBI => Some(Spec::LifeBBI), - Item::LifeRGII => Some(Spec::LifeRGII), - Item::LifeGBII => Some(Spec::LifeGBII), - Item::LifeRBII => Some(Spec::LifeRBII), - Item::LifeGGII => Some(Spec::LifeGGII), - Item::LifeRRII => Some(Spec::LifeRRII), - Item::LifeBBII => Some(Spec::LifeBBII), - Item::LifeRGIII => Some(Spec::LifeRGIII), - Item::LifeGBIII => Some(Spec::LifeGBIII), - Item::LifeRBIII => Some(Spec::LifeRBIII), - Item::LifeGGIII => Some(Spec::LifeGGIII), - Item::LifeRRIII => Some(Spec::LifeRRIII), - Item::LifeBBIII => Some(Spec::LifeBBIII), + Item::LifeRG => Some(Spec::LifeRG), + Item::LifeGB => Some(Spec::LifeGB), + Item::LifeRB => Some(Spec::LifeRB), + Item::LifeGG => Some(Spec::LifeGG), + Item::LifeRR => Some(Spec::LifeRR), + Item::LifeBB => Some(Spec::LifeBB), + Item::LifeRGPlus => Some(Spec::LifeRGPlus), + Item::LifeGBPlus => Some(Spec::LifeGBPlus), + Item::LifeRBPlus => Some(Spec::LifeRBPlus), + Item::LifeGGPlus => Some(Spec::LifeGGPlus), + Item::LifeRRPlus => Some(Spec::LifeRRPlus), + Item::LifeBBPlus => Some(Spec::LifeBBPlus), + Item::LifeRGPlusPlus => Some(Spec::LifeRGPlusPlus), + Item::LifeGBPlusPlus => Some(Spec::LifeGBPlusPlus), + Item::LifeRBPlusPlus => Some(Spec::LifeRBPlusPlus), + Item::LifeGGPlusPlus => Some(Spec::LifeGGPlusPlus), + Item::LifeRRPlusPlus => Some(Spec::LifeRRPlusPlus), + Item::LifeBBPlusPlus => Some(Spec::LifeBBPlusPlus), _ => None, } @@ -501,281 +501,281 @@ impl Item { Some SKILLS (such as STRIKE) have their damage increased by SPEED."), // Lifes Upgrades - Item::LifeGGI => format!("Increases CONSTRUCT GreenLife. + Item::LifeGG=> format!("Increases CONSTRUCT GreenLife. When your CONSTRUCT reaches 0 GreenLife it becomes KO and cannot cast SKILLS."), - Item::LifeRRI => format!("Increases CONSTRUCT RedLife. + Item::LifeRR=> format!("Increases CONSTRUCT RedLife. RedDamage dealt to your construct reduces RedLife before GreenLife."), - Item::LifeBBI => format!("Increases CONSTRUCT BlueLife. + Item::LifeBB=> format!("Increases CONSTRUCT BlueLife. BlueDamage dealt to your construct reduces BlueLife before GreenLife."), - Item::LifeRGI => format!("Increases CONSTRUCT GreenLife + RedLife"), - Item::LifeGBI => format!("Increases CONSTRUCT GreenLife + BlueLife"), - Item::LifeRBI => format!("Increases CONSTRUCT RedLife + BlueLife"), - Item::LifeGGII => format!("Increases CONSTRUCT GreenLife. + Item::LifeRG=> format!("Increases CONSTRUCT GreenLife + RedLife"), + Item::LifeGB=> format!("Increases CONSTRUCT GreenLife + BlueLife"), + Item::LifeRB=> format!("Increases CONSTRUCT RedLife + BlueLife"), + Item::LifeGGPlus => format!("Increases CONSTRUCT GreenLife. When your CONSTRUCT reaches 0 GreenLife it becomes KO and cannot cast SKILLS."), - Item::LifeRRII => format!("Increases CONSTRUCT RedLife. + Item::LifeRRPlus => format!("Increases CONSTRUCT RedLife. RedDamage dealt to your construct reduces RedLife before GreenLife."), - Item::LifeBBII => format!("Increases CONSTRUCT BlueLife. + Item::LifeBBPlus => format!("Increases CONSTRUCT BlueLife. BlueDamage dealt to your construct reduces BlueLife before GreenLife."), - Item::LifeRGII => format!("Increases CONSTRUCT GreenLife + RedLife"), - Item::LifeGBII => format!("Increases CONSTRUCT GreenLife + BlueLife"), - Item::LifeRBII => format!("Increases CONSTRUCT RedLife + BlueLife"), - Item::LifeGGIII => format!("Increases CONSTRUCT GreenLife. + Item::LifeRGPlus => format!("Increases CONSTRUCT GreenLife + RedLife"), + Item::LifeGBPlus => format!("Increases CONSTRUCT GreenLife + BlueLife"), + Item::LifeRBPlus => format!("Increases CONSTRUCT RedLife + BlueLife"), + Item::LifeGGPlusPlus => format!("Increases CONSTRUCT GreenLife. When your CONSTRUCT reaches 0 GreenLife it becomes KO and cannot cast SKILLS."), - Item::LifeRRIII => format!("Increases CONSTRUCT RedLife. + Item::LifeRRPlusPlus => format!("Increases CONSTRUCT RedLife. RedDamage dealt to your construct reduces RedLife before GreenLife."), - Item::LifeBBIII => format!("Increases CONSTRUCT BlueLife. + Item::LifeBBPlusPlus => format!("Increases CONSTRUCT BlueLife. BlueDamage dealt to your construct reduces BlueLife before GreenLife."), - Item::LifeRGIII => format!("Increases CONSTRUCT GreenLife + RedLife"), - Item::LifeGBIII => format!("Increases CONSTRUCT GreenLife + BlueLife"), - Item::LifeRBIII => format!("Increases CONSTRUCT RedLife + BlueLife"), + Item::LifeRGPlusPlus => format!("Increases CONSTRUCT GreenLife + RedLife"), + Item::LifeGBPlusPlus => format!("Increases CONSTRUCT GreenLife + BlueLife"), + Item::LifeRBPlusPlus => format!("Increases CONSTRUCT RedLife + BlueLife"), // Power Upgrades - Item::PowerRRI => format!("Increases CONSTRUCT RedPower."), - Item::PowerBBI => format!("Increases CONSTRUCT BluePower."), - Item::PowerGGI => format!("Increases CONSTRUCT GreenPower."), - Item::PowerRGI => format!("Increases CONSTRUCT GreenPower + RedPower."), - Item::PowerGBI => format!("Increases CONSTRUCT GreenPower + BluePower."), - Item::PowerRBI => format!("Increases CONSTRUCT RedPower + BluePower."), - Item::PowerRRII => format!("Increases CONSTRUCT RedPower."), - Item::PowerBBII => format!("Increases CONSTRUCT BluePower."), - Item::PowerGGII => format!("Increases CONSTRUCT GreenPower."), - Item::PowerRGII => format!("Increases CONSTRUCT GreenPower + RedPower."), - Item::PowerGBII => format!("Increases CONSTRUCT GreenPower + BluePower."), - Item::PowerRBII => format!("Increases CONSTRUCT RedPower + BluePower."), - Item::PowerRRIII => format!("Increases CONSTRUCT RedPower."), - Item::PowerBBIII => format!("Increases CONSTRUCT BluePower."), - Item::PowerGGIII => format!("Increases CONSTRUCT GreenPower."), - Item::PowerRGIII => format!("Increases CONSTRUCT GreenPower + RedPower."), - Item::PowerGBIII => format!("Increases CONSTRUCT GreenPower + BluePower."), - Item::PowerRBIII => format!("Increases CONSTRUCT RedPower + BluePower."), + Item::PowerRR=> format!("Increases CONSTRUCT RedPower."), + Item::PowerBB=> format!("Increases CONSTRUCT BluePower."), + Item::PowerGG=> format!("Increases CONSTRUCT GreenPower."), + Item::PowerRG=> format!("Increases CONSTRUCT GreenPower + RedPower."), + Item::PowerGB=> format!("Increases CONSTRUCT GreenPower + BluePower."), + Item::PowerRB=> format!("Increases CONSTRUCT RedPower + BluePower."), + Item::PowerRRPlus => format!("Increases CONSTRUCT RedPower."), + Item::PowerBBPlus => format!("Increases CONSTRUCT BluePower."), + Item::PowerGGPlus => format!("Increases CONSTRUCT GreenPower."), + Item::PowerRGPlus => format!("Increases CONSTRUCT GreenPower + RedPower."), + Item::PowerGBPlus => format!("Increases CONSTRUCT GreenPower + BluePower."), + Item::PowerRBPlus => format!("Increases CONSTRUCT RedPower + BluePower."), + Item::PowerRRPlusPlus => format!("Increases CONSTRUCT RedPower."), + Item::PowerBBPlusPlus => format!("Increases CONSTRUCT BluePower."), + Item::PowerGGPlusPlus => format!("Increases CONSTRUCT GreenPower."), + Item::PowerRGPlusPlus => format!("Increases CONSTRUCT GreenPower + RedPower."), + Item::PowerGBPlusPlus => format!("Increases CONSTRUCT GreenPower + BluePower."), + Item::PowerRBPlusPlus => format!("Increases CONSTRUCT RedPower + BluePower."), // Speed Upgrades - Item::SpeedRRI | - Item::SpeedBBI | - Item::SpeedGGI | - Item::SpeedRGI | - Item::SpeedGBI | - Item::SpeedRBI | - Item::SpeedRRII | - Item::SpeedBBII | - Item::SpeedGGII | - Item::SpeedRGII | - Item::SpeedGBII | - Item::SpeedRBII | - Item::SpeedRRIII | - Item::SpeedBBIII | - Item::SpeedGGIII | - Item::SpeedRGIII | - Item::SpeedGBIII | - Item::SpeedRBIII => format!("Increases CONSTRUCT SPEED and provides COLOUR BONUSES"), + Item::SpeedRR| + Item::SpeedBB| + Item::SpeedGG| + Item::SpeedRG| + Item::SpeedGB| + Item::SpeedRB| + Item::SpeedRRPlus | + Item::SpeedBBPlus | + Item::SpeedGGPlus | + Item::SpeedRGPlus | + Item::SpeedGBPlus | + Item::SpeedRBPlus | + Item::SpeedRRPlusPlus | + Item::SpeedBBPlusPlus | + Item::SpeedGGPlusPlus | + Item::SpeedRGPlusPlus | + Item::SpeedGBPlusPlus | + Item::SpeedRBPlusPlus => format!("Increases CONSTRUCT SPEED and provides COLOUR BONUSES"), // Skills <- need to move effect mulltipliers into skills - Item::AmplifyI | - Item::AmplifyII | - Item::AmplifyIII => format!("Increase red and blue power by {:?}%. Lasts {:?}T", + Item::Amplify| + Item::AmplifyPlus | + Item::AmplifyPlusPlus => format!("Increase red and blue power by {:?}%. Lasts {:?}T", self.into_skill().unwrap().effect()[0].get_multiplier() - 100, self.into_skill().unwrap().effect()[0].get_duration()), - Item::BanishI | - Item::BanishII | - Item::BanishIII => format!("Banish target for {:?}T. + Item::Banish| + Item::BanishPlus | + Item::BanishPlusPlus => format!("Banish target for {:?}T. Banished constructs are immune to all skills and effects.", self.into_skill().unwrap().effect()[0].get_duration()), - Item::BlastI | - Item::BlastII | - Item::BlastIII => format!("Deals Blue Damage {:?}% Blue Power.", self.into_skill().unwrap().multiplier()), + Item::Blast| + Item::BlastPlus | + Item::BlastPlusPlus => format!("Deals Blue Damage {:?}% Blue Power.", self.into_skill().unwrap().multiplier()), - Item::ChaosI | - Item::ChaosII | - Item::ChaosIII => format!( + Item::Chaos| + Item::ChaosPlus | + Item::ChaosPlusPlus => format!( "Hits twice for red and blue damage. Damage {:?}% red and blue power. Randomly deals 0 to 30% more damage", self.into_skill().unwrap().multiplier()), - Item::SustainI | - Item::SustainII | - Item::SustainIII => format!("Construct cannot be KO'd while active. Additionally provides immunity to disables. \ + Item::Sustain| + Item::SustainPlus | + Item::SustainPlusPlus => format!("Construct cannot be KO'd while active. Additionally provides immunity to disables. \ Lasts {:?}T", self.into_skill().unwrap().effect()[0].get_duration()), - Item::ElectrifyI | - Item::ElectrifyII | - Item::ElectrifyIII => format!( + Item::Electrify| + Item::ElectrifyPlus | + Item::ElectrifyPlusPlus => 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(), self.into_skill().unwrap().effect()[0].get_skill().unwrap().effect()[0].get_duration()), - Item::CurseI | - Item::CurseII | - Item::CurseIII => format!( + Item::Curse| + Item::CursePlus | + Item::CursePlusPlus => format!( "Increases red and blue damage taken by {:?}%. Lasts {:?}T", self.into_skill().unwrap().effect()[0].get_multiplier() - 100, self.into_skill().unwrap().effect()[0].get_duration()), - Item::DecayI | - Item::DecayII | - Item::DecayIII => format!( + Item::Decay| + Item::DecayPlus | + Item::DecayPlusPlus => format!( "Reduces healing taken by {:?}% for {:?}T. Deals blue damage {:?}% blue power each turn for {:?}T", 100 - self.into_skill().unwrap().effect()[0].get_multiplier(), self.into_skill().unwrap().effect()[0].get_duration(), self.into_skill().unwrap().effect()[1].get_skill().unwrap().multiplier(), self.into_skill().unwrap().effect()[1].get_duration()), - Item::AbsorbI | - Item::AbsorbII | - Item::AbsorbIII => format!( + Item::Absorb| + Item::AbsorbPlus | + Item::AbsorbPlusPlus => format!( "Gain Absorb for {:?}T. {} Absorption lasts {:?}T", self.into_skill().unwrap().effect()[0].get_duration(), "When attacked with Absorb you gain Absorption which increased red and blue power based on Damage taken.", self.into_skill().unwrap().effect()[0].get_skill().unwrap().effect()[0].get_duration()), - Item::HasteI | - Item::HasteII | - Item::HasteIII => format!( + Item::Haste| + Item::HastePlus | + Item::HastePlusPlus => format!( "Haste increases Speed by {:?}%, Red based Attack skills will strike again dealing {:?}{}. Lasts {:?}T", self.into_skill().unwrap().effect()[0].get_multiplier() - 100, Skill::HasteStrike.multiplier(), "% Speed as RedDamage", self.into_skill().unwrap().effect()[0].get_duration()), - Item::HealI | - Item::HealII | - Item::HealIII => format!("Heals for {:?}% green power.", self.into_skill().unwrap().multiplier()), + Item::Heal| + Item::HealPlus | + Item::HealPlusPlus => format!("Heals for {:?}% green power.", self.into_skill().unwrap().multiplier()), - Item::HexI | - Item::HexII | - Item::HexIII => format!("Blue based skill that applies Hex for {:?}T. \ + Item::Hex| + Item::HexPlus | + Item::HexPlusPlus => format!("Blue based skill that applies Hex for {:?}T. \ Hexed targets cannot cast any skills.", self.into_skill().unwrap().effect()[0].get_duration()), - Item::HybridI | - Item::HybridII | - Item::HybridIII => format!( + Item::Hybrid| + Item::HybridPlus | + Item::HybridPlusPlus => format!( "Hybrid increases Green Power by {:?}%, Blue based Attack skills will blast again dealing {:?}{}. Lasts {:?}T", self.into_skill().unwrap().effect()[0].get_multiplier() - 100, Skill::HybridBlast.multiplier(), "% GreenPower as BluePower", self.into_skill().unwrap().effect()[0].get_duration()), - Item::InvertI | - Item::InvertII | - Item::InvertIII => format!( + Item::Invert| + Item::InvertPlus | + Item::InvertPlusPlus => format!( "Reverse healing into damage and damage into healing. Any excess red or blue damage is converted into shield recharge."), - Item::CounterI | - Item::CounterII | - Item::CounterIII => format!("{} {:?}% red power and blocks red skills for {:?}T. {} {:?}% red power.", + Item::Counter| + Item::CounterPlus | + Item::CounterPlusPlus => format!("{} {:?}% red power and blocks red skills for {:?}T. {} {:?}% red power.", "Self targetting skill. Recharges RedLife for", self.into_skill().unwrap().multiplier(), self.into_skill().unwrap().effect()[0].get_duration(), "If a red skill is parried the construct will riposte the source dealing red damage", self.into_skill().unwrap().effect()[0].get_skill().unwrap().multiplier()), - Item::PurgeI | - Item::PurgeII | - Item::PurgeIII => format!("Remove buffs from target construct"), + Item::Purge| + Item::PurgePlus | + Item::PurgePlusPlus => format!("Remove buffs from target construct"), - Item::PurifyI | - Item::PurifyII | - Item::PurifyIII => format!( + Item::Purify| + Item::PurifyPlus | + Item::PurifyPlusPlus => format!( "Remove debuffs and heals for {:?}% green power per debuff removed.", self.into_skill().unwrap().multiplier()), - Item::ReflectI | - Item::ReflectII | - Item::ReflectIII => format!( + Item::Reflect| + Item::ReflectPlus | + Item::ReflectPlusPlus => format!( "Reflect incoming blue skills to source. Lasts {:?}T", self.into_skill().unwrap().effect()[0].get_duration()), - Item::RechargeI | - Item::RechargeII | - Item::RechargeIII => format!( + Item::Recharge| + Item::RechargePlus | + Item::RechargePlusPlus => format!( "Recharge Red and Blue Life based on {:?} RedPower and BluePower", self.into_skill().unwrap().multiplier()), - Item::RuinI | - Item::RuinII | - Item::RuinIII => format!( + Item::Ruin| + Item::RuinPlus | + Item::RuinPlusPlus => format!( "Team wide Stun for {:?}T. Stunned constructs are unable to cast skills.", self.into_skill().unwrap().effect()[0].get_duration()), - Item::LinkI | - Item::LinkII | - Item::LinkIII => format!( + Item::Link| + Item::LinkPlus | + Item::LinkPlusPlus => format!( "Caster links with target. Linked constructs split incoming Damage evenly. Recharges target Blue Life {:?}% of BluePower", self.into_skill().unwrap().multiplier()), - Item::SilenceI | - Item::SilenceII | - Item::SilenceIII => format!( + Item::Silence| + Item::SilencePlus | + Item::SilencePlusPlus => format!( "Block the target from using blue skills for {:?}T and deals blue damage {:?}% blue power. {}", self.into_skill().unwrap().effect()[0].get_duration(), self.into_skill().unwrap().multiplier(), "Deals 45% more Damage per blue skill on target"), - Item::SlayI | - Item::SlayII | - Item::SlayIII => format!( + Item::Slay| + Item::SlayPlus | + Item::SlayPlusPlus => format!( "Deals RedDamage {:?}% RedPower and provides self healing based on damage dealt.", self.into_skill().unwrap().multiplier()), - Item::SleepI | - Item::SleepII | - Item::SleepIII => format!( + Item::Sleep| + Item::SleepPlus | + Item::SleepPlusPlus => format!( "Stun for {:?}T and heal for {:?}% GreenPower.", self.into_skill().unwrap().effect()[0].get_duration(), self.into_skill().unwrap().multiplier()), - Item::RestrictI | - Item::RestrictII | - Item::RestrictIII => format!( + Item::Restrict| + Item::RestrictPlus | + Item::RestrictPlusPlus => format!( "Block the target from using red skills for {:?}T and deals RedDamage {:?}% RedPower. {}", self.into_skill().unwrap().effect()[0].get_duration(), self.into_skill().unwrap().multiplier(), "Deals 35% more Damage per red skill on target"), - Item::BashI | - Item::BashII | - Item::BashIII => format!( + Item::Bash| + Item::BashPlus | + Item::BashPlusPlus => format!( "Bash the target increasing the cooldowns of their skills. Deals {:?}% RedPower per cooldown increased. Lasts {:?}T.", self.into_skill().unwrap().effect()[0].get_skill().unwrap().multiplier(), self.into_skill().unwrap().effect()[0].get_duration()), - Item::StrikeI | - Item::StrikeII | - Item::StrikeIII => format!( + Item::Strike| + Item::StrikePlus | + Item::StrikePlusPlus => format!( "Hits at maximum speed dealing RedDamage {:?}% RedPower", self.into_skill().unwrap().multiplier()), - Item::SiphonI | - Item::SiphonII | - Item::SiphonIII => format!( + Item::Siphon| + Item::SiphonPlus | + Item::SiphonPlusPlus => format!( "Deals BlueDamage {:?}% BluePower each turn and heals caster based on Damage dealt. Lasts {:?}T", self.into_skill().unwrap().effect()[0].get_skill().unwrap().multiplier(), self.into_skill().unwrap().effect()[0].get_duration()), - Item::InterceptI | - Item::InterceptII | - Item::InterceptIII => format!("Intercept redirects skills against the team to target, lasts {:?}T.\ + Item::Intercept| + Item::InterceptPlus | + Item::InterceptPlusPlus => format!("Intercept redirects skills against the team to target, lasts {:?}T.\ Recharges RedLife for {:?} RedPower.", self.into_skill().unwrap().effect()[0].get_duration(), self.into_skill().unwrap().multiplier()), - Item::BreakI | - Item::BreakII | - Item::BreakIII => format!( + Item::Break| + Item::BreakPlus | + Item::BreakPlusPlus => format!( "Stun the target for {:?}T and applies Vulnerable increasing RedDamage taken by {:?}% for {:?}T", self.into_skill().unwrap().effect()[0].get_duration(), self.into_skill().unwrap().effect()[1].get_multiplier() - 100, self.into_skill().unwrap().effect()[1].get_duration()), - Item::TriageI | - Item::TriageII | - Item::TriageIII => format!( + Item::Triage| + Item::TriagePlus | + Item::TriagePlusPlus => format!( "Heals target for {:?}% GreenPower each turn. Lasts {:?}T", self.into_skill().unwrap().effect()[0].get_skill().unwrap().multiplier(), self.into_skill().unwrap().effect()[0].get_duration()), @@ -784,161 +784,161 @@ impl Item { fn combo(&self) -> Vec { match self { - Item::InterceptI => vec![Item::Buff, Item::Red, Item::Red], - Item::InterceptII => vec![Item::InterceptI, Item::InterceptI, Item::InterceptI], - Item::InterceptIII => vec![Item::InterceptII, Item::InterceptII, Item::InterceptII], - Item::TriageI => vec![Item::Buff, Item::Green, Item::Green], - Item::TriageII => vec![Item::TriageI, Item::TriageI, Item::TriageI], - Item::TriageIII => vec![Item::TriageII, Item::TriageII, Item::TriageII], - Item::LinkI => vec![Item::Buff, Item::Blue, Item::Blue], - Item::LinkII => vec![Item::LinkI, Item::LinkI, Item::LinkI], - Item::LinkIII => vec![Item::LinkIII, Item::LinkIII, Item::LinkIII], - 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::HybridI => vec![Item::Buff, Item::Green, Item::Blue], - Item::HybridII => vec![Item::HybridI, Item::HybridI, Item::HybridI], - Item::HybridIII => vec![Item::HybridII, Item::HybridII, Item::HybridII], - 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::Intercept => vec![Item::Buff, Item::Red, Item::Red], + Item::InterceptPlus => vec![Item::Intercept, Item::Intercept, Item::Intercept], + Item::InterceptPlusPlus => vec![Item::InterceptPlus, Item::InterceptPlus, Item::InterceptPlus], + Item::Triage => vec![Item::Buff, Item::Green, Item::Green], + Item::TriagePlus => vec![Item::Triage, Item::Triage, Item::Triage], + Item::TriagePlusPlus => vec![Item::TriagePlus, Item::TriagePlus, Item::TriagePlus], + Item::Link => vec![Item::Buff, Item::Blue, Item::Blue], + Item::LinkPlus => vec![Item::Link, Item::Link, Item::Link], + Item::LinkPlusPlus => vec![Item::LinkPlusPlus, Item::LinkPlusPlus, Item::LinkPlusPlus], + Item::Haste => vec![Item::Buff, Item::Red, Item::Green], + Item::HastePlus => vec![Item::Haste, Item::Haste, Item::Haste], + Item::HastePlusPlus => vec![Item::HastePlus, Item::HastePlus, Item::HastePlus], + Item::Hybrid => vec![Item::Buff, Item::Green, Item::Blue], + Item::HybridPlus => vec![Item::Hybrid, Item::Hybrid, Item::Hybrid], + Item::HybridPlusPlus => vec![Item::HybridPlus, Item::HybridPlus, Item::HybridPlus], + Item::Amplify => vec![Item::Buff, Item::Red, Item::Blue], + Item::AmplifyPlus => vec![Item::Amplify, Item::Amplify, Item::Amplify], + Item::AmplifyPlusPlus => vec![Item::AmplifyPlus, Item::AmplifyPlus, Item::AmplifyPlus], - Item::RestrictI => vec![Item::Debuff, Item::Red, Item::Red], - Item::RestrictII => vec![Item::RestrictI, Item::RestrictI, Item::RestrictI], - Item::RestrictIII => vec![Item::RestrictII, Item::RestrictII, Item::RestrictII], - Item::PurgeI => vec![Item::Debuff, Item::Green, Item::Green], // Needs flavour - Item::PurgeII => vec![Item::PurgeI, Item::PurgeI, Item::PurgeI], // Needs flavour - Item::PurgeIII => vec![Item::PurgeII, Item::PurgeII, Item::PurgeII], // Needs flavour - Item::SilenceI => vec![Item::Debuff, Item::Blue, Item::Blue], - Item::SilenceII => vec![Item::SilenceI, Item::SilenceI, Item::SilenceI], - Item::SilenceIII => vec![Item::SilenceII, Item::SilenceII, Item::SilenceII], - Item::CurseI => vec![Item::Debuff, Item::Red, Item::Green], - Item::CurseII => vec![Item::CurseI, Item::CurseI, Item::CurseI], - Item::CurseIII => vec![Item::CurseII, Item::CurseII, Item::CurseII], - Item::DecayI => vec![Item::Debuff, Item::Green, Item::Blue], - Item::DecayII => vec![Item::DecayI, Item::DecayI, Item::DecayI], - Item::DecayIII => vec![Item::DecayII, Item::DecayII, Item::DecayII], - Item::InvertI => vec![Item::Debuff, Item::Red, Item::Blue], - Item::InvertII => vec![Item::InvertI, Item::InvertI, Item::InvertI], - Item::InvertIII => vec![Item::InvertII, Item::InvertII, Item::InvertII], + Item::Restrict => vec![Item::Debuff, Item::Red, Item::Red], + Item::RestrictPlus => vec![Item::Restrict, Item::Restrict, Item::Restrict], + Item::RestrictPlusPlus => vec![Item::RestrictPlus, Item::RestrictPlus, Item::RestrictPlus], + Item::Purge => vec![Item::Debuff, Item::Green, Item::Green], // Needs flavour + Item::PurgePlus => vec![Item::Purge, Item::Purge, Item::Purge], // Needs flavour + Item::PurgePlusPlus => vec![Item::PurgePlus, Item::PurgePlus, Item::PurgePlus], // Needs flavour + Item::Silence => vec![Item::Debuff, Item::Blue, Item::Blue], + Item::SilencePlus => vec![Item::Silence, Item::Silence, Item::Silence], + Item::SilencePlusPlus => vec![Item::SilencePlus, Item::SilencePlus, Item::SilencePlus], + Item::Curse => vec![Item::Debuff, Item::Red, Item::Green], + Item::CursePlus => vec![Item::Curse, Item::Curse, Item::Curse], + Item::CursePlusPlus => vec![Item::CursePlus, Item::CursePlus, Item::CursePlus], + Item::Decay => vec![Item::Debuff, Item::Green, Item::Blue], + Item::DecayPlus => vec![Item::Decay, Item::Decay, Item::Decay], + Item::DecayPlusPlus => vec![Item::DecayPlus, Item::DecayPlus, Item::DecayPlus], + Item::Invert => vec![Item::Debuff, Item::Red, Item::Blue], + Item::InvertPlus => vec![Item::Invert, Item::Invert, Item::Invert], + Item::InvertPlusPlus => vec![Item::InvertPlus, Item::InvertPlus, Item::InvertPlus], - Item::CounterI => vec![Item::Block, Item::Red, Item::Red], - Item::CounterII => vec![Item::CounterI, Item::CounterI, Item::CounterI], - Item::CounterIII => vec![Item::CounterII, Item::CounterII, Item::CounterII], // Add red recharge - 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::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::SustainI => vec![Item::Block, Item::Red, Item::Green], - Item::SustainII => vec![Item::SustainI, Item::SustainI, Item::SustainI], - Item::SustainIII => vec![Item::SustainII, Item::SustainII, Item::SustainII], - Item::ReflectI => vec![Item::Block, Item::Green, Item::Blue], - Item::ReflectII => vec![Item::ReflectI, Item::ReflectI, Item::ReflectI], - Item::ReflectIII => vec![Item::ReflectII, Item::ReflectII, Item::ReflectII], - Item::RechargeI => vec![Item::Block, Item::Red, Item::Blue], - Item::RechargeII => vec![Item::RechargeI, Item::RechargeI, Item::RechargeI], - Item::RechargeIII => vec![Item::RechargeII, Item::RechargeII, Item::RechargeII], + Item::Counter => vec![Item::Block, Item::Red, Item::Red], + Item::CounterPlus => vec![Item::Counter, Item::Counter, Item::Counter], + Item::CounterPlusPlus => vec![Item::CounterPlus, Item::CounterPlus, Item::CounterPlus], // Add red recharge + Item::Purify => vec![Item::Block, Item::Green, Item::Green], + Item::PurifyPlus => vec![Item::Purify, Item::Purify, Item::Purify], + Item::PurifyPlusPlus => vec![Item::PurifyPlus, Item::PurifyPlus, Item::PurifyPlus], + Item::Electrify => vec![Item::Block, Item::Blue, Item::Blue], + Item::ElectrifyPlus => vec![Item::Electrify, Item::Electrify, Item::Electrify], + Item::ElectrifyPlusPlus => vec![Item::ElectrifyPlus, Item::ElectrifyPlus, Item::ElectrifyPlus], + Item::Sustain => vec![Item::Block, Item::Red, Item::Green], + Item::SustainPlus => vec![Item::Sustain, Item::Sustain, Item::Sustain], + Item::SustainPlusPlus => vec![Item::SustainPlus, Item::SustainPlus, Item::SustainPlus], + Item::Reflect => vec![Item::Block, Item::Green, Item::Blue], + Item::ReflectPlus => vec![Item::Reflect, Item::Reflect, Item::Reflect], + Item::ReflectPlusPlus => vec![Item::ReflectPlus, Item::ReflectPlus, Item::ReflectPlus], + Item::Recharge => vec![Item::Block, Item::Red, Item::Blue], + Item::RechargePlus => vec![Item::Recharge, Item::Recharge, Item::Recharge], + Item::RechargePlusPlus => vec![Item::RechargePlus, Item::RechargePlus, Item::RechargePlus], - Item::BashI => vec![Item::Stun, Item::Red, Item::Red], - Item::BashII => vec![Item::BashI, Item::BashI, Item::BashI], - Item::BashIII => vec![Item::BashII, Item::BashII, Item::BashII], - Item::SleepI => vec![Item::Stun, Item::Green, Item::Green], - Item::SleepII => vec![Item::SleepI, Item::SleepI, Item::SleepI], - Item::SleepIII => vec![Item::SleepII, Item::SleepII, Item::SleepII], - Item::RuinI => vec![Item::Stun, Item::Blue, Item::Blue], - Item::RuinII => vec![Item::RuinI, Item::RuinI, Item::RuinI], - Item::RuinIII => vec![Item::RuinII, Item::RuinII, Item::RuinII], - Item::BreakI => vec![Item::Stun, Item::Red, Item::Green], - Item::BreakII => vec![Item::BreakI, Item::BreakI, Item::BreakI], - Item::BreakIII => vec![Item::BreakII, Item::BreakII, Item::BreakII], - Item::AbsorbI => vec![Item::Stun, Item::Green, Item::Blue], - Item::AbsorbII => vec![Item::AbsorbI, Item::AbsorbI, Item::AbsorbI], - Item::AbsorbIII => vec![Item::AbsorbII, Item::AbsorbII, Item::AbsorbII], - Item::BanishI => vec![Item::Stun, Item::Red, Item::Blue], - Item::BanishII => vec![Item::BanishI, Item::BanishI, Item::BanishI], - Item::BanishIII => vec![Item::BanishII, Item::BanishII, Item::BanishII], + Item::Bash => vec![Item::Stun, Item::Red, Item::Red], + Item::BashPlus => vec![Item::Bash, Item::Bash, Item::Bash], + Item::BashPlusPlus => vec![Item::BashPlus, Item::BashPlus, Item::BashPlus], + Item::Sleep => vec![Item::Stun, Item::Green, Item::Green], + Item::SleepPlus => vec![Item::Sleep, Item::Sleep, Item::Sleep], + Item::SleepPlusPlus => vec![Item::SleepPlus, Item::SleepPlus, Item::SleepPlus], + Item::Ruin => vec![Item::Stun, Item::Blue, Item::Blue], + Item::RuinPlus => vec![Item::Ruin, Item::Ruin, Item::Ruin], + Item::RuinPlusPlus => vec![Item::RuinPlus, Item::RuinPlus, Item::RuinPlus], + Item::Break => vec![Item::Stun, Item::Red, Item::Green], + Item::BreakPlus => vec![Item::Break, Item::Break, Item::Break], + Item::BreakPlusPlus => vec![Item::BreakPlus, Item::BreakPlus, Item::BreakPlus], + Item::Absorb => vec![Item::Stun, Item::Green, Item::Blue], + Item::AbsorbPlus => vec![Item::Absorb, Item::Absorb, Item::Absorb], + Item::AbsorbPlusPlus => vec![Item::AbsorbPlus, Item::AbsorbPlus, Item::AbsorbPlus], + Item::Banish => vec![Item::Stun, Item::Red, Item::Blue], + Item::BanishPlus => vec![Item::Banish, Item::Banish, Item::Banish], + Item::BanishPlusPlus => vec![Item::BanishPlus, Item::BanishPlus, Item::BanishPlus], - Item::StrikeI => vec![Item::Attack, Item::Red, Item::Red], - Item::StrikeII => vec![Item::StrikeI, Item::StrikeI, Item::StrikeI], - Item::StrikeIII => vec![Item::StrikeII, Item::StrikeII, Item::StrikeII], - Item::HealI => vec![Item::Attack, Item::Green, Item::Green], - Item::HealII => vec![Item::HealI, Item::HealI, Item::HealI], - Item::HealIII => vec![Item::HealII, Item::HealII, Item::HealII], - Item::BlastI => vec![Item::Attack, Item::Blue, Item::Blue], - Item::BlastII => vec![Item::BlastI, Item::BlastI, Item::BlastI], - Item::BlastIII => vec![Item::BlastII, Item::BlastII, Item::BlastII], - Item::SlayI => vec![Item::Attack, Item::Red, Item::Green], - Item::SlayII => vec![Item::SlayI, Item::SlayI, Item::SlayI], - Item::SlayIII => vec![Item::SlayII, Item::SlayII, Item::SlayII], - Item::SiphonI => vec![Item::Attack, Item::Green, Item::Blue], - Item::SiphonII => vec![Item::SiphonI, Item::SiphonI, Item::SiphonI], - Item::SiphonIII => vec![Item::SiphonII, Item::SiphonII, Item::SiphonII], - Item::ChaosI => vec![Item::Attack, Item::Red, Item::Blue], - Item::ChaosII => vec![Item::ChaosI, Item::ChaosI, Item::ChaosI], - Item::ChaosIII => vec![Item::ChaosII, Item::ChaosII, Item::ChaosII], + Item::Strike => vec![Item::Attack, Item::Red, Item::Red], + Item::StrikePlus => vec![Item::Strike, Item::Strike, Item::Strike], + Item::StrikePlusPlus => vec![Item::StrikePlus, Item::StrikePlus, Item::StrikePlus], + Item::Heal => vec![Item::Attack, Item::Green, Item::Green], + Item::HealPlus => vec![Item::Heal, Item::Heal, Item::Heal], + Item::HealPlusPlus => vec![Item::HealPlus, Item::HealPlus, Item::HealPlus], + Item::Blast => vec![Item::Attack, Item::Blue, Item::Blue], + Item::BlastPlus => vec![Item::Blast, Item::Blast, Item::Blast], + Item::BlastPlusPlus => vec![Item::BlastPlus, Item::BlastPlus, Item::BlastPlus], + Item::Slay => vec![Item::Attack, Item::Red, Item::Green], + Item::SlayPlus => vec![Item::Slay, Item::Slay, Item::Slay], + Item::SlayPlusPlus => vec![Item::SlayPlus, Item::SlayPlus, Item::SlayPlus], + Item::Siphon => vec![Item::Attack, Item::Green, Item::Blue], + Item::SiphonPlus => vec![Item::Siphon, Item::Siphon, Item::Siphon], + Item::SiphonPlusPlus => vec![Item::SiphonPlus, Item::SiphonPlus, Item::SiphonPlus], + Item::Chaos => vec![Item::Attack, Item::Red, Item::Blue], + Item::ChaosPlus => vec![Item::Chaos, Item::Chaos, Item::Chaos], + Item::ChaosPlusPlus => vec![Item::ChaosPlus, Item::ChaosPlus, Item::ChaosPlus], - Item::PowerRRI => vec![Item::Power, Item::Red, Item::Red], - Item::PowerGGI => vec![Item::Power, Item::Green, Item::Green], - Item::PowerBBI => vec![Item::Power, Item::Blue, Item::Blue], - Item::PowerRGI => vec![Item::Power, Item::Red, Item::Green], - Item::PowerGBI => vec![Item::Power, Item::Green, Item::Blue], - Item::PowerRBI => vec![Item::Power, Item::Red, Item::Blue], - Item::PowerRRII => vec![Item::PowerRRI, Item::PowerRRI, Item::PowerRRI], - Item::PowerGGII => vec![Item::PowerGGI, Item::PowerGGI, Item::PowerGGI], - Item::PowerBBII => vec![Item::PowerBBI, Item::PowerBBI, Item::PowerBBI], - Item::PowerRGII => vec![Item::PowerRGI, Item::PowerRGI, Item::PowerRGI], - Item::PowerGBII => vec![Item::PowerGBI, Item::PowerGBI, Item::PowerGBI], - Item::PowerRBII => vec![Item::PowerRBI, Item::PowerRBI, Item::PowerRBI], - Item::PowerRRIII => vec![Item::PowerRRII, Item::PowerRRII, Item::PowerRRII], - Item::PowerGGIII => vec![Item::PowerGGII, Item::PowerGGII, Item::PowerGGII], - Item::PowerBBIII => vec![Item::PowerBBII, Item::PowerBBII, Item::PowerBBII], - Item::PowerRGIII => vec![Item::PowerRGII, Item::PowerRGII, Item::PowerRGII], - Item::PowerGBIII => vec![Item::PowerGBII, Item::PowerGBII, Item::PowerGBII], - Item::PowerRBIII => vec![Item::PowerRBII, Item::PowerRBII, Item::PowerRBII], + Item::PowerRR => vec![Item::Power, Item::Red, Item::Red], + Item::PowerGG => vec![Item::Power, Item::Green, Item::Green], + Item::PowerBB => vec![Item::Power, Item::Blue, Item::Blue], + Item::PowerRG => vec![Item::Power, Item::Red, Item::Green], + Item::PowerGB => vec![Item::Power, Item::Green, Item::Blue], + Item::PowerRB => vec![Item::Power, Item::Red, Item::Blue], + Item::PowerRRPlus => vec![Item::PowerRR, Item::PowerRR, Item::PowerRR], + Item::PowerGGPlus => vec![Item::PowerGG, Item::PowerGG, Item::PowerGG], + Item::PowerBBPlus => vec![Item::PowerBB, Item::PowerBB, Item::PowerBB], + Item::PowerRGPlus => vec![Item::PowerRG, Item::PowerRG, Item::PowerRG], + Item::PowerGBPlus => vec![Item::PowerGB, Item::PowerGB, Item::PowerGB], + Item::PowerRBPlus => vec![Item::PowerRB, Item::PowerRB, Item::PowerRB], + Item::PowerRRPlusPlus => vec![Item::PowerRRPlus, Item::PowerRRPlus, Item::PowerRRPlus], + Item::PowerGGPlusPlus => vec![Item::PowerGGPlus, Item::PowerGGPlus, Item::PowerGGPlus], + Item::PowerBBPlusPlus => vec![Item::PowerBBPlus, Item::PowerBBPlus, Item::PowerBBPlus], + Item::PowerRGPlusPlus => vec![Item::PowerRGPlus, Item::PowerRGPlus, Item::PowerRGPlus], + Item::PowerGBPlusPlus => vec![Item::PowerGBPlus, Item::PowerGBPlus, Item::PowerGBPlus], + Item::PowerRBPlusPlus => vec![Item::PowerRBPlus, Item::PowerRBPlus, Item::PowerRBPlus], - Item::LifeRRI => vec![Item::Life, Item::Red, Item::Red], - Item::LifeGGI => vec![Item::Life, Item::Green, Item::Green], - Item::LifeBBI => vec![Item::Life, Item::Blue, Item::Blue], - Item::LifeRGI => vec![Item::Life, Item::Red, Item::Green], - Item::LifeGBI => vec![Item::Life, Item::Green, Item::Blue], - Item::LifeRBI => vec![Item::Life, Item::Red, Item::Blue], - Item::LifeRRII => vec![Item::LifeRRI, Item::LifeRRI, Item::LifeRRI], - Item::LifeGGII => vec![Item::LifeGGI, Item::LifeGGI, Item::LifeGGI], - Item::LifeBBII => vec![Item::LifeBBI, Item::LifeBBI, Item::LifeBBI], - Item::LifeRGII => vec![Item::LifeRGI, Item::LifeRGI, Item::LifeRGI], - Item::LifeGBII => vec![Item::LifeGBI, Item::LifeGBI, Item::LifeGBI], - Item::LifeRBII => vec![Item::LifeRBI, Item::LifeRBI, Item::LifeRBI], - Item::LifeRRIII => vec![Item::LifeRRII, Item::LifeRRII, Item::LifeRRII], - Item::LifeGGIII => vec![Item::LifeGGII, Item::LifeGGII, Item::LifeGGII], - Item::LifeBBIII => vec![Item::LifeBBII, Item::LifeBBII, Item::LifeBBII], - Item::LifeRGIII => vec![Item::LifeRGII, Item::LifeRGII, Item::LifeRGII], - Item::LifeGBIII => vec![Item::LifeGBII, Item::LifeGBII, Item::LifeGBII], - Item::LifeRBIII => vec![Item::LifeRBII, Item::LifeRBII, Item::LifeRBII], + Item::LifeRR => vec![Item::Life, Item::Red, Item::Red], + Item::LifeGG => vec![Item::Life, Item::Green, Item::Green], + Item::LifeBB => vec![Item::Life, Item::Blue, Item::Blue], + Item::LifeRG => vec![Item::Life, Item::Red, Item::Green], + Item::LifeGB => vec![Item::Life, Item::Green, Item::Blue], + Item::LifeRB => vec![Item::Life, Item::Red, Item::Blue], + Item::LifeRRPlus => vec![Item::LifeRR, Item::LifeRR, Item::LifeRR], + Item::LifeGGPlus => vec![Item::LifeGG, Item::LifeGG, Item::LifeGG], + Item::LifeBBPlus => vec![Item::LifeBB, Item::LifeBB, Item::LifeBB], + Item::LifeRGPlus => vec![Item::LifeRG, Item::LifeRG, Item::LifeRG], + Item::LifeGBPlus => vec![Item::LifeGB, Item::LifeGB, Item::LifeGB], + Item::LifeRBPlus => vec![Item::LifeRB, Item::LifeRB, Item::LifeRB], + Item::LifeRRPlusPlus => vec![Item::LifeRRPlus, Item::LifeRRPlus, Item::LifeRRPlus], + Item::LifeGGPlusPlus => vec![Item::LifeGGPlus, Item::LifeGGPlus, Item::LifeGGPlus], + Item::LifeBBPlusPlus => vec![Item::LifeBBPlus, Item::LifeBBPlus, Item::LifeBBPlus], + Item::LifeRGPlusPlus => vec![Item::LifeRGPlus, Item::LifeRGPlus, Item::LifeRGPlus], + Item::LifeGBPlusPlus => vec![Item::LifeGBPlus, Item::LifeGBPlus, Item::LifeGBPlus], + Item::LifeRBPlusPlus => vec![Item::LifeRBPlus, Item::LifeRBPlus, Item::LifeRBPlus], - Item::SpeedRRI => vec![Item::Speed, Item::Red, Item::Red], - Item::SpeedGGI => vec![Item::Speed, Item::Green, Item::Green], - Item::SpeedBBI => vec![Item::Speed, Item::Blue, Item::Blue], - Item::SpeedRGI => vec![Item::Speed, Item::Red, Item::Green], - Item::SpeedGBI => vec![Item::Speed, Item::Green, Item::Blue], - Item::SpeedRBI => vec![Item::Speed, Item::Red, Item::Blue], + Item::SpeedRR => vec![Item::Speed, Item::Red, Item::Red], + Item::SpeedGG => vec![Item::Speed, Item::Green, Item::Green], + Item::SpeedBB => vec![Item::Speed, Item::Blue, Item::Blue], + Item::SpeedRG => vec![Item::Speed, Item::Red, Item::Green], + Item::SpeedGB => vec![Item::Speed, Item::Green, Item::Blue], + Item::SpeedRB => vec![Item::Speed, Item::Red, Item::Blue], - Item::SpeedRRII => vec![Item::SpeedRRI, Item::SpeedRRI, Item::SpeedRRI], - Item::SpeedGGII => vec![Item::SpeedGGI, Item::SpeedGGI, Item::SpeedGGI], - Item::SpeedBBII => vec![Item::SpeedBBI, Item::SpeedBBI, Item::SpeedBBI], - Item::SpeedRGII => vec![Item::SpeedRGI, Item::SpeedRGI, Item::SpeedRGI], - Item::SpeedGBII => vec![Item::SpeedGBI, Item::SpeedGBI, Item::SpeedGBI], - Item::SpeedRBII => vec![Item::SpeedRBI, Item::SpeedRBI, Item::SpeedRBI], + Item::SpeedRRPlus => vec![Item::SpeedRR, Item::SpeedRR, Item::SpeedRR], + Item::SpeedGGPlus => vec![Item::SpeedGG, Item::SpeedGG, Item::SpeedGG], + Item::SpeedBBPlus => vec![Item::SpeedBB, Item::SpeedBB, Item::SpeedBB], + Item::SpeedRGPlus => vec![Item::SpeedRG, Item::SpeedRG, Item::SpeedRG], + Item::SpeedGBPlus => vec![Item::SpeedGB, Item::SpeedGB, Item::SpeedGB], + Item::SpeedRBPlus => vec![Item::SpeedRB, Item::SpeedRB, Item::SpeedRB], - Item::SpeedRRIII => vec![Item::SpeedRRII, Item::SpeedRRII, Item::SpeedRRII], - Item::SpeedGGIII => vec![Item::SpeedGGII, Item::SpeedGGII, Item::SpeedGGII], - Item::SpeedBBIII => vec![Item::SpeedBBII, Item::SpeedBBII, Item::SpeedBBII], - Item::SpeedRGIII => vec![Item::SpeedRGII, Item::SpeedRGII, Item::SpeedRGII], - Item::SpeedGBIII => vec![Item::SpeedGBII, Item::SpeedGBII, Item::SpeedGBII], - Item::SpeedRBIII => vec![Item::SpeedRBII, Item::SpeedRBII, Item::SpeedRBII], + Item::SpeedRRPlusPlus => vec![Item::SpeedRRPlus, Item::SpeedRRPlus, Item::SpeedRRPlus], + Item::SpeedGGPlusPlus => vec![Item::SpeedGGPlus, Item::SpeedGGPlus, Item::SpeedGGPlus], + Item::SpeedBBPlusPlus => vec![Item::SpeedBBPlus, Item::SpeedBBPlus, Item::SpeedBBPlus], + Item::SpeedRGPlusPlus => vec![Item::SpeedRGPlus, Item::SpeedRGPlus, Item::SpeedRGPlus], + Item::SpeedGBPlusPlus => vec![Item::SpeedGBPlus, Item::SpeedGBPlus, Item::SpeedGBPlus], + Item::SpeedRBPlusPlus => vec![Item::SpeedRBPlus, Item::SpeedRBPlus, Item::SpeedRBPlus], _ => vec![*self], } @@ -948,129 +948,129 @@ impl Item { impl From for Item { fn from(skill: Skill) -> Item { match skill { - Skill::AbsorbI => Item::AbsorbI, - Skill::AbsorbII => Item::AbsorbII, - Skill::AbsorbIII => Item::AbsorbIII, - Skill::AmplifyI => Item::AmplifyI, - Skill::AmplifyII => Item::AmplifyII, - Skill::AmplifyIII => Item::AmplifyIII, + Skill::Absorb => Item::Absorb, + Skill::AbsorbPlus => Item::AbsorbPlus, + Skill::AbsorbPlusPlus => Item::AbsorbPlusPlus, + Skill::Amplify => Item::Amplify, + Skill::AmplifyPlus => Item::AmplifyPlus, + Skill::AmplifyPlusPlus => Item::AmplifyPlusPlus, Skill::Attack => Item::Attack, - Skill::BanishI => Item::BanishI, - Skill::BanishII => Item::BanishII, - Skill::BanishIII => Item::BanishIII, - Skill::BashI => Item::BashI, - Skill::BashII => Item::BashII, - Skill::BashIII => Item::BashIII, - Skill::BlastI => Item::BlastI, - Skill::BlastII => Item::BlastII, - Skill::BlastIII => Item::BlastIII, + Skill::Banish => Item::Banish, + Skill::BanishPlus => Item::BanishPlus, + Skill::BanishPlusPlus => Item::BanishPlusPlus, + Skill::Bash => Item::Bash, + Skill::BashPlus => Item::BashPlus, + Skill::BashPlusPlus => Item::BashPlusPlus, + Skill::Blast => Item::Blast, + Skill::BlastPlus => Item::BlastPlus, + Skill::BlastPlusPlus => Item::BlastPlusPlus, Skill::Block => Item::Block, Skill::Buff => Item::Buff, - Skill::ChaosI => Item::ChaosI, - Skill::ChaosII => Item::ChaosII, - Skill::ChaosIII => Item::ChaosIII, - Skill::CounterI => Item::CounterI, - Skill::CounterII => Item::CounterII, - Skill::CounterIII => Item::CounterIII, - Skill::CurseI => Item::CurseI, - Skill::CurseII => Item::CurseII, - Skill::CurseIII => Item::CurseIII, + Skill::Chaos => Item::Chaos, + Skill::ChaosPlus => Item::ChaosPlus, + Skill::ChaosPlusPlus => Item::ChaosPlusPlus, + Skill::Counter => Item::Counter, + Skill::CounterPlus => Item::CounterPlus, + Skill::CounterPlusPlus => Item::CounterPlusPlus, + Skill::Curse => Item::Curse, + Skill::CursePlus => Item::CursePlus, + Skill::CursePlusPlus => Item::CursePlusPlus, Skill::Debuff => Item::Debuff, - Skill::DecayI => Item::DecayI, - Skill::DecayII => Item::DecayII, - Skill::DecayIII => Item::DecayIII, - Skill::ElectrifyI => Item::ElectrifyI, - Skill::ElectrifyII => Item::ElectrifyII, - Skill::ElectrifyIII => Item::ElectrifyIII, - Skill::HasteI => Item::HasteI, - Skill::HasteII => Item::HasteII, - Skill::HasteIII => Item::HasteIII, - Skill::HealI => Item::HealI, - Skill::HealII => Item::HealII, - Skill::HealIII => Item::HealIII, - Skill::HexI => Item::HexI, - Skill::HexII => Item::HexII, - Skill::HexIII => Item::HexIII, - Skill::HybridI => Item::HybridI, - Skill::HybridII => Item::HybridII, - Skill::HybridIII => Item::HybridIII, - Skill::InterceptI => Item::InterceptI, - Skill::InterceptII => Item::InterceptII, - Skill::InterceptIII => Item::InterceptIII, - Skill::InvertI => Item::InvertI, - Skill::InvertII => Item::InvertII, - Skill::InvertIII => Item::InvertIII, - Skill::PurgeI => Item::PurgeI, - Skill::PurgeII => Item::PurgeII, - Skill::PurgeIII => Item::PurgeIII, - Skill::PurifyI => Item::PurifyI, - Skill::PurifyII => Item::PurifyII, - Skill::PurifyIII => Item::PurifyIII, - Skill::RechargeI => Item::RechargeI, - Skill::RechargeII => Item::RechargeII, - Skill::RechargeIII => Item::RechargeIII, - Skill::ReflectI => Item::ReflectI, - Skill::ReflectII => Item::ReflectII, - Skill::ReflectIII => Item::ReflectIII, - Skill::RestrictI => Item::RestrictI, - Skill::RestrictII => Item::RestrictII, - Skill::RestrictIII => Item::RestrictIII, - Skill::RuinI => Item::RuinI, - Skill::RuinII => Item::RuinII, - Skill::RuinIII => Item::RuinIII, - Skill::LinkI => Item::LinkI, - Skill::LinkII => Item::LinkII, - Skill::LinkIII => Item::LinkIII, - Skill::SilenceI => Item::SilenceI, - Skill::SilenceII => Item::SilenceII, - Skill::SilenceIII => Item::SilenceIII, - Skill::SiphonI => Item::SiphonI, - Skill::SiphonII => Item::SiphonII, - Skill::SiphonIII => Item::SiphonIII, - Skill::SlayI => Item::SlayI, - Skill::SlayII => Item::SlayII, - Skill::SlayIII => Item::SlayIII, - Skill::SleepI => Item::SleepI, - Skill::SleepII => Item::SleepII, - Skill::SleepIII => Item::SleepIII, - Skill::StrikeI => Item::StrikeI, - Skill::StrikeII => Item::StrikeII, - Skill::StrikeIII => Item::StrikeIII, + Skill::Decay => Item::Decay, + Skill::DecayPlus => Item::DecayPlus, + Skill::DecayPlusPlus => Item::DecayPlusPlus, + Skill::Electrify => Item::Electrify, + Skill::ElectrifyPlus => Item::ElectrifyPlus, + Skill::ElectrifyPlusPlus => Item::ElectrifyPlusPlus, + Skill::Haste => Item::Haste, + Skill::HastePlus => Item::HastePlus, + Skill::HastePlusPlus => Item::HastePlusPlus, + Skill::Heal => Item::Heal, + Skill::HealPlus => Item::HealPlus, + Skill::HealPlusPlus => Item::HealPlusPlus, + Skill::Hex => Item::Hex, + Skill::HexPlus => Item::HexPlus, + Skill::HexPlusPlus => Item::HexPlusPlus, + Skill::Hybrid => Item::Hybrid, + Skill::HybridPlus => Item::HybridPlus, + Skill::HybridPlusPlus => Item::HybridPlusPlus, + Skill::Intercept => Item::Intercept, + Skill::InterceptPlus => Item::InterceptPlus, + Skill::InterceptPlusPlus => Item::InterceptPlusPlus, + Skill::Invert => Item::Invert, + Skill::InvertPlus => Item::InvertPlus, + Skill::InvertPlusPlus => Item::InvertPlusPlus, + Skill::Purge => Item::Purge, + Skill::PurgePlus => Item::PurgePlus, + Skill::PurgePlusPlus => Item::PurgePlusPlus, + Skill::Purify => Item::Purify, + Skill::PurifyPlus => Item::PurifyPlus, + Skill::PurifyPlusPlus => Item::PurifyPlusPlus, + Skill::Recharge => Item::Recharge, + Skill::RechargePlus => Item::RechargePlus, + Skill::RechargePlusPlus => Item::RechargePlusPlus, + Skill::Reflect => Item::Reflect, + Skill::ReflectPlus => Item::ReflectPlus, + Skill::ReflectPlusPlus => Item::ReflectPlusPlus, + Skill::Restrict => Item::Restrict, + Skill::RestrictPlus => Item::RestrictPlus, + Skill::RestrictPlusPlus => Item::RestrictPlusPlus, + Skill::Ruin => Item::Ruin, + Skill::RuinPlus => Item::RuinPlus, + Skill::RuinPlusPlus => Item::RuinPlusPlus, + Skill::Link => Item::Link, + Skill::LinkPlus => Item::LinkPlus, + Skill::LinkPlusPlus => Item::LinkPlusPlus, + Skill::Silence => Item::Silence, + Skill::SilencePlus => Item::SilencePlus, + Skill::SilencePlusPlus => Item::SilencePlusPlus, + Skill::Siphon => Item::Siphon, + Skill::SiphonPlus => Item::SiphonPlus, + Skill::SiphonPlusPlus => Item::SiphonPlusPlus, + Skill::Slay => Item::Slay, + Skill::SlayPlus => Item::SlayPlus, + Skill::SlayPlusPlus => Item::SlayPlusPlus, + Skill::Sleep => Item::Sleep, + Skill::SleepPlus => Item::SleepPlus, + Skill::SleepPlusPlus => Item::SleepPlusPlus, + Skill::Strike => Item::Strike, + Skill::StrikePlus => Item::StrikePlus, + Skill::StrikePlusPlus => Item::StrikePlusPlus, Skill::Stun => Item::Stun, - Skill::SustainI => Item::SustainI, - Skill::SustainII => Item::SustainII, - Skill::SustainIII => Item::SustainIII, - Skill::BreakI => Item::BreakI, - Skill::BreakII => Item::BreakII, - Skill::BreakIII => Item::BreakIII, - Skill::TriageI => Item::TriageI, - Skill::TriageII => Item::TriageII, - Skill::TriageIII => Item::TriageIII, + Skill::Sustain => Item::Sustain, + Skill::SustainPlus => Item::SustainPlus, + Skill::SustainPlusPlus => Item::SustainPlusPlus, + Skill::Break => Item::Break, + Skill::BreakPlus => Item::BreakPlus, + Skill::BreakPlusPlus => Item::BreakPlusPlus, + Skill::Triage => Item::Triage, + Skill::TriagePlus => Item::TriagePlus, + Skill::TriagePlusPlus => Item::TriagePlusPlus, // Convert subskills into parent skills - 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, - Skill::AbsorptionI => Item::AbsorbI, - Skill::AbsorptionII => Item::AbsorbII, - Skill::AbsorptionIII => Item::AbsorbIII, - Skill::HasteStrike => Item::HasteI, - Skill::HybridBlast => Item::HybridI, - Skill::CounterAttackI => Item::CounterI, - Skill::CounterAttackII => Item::CounterII, - Skill::CounterAttackIII => Item::CounterIII, - Skill::SiphonTickI => Item::SiphonI, - Skill::SiphonTickII => Item::SiphonII, - Skill::SiphonTickIII => Item::SiphonIII, - Skill::TriageTickI => Item::TriageI, - Skill::TriageTickII => Item::TriageII, - Skill::TriageTickIII => Item::TriageIII, + Skill::Electrocute => Item::Electrify, + Skill::ElectrocutePlus => Item::ElectrifyPlus, + Skill::ElectrocutePlusPlus => Item::ElectrifyPlusPlus, + Skill::ElectrocuteTick => Item::Electrify, + Skill::ElectrocuteTickPlus => Item::ElectrifyPlus, + Skill::ElectrocuteTickPlusPlus => Item::ElectrifyPlus, + Skill::DecayTick => Item::Decay, + Skill::DecayTickPlus => Item::DecayPlus, + Skill::DecayTickPlusPlus => Item::DecayPlusPlus, + Skill::Absorption => Item::Absorb, + Skill::AbsorptionPlus => Item::AbsorbPlus, + Skill::AbsorptionPlusPlus => Item::AbsorbPlusPlus, + Skill::HasteStrike => Item::Haste, + Skill::HybridBlast => Item::Hybrid, + Skill::CounterAttack => Item::Counter, + Skill::CounterAttackPlus => Item::CounterPlus, + Skill::CounterAttackPlusPlus => Item::CounterPlusPlus, + Skill::SiphonTick => Item::Siphon, + Skill::SiphonTickPlus => Item::SiphonPlus, + Skill::SiphonTickPlusPlus => Item::SiphonPlusPlus, + Skill::TriageTick => Item::Triage, + Skill::TriageTickPlus => Item::TriagePlus, + Skill::TriageTickPlusPlus => Item::TriagePlusPlus, } } } @@ -1079,66 +1079,66 @@ impl From for Item { fn from(spec: Spec) -> Item { match spec { Spec::Speed => Item::Speed, - Spec::SpeedRRI => Item::SpeedRRI, - Spec::SpeedBBI => Item::SpeedBBI, - Spec::SpeedGGI => Item::SpeedGGI, - Spec::SpeedRGI => Item::SpeedRGI, - Spec::SpeedGBI => Item::SpeedGBI, - Spec::SpeedRBI => Item::SpeedRBI, + Spec::SpeedRR => Item::SpeedRR, + Spec::SpeedBB => Item::SpeedBB, + Spec::SpeedGG => Item::SpeedGG, + Spec::SpeedRG => Item::SpeedRG, + Spec::SpeedGB => Item::SpeedGB, + Spec::SpeedRB => Item::SpeedRB, - Spec::SpeedRRII => Item::SpeedRRII, - Spec::SpeedBBII => Item::SpeedBBII, - Spec::SpeedGGII => Item::SpeedGGII, - Spec::SpeedRGII => Item::SpeedRGII, - Spec::SpeedGBII => Item::SpeedGBII, - Spec::SpeedRBII => Item::SpeedRBII, + Spec::SpeedRRPlus => Item::SpeedRRPlus, + Spec::SpeedBBPlus => Item::SpeedBBPlus, + Spec::SpeedGGPlus => Item::SpeedGGPlus, + Spec::SpeedRGPlus => Item::SpeedRGPlus, + Spec::SpeedGBPlus => Item::SpeedGBPlus, + Spec::SpeedRBPlus => Item::SpeedRBPlus, - Spec::SpeedRRIII => Item::SpeedRRIII, - Spec::SpeedBBIII => Item::SpeedBBIII, - Spec::SpeedGGIII => Item::SpeedGGIII, - Spec::SpeedRGIII => Item::SpeedRGIII, - Spec::SpeedGBIII => Item::SpeedGBIII, - Spec::SpeedRBIII => Item::SpeedRBIII, + Spec::SpeedRRPlusPlus => Item::SpeedRRPlusPlus, + Spec::SpeedBBPlusPlus => Item::SpeedBBPlusPlus, + Spec::SpeedGGPlusPlus => Item::SpeedGGPlusPlus, + Spec::SpeedRGPlusPlus => Item::SpeedRGPlusPlus, + Spec::SpeedGBPlusPlus => Item::SpeedGBPlusPlus, + Spec::SpeedRBPlusPlus => Item::SpeedRBPlusPlus, Spec::Power => Item::Power, - Spec::PowerRRI => Item::PowerRRI, - Spec::PowerBBI => Item::PowerBBI, - Spec::PowerGGI => Item::PowerGGI, - Spec::PowerRGI => Item::PowerRGI, - Spec::PowerGBI => Item::PowerGBI, - Spec::PowerRBI => Item::PowerRBI, - Spec::PowerRRII => Item::PowerRRII, - Spec::PowerBBII => Item::PowerBBII, - Spec::PowerGGII => Item::PowerGGII, - Spec::PowerRGII => Item::PowerRGII, - Spec::PowerGBII => Item::PowerGBII, - Spec::PowerRBII => Item::PowerRBII, - Spec::PowerRRIII => Item::PowerRRIII, - Spec::PowerBBIII => Item::PowerBBIII, - Spec::PowerGGIII => Item::PowerGGIII, - Spec::PowerRGIII => Item::PowerRGIII, - Spec::PowerGBIII => Item::PowerGBIII, - Spec::PowerRBIII => Item::PowerRBIII, + Spec::PowerRR => Item::PowerRR, + Spec::PowerBB => Item::PowerBB, + Spec::PowerGG => Item::PowerGG, + Spec::PowerRG => Item::PowerRG, + Spec::PowerGB => Item::PowerGB, + Spec::PowerRB => Item::PowerRB, + Spec::PowerRRPlus => Item::PowerRRPlus, + Spec::PowerBBPlus => Item::PowerBBPlus, + Spec::PowerGGPlus => Item::PowerGGPlus, + Spec::PowerRGPlus => Item::PowerRGPlus, + Spec::PowerGBPlus => Item::PowerGBPlus, + Spec::PowerRBPlus => Item::PowerRBPlus, + Spec::PowerRRPlusPlus => Item::PowerRRPlusPlus, + Spec::PowerBBPlusPlus => Item::PowerBBPlusPlus, + Spec::PowerGGPlusPlus => Item::PowerGGPlusPlus, + Spec::PowerRGPlusPlus => Item::PowerRGPlusPlus, + Spec::PowerGBPlusPlus => Item::PowerGBPlusPlus, + Spec::PowerRBPlusPlus => Item::PowerRBPlusPlus, Spec::Life => Item::Life, - Spec::LifeRGI => Item::LifeRGI, - Spec::LifeGBI => Item::LifeGBI, - Spec::LifeRBI => Item::LifeRBI, - Spec::LifeGGI => Item::LifeGGI, - Spec::LifeRRI => Item::LifeRRI, - Spec::LifeBBI => Item::LifeBBI, - Spec::LifeRGII => Item::LifeRGII, - Spec::LifeGBII => Item::LifeGBII, - Spec::LifeRBII => Item::LifeRBII, - Spec::LifeGGII => Item::LifeGGII, - Spec::LifeRRII => Item::LifeRRII, - Spec::LifeBBII => Item::LifeBBII, - Spec::LifeRGIII => Item::LifeRGIII, - Spec::LifeGBIII => Item::LifeGBIII, - Spec::LifeRBIII => Item::LifeRBIII, - Spec::LifeGGIII => Item::LifeGGIII, - Spec::LifeRRIII => Item::LifeRRIII, - Spec::LifeBBIII => Item::LifeBBIII, + Spec::LifeRG => Item::LifeRG, + Spec::LifeGB => Item::LifeGB, + Spec::LifeRB => Item::LifeRB, + Spec::LifeGG => Item::LifeGG, + Spec::LifeRR => Item::LifeRR, + Spec::LifeBB => Item::LifeBB, + Spec::LifeRGPlus => Item::LifeRGPlus, + Spec::LifeGBPlus => Item::LifeGBPlus, + Spec::LifeRBPlus => Item::LifeRBPlus, + Spec::LifeGGPlus => Item::LifeGGPlus, + Spec::LifeRRPlus => Item::LifeRRPlus, + Spec::LifeBBPlus => Item::LifeBBPlus, + Spec::LifeRGPlusPlus => Item::LifeRGPlusPlus, + Spec::LifeGBPlusPlus => Item::LifeGBPlusPlus, + Spec::LifeRBPlusPlus => Item::LifeRBPlusPlus, + Spec::LifeGGPlusPlus => Item::LifeGGPlusPlus, + Spec::LifeRRPlusPlus => Item::LifeRRPlusPlus, + Spec::LifeBBPlusPlus => Item::LifeBBPlusPlus, // _ => panic!("{:?} not implemented as a item", spec), } @@ -1154,173 +1154,173 @@ pub struct Combo { pub fn get_combos() -> Vec { let mut combinations = vec![ - Combo { components: Item::InterceptI.combo(), item: Item::InterceptI }, - Combo { components: Item::InterceptII.combo(), item: Item::InterceptII }, - Combo { components: Item::InterceptIII.combo(), item: Item::InterceptIII }, + Combo { components: Item::Intercept.combo(), item: Item::Intercept }, + Combo { components: Item::InterceptPlus.combo(), item: Item::InterceptPlus }, + Combo { components: Item::InterceptPlusPlus.combo(), item: Item::InterceptPlusPlus }, - Combo { components: Item::TriageI.combo(), item: Item::TriageI }, - Combo { components: Item::TriageII.combo(), item: Item::TriageII }, - Combo { components: Item::TriageIII.combo(), item: Item::TriageIII }, + Combo { components: Item::Triage.combo(), item: Item::Triage }, + Combo { components: Item::TriagePlus.combo(), item: Item::TriagePlus }, + Combo { components: Item::TriagePlusPlus.combo(), item: Item::TriagePlusPlus }, - Combo { components: Item::LinkI.combo(), item: Item::LinkI }, - Combo { components: Item::LinkII.combo(), item: Item::LinkII }, - Combo { components: Item::LinkIII.combo(), item: Item::LinkIII }, + Combo { components: Item::Link.combo(), item: Item::Link }, + Combo { components: Item::LinkPlus.combo(), item: Item::LinkPlus }, + Combo { components: Item::LinkPlusPlus.combo(), item: Item::LinkPlusPlus }, - Combo { components: Item::HasteI.combo(), item: Item::HasteI }, - Combo { components: Item::HasteII.combo(), item: Item::HasteII }, - Combo { components: Item::HasteIII.combo(), item: Item::HasteIII }, - Combo { components: Item::AbsorbI.combo(), item: Item::AbsorbI }, - Combo { components: Item::AbsorbII.combo(), item: Item::AbsorbII }, - Combo { components: Item::AbsorbIII.combo(), item: Item::AbsorbIII }, - Combo { components: Item::HybridI.combo(), item: Item::HybridI }, - Combo { components: Item::HybridII.combo(), item: Item::HybridII }, - Combo { components: Item::HybridIII.combo(), item: Item::HybridIII }, + Combo { components: Item::Haste.combo(), item: Item::Haste }, + Combo { components: Item::HastePlus.combo(), item: Item::HastePlus }, + Combo { components: Item::HastePlusPlus.combo(), item: Item::HastePlusPlus }, + Combo { components: Item::Absorb.combo(), item: Item::Absorb }, + Combo { components: Item::AbsorbPlus.combo(), item: Item::AbsorbPlus }, + Combo { components: Item::AbsorbPlusPlus.combo(), item: Item::AbsorbPlusPlus }, + Combo { components: Item::Hybrid.combo(), item: Item::Hybrid }, + Combo { components: Item::HybridPlus.combo(), item: Item::HybridPlus }, + Combo { components: Item::HybridPlusPlus.combo(), item: Item::HybridPlusPlus }, - Combo { components: Item::AmplifyI.combo(), item: Item::AmplifyI }, - Combo { components: Item::AmplifyII.combo(), item: Item::AmplifyII }, - Combo { components: Item::AmplifyIII.combo(), item: Item::AmplifyIII }, + Combo { components: Item::Amplify.combo(), item: Item::Amplify }, + Combo { components: Item::AmplifyPlus.combo(), item: Item::AmplifyPlus }, + Combo { components: Item::AmplifyPlusPlus.combo(), item: Item::AmplifyPlusPlus }, - Combo { components: Item::RestrictI.combo(), item: Item::RestrictI }, - Combo { components: Item::RestrictII.combo(), item: Item::RestrictII }, - Combo { components: Item::RestrictIII.combo(), item: Item::RestrictIII }, - Combo { components: Item::PurgeI.combo(), item: Item::PurgeI }, // Needs flavour - Combo { components: Item::PurgeII.combo(), item: Item::PurgeII }, - Combo { components: Item::PurgeIII.combo(), item: Item::PurgeIII }, + Combo { components: Item::Restrict.combo(), item: Item::Restrict }, + Combo { components: Item::RestrictPlus.combo(), item: Item::RestrictPlus }, + Combo { components: Item::RestrictPlusPlus.combo(), item: Item::RestrictPlusPlus }, + Combo { components: Item::Purge.combo(), item: Item::Purge }, // Needs flavour + Combo { components: Item::PurgePlus.combo(), item: Item::PurgePlus }, + Combo { components: Item::PurgePlusPlus.combo(), item: Item::PurgePlusPlus }, - Combo { components: Item::SilenceI.combo(), item: Item::SilenceI }, - Combo { components: Item::SilenceII.combo(), item: Item::SilenceII }, - Combo { components: Item::SilenceIII.combo(), item: Item::SilenceIII }, + Combo { components: Item::Silence.combo(), item: Item::Silence }, + Combo { components: Item::SilencePlus.combo(), item: Item::SilencePlus }, + Combo { components: Item::SilencePlusPlus.combo(), item: Item::SilencePlusPlus }, - Combo { components: Item::CurseI.combo(), item: Item::CurseI }, - Combo { components: Item::CurseII.combo(), item: Item::CurseII }, - Combo { components: Item::CurseIII.combo(), item: Item::CurseIII }, - Combo { components: Item::DecayI.combo(), item: Item::DecayI }, - Combo { components: Item::DecayII.combo(), item: Item::DecayII }, - Combo { components: Item::DecayIII.combo(), item: Item::DecayIII }, - Combo { components: Item::InvertI.combo(), item: Item::InvertI }, - Combo { components: Item::InvertII.combo(), item: Item::InvertII }, - Combo { components: Item::InvertIII.combo(), item: Item::InvertIII }, + Combo { components: Item::Curse.combo(), item: Item::Curse }, + Combo { components: Item::CursePlus.combo(), item: Item::CursePlus }, + Combo { components: Item::CursePlusPlus.combo(), item: Item::CursePlusPlus }, + Combo { components: Item::Decay.combo(), item: Item::Decay }, + Combo { components: Item::DecayPlus.combo(), item: Item::DecayPlus }, + Combo { components: Item::DecayPlusPlus.combo(), item: Item::DecayPlusPlus }, + Combo { components: Item::Invert.combo(), item: Item::Invert }, + Combo { components: Item::InvertPlus.combo(), item: Item::InvertPlus }, + Combo { components: Item::InvertPlusPlus.combo(), item: Item::InvertPlusPlus }, - Combo { components: Item::CounterI.combo(), item: Item::CounterI }, - Combo { components: Item::CounterII.combo(), item: Item::CounterII }, - Combo { components: Item::CounterIII.combo(), item: Item::CounterIII }, - 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::Counter.combo(), item: Item::Counter }, + Combo { components: Item::CounterPlus.combo(), item: Item::CounterPlus }, + Combo { components: Item::CounterPlusPlus.combo(), item: Item::CounterPlusPlus }, + Combo { components: Item::Purify.combo(), item: Item::Purify }, + Combo { components: Item::PurifyPlus.combo(), item: Item::PurifyPlus }, + Combo { components: Item::PurifyPlusPlus.combo(), item: Item::PurifyPlusPlus }, - 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::Electrify.combo(), item: Item::Electrify }, + Combo { components: Item::ElectrifyPlus.combo(), item: Item::ElectrifyPlus }, + Combo { components: Item::ElectrifyPlusPlus.combo(), item: Item::ElectrifyPlusPlus }, - Combo { components: Item::SustainI.combo(), item: Item::SustainI }, - Combo { components: Item::SustainII.combo(), item: Item::SustainII }, - Combo { components: Item::SustainIII.combo(), item: Item::SustainIII }, - Combo { components: Item::ReflectI.combo(), item: Item::ReflectI }, - Combo { components: Item::ReflectII.combo(), item: Item::ReflectII }, - Combo { components: Item::ReflectIII.combo(), item: Item::ReflectIII }, + Combo { components: Item::Sustain.combo(), item: Item::Sustain }, + Combo { components: Item::SustainPlus.combo(), item: Item::SustainPlus }, + Combo { components: Item::SustainPlusPlus.combo(), item: Item::SustainPlusPlus }, + Combo { components: Item::Reflect.combo(), item: Item::Reflect }, + Combo { components: Item::ReflectPlus.combo(), item: Item::ReflectPlus }, + Combo { components: Item::ReflectPlusPlus.combo(), item: Item::ReflectPlusPlus }, - Combo { components: Item::RechargeI.combo(), item: Item::RechargeI }, - Combo { components: Item::RechargeII.combo(), item: Item::RechargeII }, - Combo { components: Item::RechargeIII.combo(), item: Item::RechargeIII }, + Combo { components: Item::Recharge.combo(), item: Item::Recharge }, + Combo { components: Item::RechargePlus.combo(), item: Item::RechargePlus }, + Combo { components: Item::RechargePlusPlus.combo(), item: Item::RechargePlusPlus }, - Combo { components: Item::BashI.combo(), item: Item::BashI }, - Combo { components: Item::BashII.combo(), item: Item::BashII }, - Combo { components: Item::BashIII.combo(), item: Item::BashIII }, - Combo { components: Item::SleepI.combo(), item: Item::SleepI }, - Combo { components: Item::SleepII.combo(), item: Item::SleepII }, - Combo { components: Item::SleepIII.combo(), item: Item::SleepIII }, - Combo { components: Item::RuinI.combo(), item: Item::RuinI }, - Combo { components: Item::RuinII.combo(), item: Item::RuinII }, - Combo { components: Item::RuinIII.combo(), item: Item::RuinIII }, + Combo { components: Item::Bash.combo(), item: Item::Bash }, + Combo { components: Item::BashPlus.combo(), item: Item::BashPlus }, + Combo { components: Item::BashPlusPlus.combo(), item: Item::BashPlusPlus }, + Combo { components: Item::Sleep.combo(), item: Item::Sleep }, + Combo { components: Item::SleepPlus.combo(), item: Item::SleepPlus }, + Combo { components: Item::SleepPlusPlus.combo(), item: Item::SleepPlusPlus }, + Combo { components: Item::Ruin.combo(), item: Item::Ruin }, + Combo { components: Item::RuinPlus.combo(), item: Item::RuinPlus }, + Combo { components: Item::RuinPlusPlus.combo(), item: Item::RuinPlusPlus }, - Combo { components: Item::BreakI.combo(), item: Item::BreakI }, - Combo { components: Item::BreakII.combo(), item: Item::BreakII }, - Combo { components: Item::BreakIII.combo(), item: Item::BreakIII }, - Combo { components: Item::AbsorbI.combo(), item: Item::AbsorbI }, - Combo { components: Item::AbsorbII.combo(), item: Item::AbsorbII }, - Combo { components: Item::AbsorbIII.combo(), item: Item::AbsorbIII }, - Combo { components: Item::BanishI.combo(), item: Item::BanishI }, - Combo { components: Item::BanishII.combo(), item: Item::BanishII }, - Combo { components: Item::BanishIII.combo(), item: Item::BanishIII }, + Combo { components: Item::Break.combo(), item: Item::Break }, + Combo { components: Item::BreakPlus.combo(), item: Item::BreakPlus }, + Combo { components: Item::BreakPlusPlus.combo(), item: Item::BreakPlusPlus }, + Combo { components: Item::Absorb.combo(), item: Item::Absorb }, + Combo { components: Item::AbsorbPlus.combo(), item: Item::AbsorbPlus }, + Combo { components: Item::AbsorbPlusPlus.combo(), item: Item::AbsorbPlusPlus }, + Combo { components: Item::Banish.combo(), item: Item::Banish }, + Combo { components: Item::BanishPlus.combo(), item: Item::BanishPlus }, + Combo { components: Item::BanishPlusPlus.combo(), item: Item::BanishPlusPlus }, - Combo { components: Item::StrikeI.combo(), item: Item::StrikeI }, - Combo { components: Item::StrikeII.combo(), item: Item::StrikeII }, - Combo { components: Item::StrikeIII.combo(), item: Item::StrikeIII }, + Combo { components: Item::Strike.combo(), item: Item::Strike }, + Combo { components: Item::StrikePlus.combo(), item: Item::StrikePlus }, + Combo { components: Item::StrikePlusPlus.combo(), item: Item::StrikePlusPlus }, - Combo { components: Item::HealI.combo(), item: Item::HealI }, - Combo { components: Item::HealII.combo(), item: Item::HealII }, - Combo { components: Item::HealIII.combo(), item: Item::HealIII }, - Combo { components: Item::BlastI.combo(), item: Item::BlastI }, - Combo { components: Item::BlastII.combo(), item: Item::BlastII }, - Combo { components: Item::BlastIII.combo(), item: Item::BlastIII }, - Combo { components: Item::SlayI.combo(), item: Item::SlayI }, - Combo { components: Item::SlayII.combo(), item: Item::SlayII }, - Combo { components: Item::SlayIII.combo(), item: Item::SlayIII }, - Combo { components: Item::SiphonI.combo(), item: Item::SiphonI }, - Combo { components: Item::SiphonII.combo(), item: Item::SiphonII }, - Combo { components: Item::SiphonIII.combo(), item: Item::SiphonIII }, - Combo { components: Item::ChaosI.combo(), item: Item::ChaosI }, - Combo { components: Item::ChaosII.combo(), item: Item::ChaosII }, - Combo { components: Item::ChaosIII.combo(), item: Item::ChaosIII }, + Combo { components: Item::Heal.combo(), item: Item::Heal }, + Combo { components: Item::HealPlus.combo(), item: Item::HealPlus }, + Combo { components: Item::HealPlusPlus.combo(), item: Item::HealPlusPlus }, + Combo { components: Item::Blast.combo(), item: Item::Blast }, + Combo { components: Item::BlastPlus.combo(), item: Item::BlastPlus }, + Combo { components: Item::BlastPlusPlus.combo(), item: Item::BlastPlusPlus }, + Combo { components: Item::Slay.combo(), item: Item::Slay }, + Combo { components: Item::SlayPlus.combo(), item: Item::SlayPlus }, + Combo { components: Item::SlayPlusPlus.combo(), item: Item::SlayPlusPlus }, + Combo { components: Item::Siphon.combo(), item: Item::Siphon }, + Combo { components: Item::SiphonPlus.combo(), item: Item::SiphonPlus }, + Combo { components: Item::SiphonPlusPlus.combo(), item: Item::SiphonPlusPlus }, + Combo { components: Item::Chaos.combo(), item: Item::Chaos }, + Combo { components: Item::ChaosPlus.combo(), item: Item::ChaosPlus }, + Combo { components: Item::ChaosPlusPlus.combo(), item: Item::ChaosPlusPlus }, - Combo { components: Item::PowerRRI.combo(), item: Item::PowerRRI }, - Combo { components: Item::PowerGGI.combo(), item: Item::PowerGGI }, - Combo { components: Item::PowerBBI.combo(), item: Item::PowerBBI }, - Combo { components: Item::PowerRGI.combo(), item: Item::PowerRGI }, - Combo { components: Item::PowerGBI.combo(), item: Item::PowerGBI }, - Combo { components: Item::PowerRBI.combo(), item: Item::PowerRBI }, - Combo { components: Item::PowerRRII.combo(), item: Item::PowerRRII }, - Combo { components: Item::PowerGGII.combo(), item: Item::PowerGGII }, - Combo { components: Item::PowerBBII.combo(), item: Item::PowerBBII }, - Combo { components: Item::PowerRGII.combo(), item: Item::PowerRGII }, - Combo { components: Item::PowerGBII.combo(), item: Item::PowerGBII }, - Combo { components: Item::PowerRBII.combo(), item: Item::PowerRBII }, - Combo { components: Item::PowerRRIII.combo(), item: Item::PowerRRIII }, - Combo { components: Item::PowerGGIII.combo(), item: Item::PowerGGIII }, - Combo { components: Item::PowerBBIII.combo(), item: Item::PowerBBIII }, - Combo { components: Item::PowerRGIII.combo(), item: Item::PowerRGIII }, - Combo { components: Item::PowerGBIII.combo(), item: Item::PowerGBIII }, - Combo { components: Item::PowerRBIII.combo(), item: Item::PowerRBIII }, + Combo { components: Item::PowerRR.combo(), item: Item::PowerRR }, + Combo { components: Item::PowerGG.combo(), item: Item::PowerGG }, + Combo { components: Item::PowerBB.combo(), item: Item::PowerBB }, + Combo { components: Item::PowerRG.combo(), item: Item::PowerRG }, + Combo { components: Item::PowerGB.combo(), item: Item::PowerGB }, + Combo { components: Item::PowerRB.combo(), item: Item::PowerRB }, + Combo { components: Item::PowerRRPlus.combo(), item: Item::PowerRRPlus }, + Combo { components: Item::PowerGGPlus.combo(), item: Item::PowerGGPlus }, + Combo { components: Item::PowerBBPlus.combo(), item: Item::PowerBBPlus }, + Combo { components: Item::PowerRGPlus.combo(), item: Item::PowerRGPlus }, + Combo { components: Item::PowerGBPlus.combo(), item: Item::PowerGBPlus }, + Combo { components: Item::PowerRBPlus.combo(), item: Item::PowerRBPlus }, + Combo { components: Item::PowerRRPlusPlus.combo(), item: Item::PowerRRPlusPlus }, + Combo { components: Item::PowerGGPlusPlus.combo(), item: Item::PowerGGPlusPlus }, + Combo { components: Item::PowerBBPlusPlus.combo(), item: Item::PowerBBPlusPlus }, + Combo { components: Item::PowerRGPlusPlus.combo(), item: Item::PowerRGPlusPlus }, + Combo { components: Item::PowerGBPlusPlus.combo(), item: Item::PowerGBPlusPlus }, + Combo { components: Item::PowerRBPlusPlus.combo(), item: Item::PowerRBPlusPlus }, - Combo { components: Item::LifeRRI.combo(), item: Item::LifeRRI }, - Combo { components: Item::LifeGGI.combo(), item: Item::LifeGGI }, - Combo { components: Item::LifeBBI.combo(), item: Item::LifeBBI }, - Combo { components: Item::LifeRGI.combo(), item: Item::LifeRGI }, - Combo { components: Item::LifeGBI.combo(), item: Item::LifeGBI }, - Combo { components: Item::LifeRBI.combo(), item: Item::LifeRBI }, - Combo { components: Item::LifeRRII.combo(), item: Item::LifeRRII }, - Combo { components: Item::LifeGGII.combo(), item: Item::LifeGGII }, - Combo { components: Item::LifeBBII.combo(), item: Item::LifeBBII }, - Combo { components: Item::LifeRGII.combo(), item: Item::LifeRGII }, - Combo { components: Item::LifeGBII.combo(), item: Item::LifeGBII }, - Combo { components: Item::LifeRBII.combo(), item: Item::LifeRBII }, - Combo { components: Item::LifeRRIII.combo(), item: Item::LifeRRIII }, - Combo { components: Item::LifeGGIII.combo(), item: Item::LifeGGIII }, - Combo { components: Item::LifeBBIII.combo(), item: Item::LifeBBIII }, - Combo { components: Item::LifeRGIII.combo(), item: Item::LifeRGIII }, - Combo { components: Item::LifeGBIII.combo(), item: Item::LifeGBIII }, - Combo { components: Item::LifeRBIII.combo(), item: Item::LifeRBIII }, + Combo { components: Item::LifeRR.combo(), item: Item::LifeRR}, + Combo { components: Item::LifeGG.combo(), item: Item::LifeGG}, + Combo { components: Item::LifeBB.combo(), item: Item::LifeBB}, + Combo { components: Item::LifeRG.combo(), item: Item::LifeRG}, + Combo { components: Item::LifeGB.combo(), item: Item::LifeGB}, + Combo { components: Item::LifeRB.combo(), item: Item::LifeRB}, + Combo { components: Item::LifeRRPlus.combo(), item: Item::LifeRRPlus }, + Combo { components: Item::LifeGGPlus.combo(), item: Item::LifeGGPlus }, + Combo { components: Item::LifeBBPlus.combo(), item: Item::LifeBBPlus }, + Combo { components: Item::LifeRGPlus.combo(), item: Item::LifeRGPlus }, + Combo { components: Item::LifeGBPlus.combo(), item: Item::LifeGBPlus }, + Combo { components: Item::LifeRBPlus.combo(), item: Item::LifeRBPlus }, + Combo { components: Item::LifeRRPlusPlus.combo(), item: Item::LifeRRPlusPlus }, + Combo { components: Item::LifeGGPlusPlus.combo(), item: Item::LifeGGPlusPlus }, + Combo { components: Item::LifeBBPlusPlus.combo(), item: Item::LifeBBPlusPlus }, + Combo { components: Item::LifeRGPlusPlus.combo(), item: Item::LifeRGPlusPlus }, + Combo { components: Item::LifeGBPlusPlus.combo(), item: Item::LifeGBPlusPlus }, + Combo { components: Item::LifeRBPlusPlus.combo(), item: Item::LifeRBPlusPlus }, - Combo { components: Item::SpeedRRI.combo(), item: Item::SpeedRRI }, - Combo { components: Item::SpeedGGI.combo(), item: Item::SpeedGGI }, - Combo { components: Item::SpeedBBI.combo(), item: Item::SpeedBBI }, - Combo { components: Item::SpeedRGI.combo(), item: Item::SpeedRGI }, - Combo { components: Item::SpeedGBI.combo(), item: Item::SpeedGBI }, - Combo { components: Item::SpeedRBI.combo(), item: Item::SpeedRBI }, - Combo { components: Item::SpeedRRII.combo(), item: Item::SpeedRRII }, - Combo { components: Item::SpeedGGII.combo(), item: Item::SpeedGGII }, - Combo { components: Item::SpeedBBII.combo(), item: Item::SpeedBBII }, - Combo { components: Item::SpeedRGII.combo(), item: Item::SpeedRGII }, - Combo { components: Item::SpeedGBII.combo(), item: Item::SpeedGBII }, - Combo { components: Item::SpeedRBII.combo(), item: Item::SpeedRBII }, - Combo { components: Item::SpeedRRIII.combo(), item: Item::SpeedRRIII }, - Combo { components: Item::SpeedGGIII.combo(), item: Item::SpeedGGIII }, - Combo { components: Item::SpeedBBIII.combo(), item: Item::SpeedBBIII }, - Combo { components: Item::SpeedRGIII.combo(), item: Item::SpeedRGIII }, - Combo { components: Item::SpeedGBIII.combo(), item: Item::SpeedGBIII }, - Combo { components: Item::SpeedRBIII.combo(), item: Item::SpeedRBIII }, + Combo { components: Item::SpeedRR.combo(), item: Item::SpeedRR}, + Combo { components: Item::SpeedGG.combo(), item: Item::SpeedGG}, + Combo { components: Item::SpeedBB.combo(), item: Item::SpeedBB}, + Combo { components: Item::SpeedRG.combo(), item: Item::SpeedRG}, + Combo { components: Item::SpeedGB.combo(), item: Item::SpeedGB}, + Combo { components: Item::SpeedRB.combo(), item: Item::SpeedRB}, + Combo { components: Item::SpeedRRPlus.combo(), item: Item::SpeedRRPlus }, + Combo { components: Item::SpeedGGPlus.combo(), item: Item::SpeedGGPlus }, + Combo { components: Item::SpeedBBPlus.combo(), item: Item::SpeedBBPlus }, + Combo { components: Item::SpeedRGPlus.combo(), item: Item::SpeedRGPlus }, + Combo { components: Item::SpeedGBPlus.combo(), item: Item::SpeedGBPlus }, + Combo { components: Item::SpeedRBPlus.combo(), item: Item::SpeedRBPlus }, + Combo { components: Item::SpeedRRPlusPlus.combo(), item: Item::SpeedRRPlusPlus }, + Combo { components: Item::SpeedGGPlusPlus.combo(), item: Item::SpeedGGPlusPlus }, + Combo { components: Item::SpeedBBPlusPlus.combo(), item: Item::SpeedBBPlusPlus }, + Combo { components: Item::SpeedRGPlusPlus.combo(), item: Item::SpeedRGPlusPlus }, + Combo { components: Item::SpeedGBPlusPlus.combo(), item: Item::SpeedGBPlusPlus }, + Combo { components: Item::SpeedRBPlusPlus.combo(), item: Item::SpeedRBPlusPlus }, ]; combinations.iter_mut().for_each(|set| set.components.sort_unstable()); @@ -1385,13 +1385,13 @@ mod tests { #[test] fn item_components_test() { - assert_eq!(Item::StrikeI.components(), vec![Item::Red, Item::Red, Item::Attack]); - assert_eq!(Item::StrikeII.components(), vec![ + assert_eq!(Item::Strike.components(), vec![Item::Red, Item::Red, Item::Attack]); + assert_eq!(Item::StrikePlus.components(), vec![ Item::Red, Item::Red, Item::Attack, Item::Red, Item::Red, Item::Attack, Item::Red, Item::Red, Item::Attack, ]); - assert_eq!(Item::StrikeIII.components(), vec![ + assert_eq!(Item::StrikePlusPlus.components(), vec![ Item::Red, Item::Red, Item::Attack, Item::Red, Item::Red, Item::Attack, Item::Red, Item::Red, Item::Attack, diff --git a/server/src/skill.rs b/server/src/skill.rs index 206a3f83..949360f8 100644 --- a/server/src/skill.rs +++ b/server/src/skill.rs @@ -90,9 +90,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() @@ -104,9 +104,9 @@ pub fn resolve(skill: Skill, source: &mut Construct, target: &mut Construct, mut if source.affected(Effect::Hybrid) { match skill { - Skill::BlastI | - Skill::ChaosI | - Skill::SiphonI => { + Skill::Blast| + Skill::Chaos| + Skill::Siphon=> { let amount = source.green_power().pct(Skill::HybridBlast.multiplier()); target.deal_blue_damage(Skill::HybridBlast, amount) .into_iter() @@ -127,142 +127,142 @@ 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::Amplify| + Skill::AmplifyPlus | + Skill::AmplifyPlusPlus => amplify(source, target, resolutions, skill), - Skill::BanishI | - Skill::BanishII | - Skill::BanishIII => banish(source, target, resolutions, skill), + Skill::Banish| + Skill::BanishPlus | + Skill::BanishPlusPlus => banish(source, target, resolutions, skill), - Skill::BashI | - Skill::BashII | - Skill::BashIII => bash(source, target, resolutions, skill), + Skill::Bash| + Skill::BashPlus | + Skill::BashPlusPlus => bash(source, target, resolutions, skill), - Skill::BlastI | - Skill::BlastII | - Skill::BlastIII => blast(source, target, resolutions, skill), + Skill::Blast| + Skill::BlastPlus | + Skill::BlastPlusPlus => blast(source, target, resolutions, skill), - Skill::ChaosI | - Skill::ChaosII | - Skill::ChaosIII => chaos(source, target, resolutions, skill), + Skill::Chaos| + Skill::ChaosPlus | + Skill::ChaosPlusPlus => chaos(source, target, resolutions, skill), - Skill::SustainI | - Skill::SustainII | - Skill::SustainIII => sustain(source, target, resolutions, skill), + Skill::Sustain| + Skill::SustainPlus | + Skill::SustainPlusPlus => sustain(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::Electrify| + Skill::ElectrifyPlus | + Skill::ElectrifyPlusPlus => electrify(source, target, resolutions, skill), + Skill::ElectrocuteTick| + Skill::ElectrocuteTickPlus | + Skill::ElectrocuteTickPlusPlus => electrocute_tick(source, target, resolutions, skill), - Skill::CurseI | - Skill::CurseII | - Skill::CurseIII => curse(source, target, resolutions, skill), + Skill::Curse| + Skill::CursePlus | + Skill::CursePlusPlus => 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::Decay| + Skill::DecayPlus | + Skill::DecayPlusPlus => decay(source, target, resolutions, skill), // dot + Skill::DecayTick| + Skill::DecayTickPlus | + Skill::DecayTickPlusPlus => decay_tick(source, target, resolutions, skill), // dot - Skill::HasteI | - Skill::HasteII | - Skill::HasteIII => haste(source, target, resolutions, skill), // speed slow + Skill::Haste| + Skill::HastePlus | + Skill::HastePlusPlus => haste(source, target, resolutions, skill), // speed slow - Skill::HealI | - Skill::HealII | - Skill::HealIII => heal(source, target, resolutions, skill), + Skill::Heal| + Skill::HealPlus | + Skill::HealPlusPlus => heal(source, target, resolutions, skill), - Skill::HexI | - Skill::HexII | - Skill::HexIII => hex(source, target, resolutions, skill), + Skill::Hex| + Skill::HexPlus | + Skill::HexPlusPlus => hex(source, target, resolutions, skill), - Skill::AbsorbI | - Skill::AbsorbII | - Skill::AbsorbIII => absorb(source, target, resolutions, skill), + Skill::Absorb| + Skill::AbsorbPlus | + Skill::AbsorbPlusPlus => absorb(source, target, resolutions, skill), - Skill::HybridI | - Skill::HybridII | - Skill::HybridIII => hybrid(source, target, resolutions, skill), + Skill::Hybrid| + Skill::HybridPlus | + Skill::HybridPlusPlus => hybrid(source, target, resolutions, skill), - Skill::InvertI | - Skill::InvertII | - Skill::InvertIII => invert(source, target, resolutions, skill), + Skill::Invert| + Skill::InvertPlus | + Skill::InvertPlusPlus => invert(source, target, resolutions, skill), - Skill::CounterI | - Skill::CounterII | - Skill::CounterIII => counter(source, target, resolutions, skill), + Skill::Counter| + Skill::CounterPlus | + Skill::CounterPlusPlus => counter(source, target, resolutions, skill), - Skill::PurgeI | - Skill::PurgeII | - Skill::PurgeIII => purge(source, target, resolutions, skill), // dispel all buffs + Skill::Purge| + Skill::PurgePlus | + Skill::PurgePlusPlus => purge(source, target, resolutions, skill), // dispel all buffs - Skill::PurifyI | - Skill::PurifyII | - Skill::PurifyIII => purify(source, target, resolutions, skill), + Skill::Purify| + Skill::PurifyPlus | + Skill::PurifyPlusPlus => purify(source, target, resolutions, skill), - Skill::RechargeI | - Skill::RechargeII | - Skill::RechargeIII => recharge(source, target, resolutions, skill), + Skill::Recharge| + Skill::RechargePlus | + Skill::RechargePlusPlus => recharge(source, target, resolutions, skill), - Skill::ReflectI | - Skill::ReflectII | - Skill::ReflectIII => reflect(source, target, resolutions, skill), + Skill::Reflect| + Skill::ReflectPlus | + Skill::ReflectPlusPlus => reflect(source, target, resolutions, skill), - Skill::RuinI | - Skill::RuinII | - Skill::RuinIII => ruin(source, target, resolutions, skill), + Skill::Ruin| + Skill::RuinPlus | + Skill::RuinPlusPlus => ruin(source, target, resolutions, skill), - Skill::LinkI | - Skill::LinkII | - Skill::LinkIII => link(source, target, resolutions, skill), // target is immune to magic damage and fx + Skill::Link| + Skill::LinkPlus | + Skill::LinkPlusPlus => link(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::Silence| + Skill::SilencePlus | + Skill::SilencePlusPlus => 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::Siphon| + Skill::SiphonPlus | + Skill::SiphonPlusPlus => siphon(source, target, resolutions, skill), // dot + Skill::SiphonTick| + Skill::SiphonTickPlus | + Skill::SiphonTickPlusPlus => siphon_tick(source, target, resolutions, skill), // dot - Skill::SlayI | - Skill::SlayII | - Skill::SlayIII => slay(source, target, resolutions, skill), // hybrid dmg self heal + Skill::Slay| + Skill::SlayPlus | + Skill::SlayPlusPlus => slay(source, target, resolutions, skill), // hybrid dmg self heal - Skill::SleepI | - Skill::SleepII | - Skill::SleepIII => sleep(source, target, resolutions, skill), // heal stun + Skill::Sleep| + Skill::SleepPlus | + Skill::SleepPlusPlus => sleep(source, target, resolutions, skill), // heal stun - Skill::RestrictI | - Skill::RestrictII | - Skill::RestrictIII => restrict(source, target, resolutions, skill), + Skill::Restrict| + Skill::RestrictPlus | + Skill::RestrictPlusPlus => restrict(source, target, resolutions, skill), - Skill::StrikeI | - Skill::StrikeII | - Skill::StrikeIII => strike(source, target, resolutions, skill), + Skill::Strike| + Skill::StrikePlus | + Skill::StrikePlusPlus => strike(source, target, resolutions, skill), - Skill::InterceptI | - Skill::InterceptII | - Skill::InterceptIII => intercept(source, target, resolutions, skill), + Skill::Intercept| + Skill::InterceptPlus | + Skill::InterceptPlusPlus => intercept(source, target, resolutions, skill), - Skill::BreakI | - Skill::BreakII | - Skill::BreakIII => break_(source, target, resolutions, skill), // no damage stun, adds vulnerable + Skill::Break| + Skill::BreakPlus | + Skill::BreakPlusPlus => break_(source, target, resolutions, skill), // no damage stun, adds vulnerable - Skill::TriageI | - Skill::TriageII | - Skill::TriageIII => triage(source, target, resolutions, skill), // hot + Skill::Triage| + Skill::TriagePlus | + Skill::TriagePlusPlus => triage(source, target, resolutions, skill), // hot - Skill::TriageTickI | - Skill::TriageTickII | - Skill::TriageTickIII => triage_tick(source, target, resolutions, skill), // hot + Skill::TriageTick| + Skill::TriageTickPlus | + Skill::TriageTickPlusPlus => triage_tick(source, target, resolutions, skill), // hot // Base Skills Skill::Attack => attack(source, target, resolutions, skill), @@ -272,17 +272,17 @@ pub fn resolve(skill: Skill, source: &mut Construct, target: &mut Construct, mut Skill::Stun => stun(source, target, resolutions, skill), //Triggered - Skill::ElectrocuteI | - Skill::ElectrocuteII | - Skill::ElectrocuteIII => panic!("should only trigger from electrify hit"), + Skill::Electrocute| + Skill::ElectrocutePlus | + Skill::ElectrocutePlusPlus => panic!("should only trigger from electrify hit"), Skill::HasteStrike => panic!("should only trigger from haste"), - Skill::AbsorptionI | - Skill::AbsorptionII | - Skill::AbsorptionIII => panic!("should only trigger from absorb"), + Skill::Absorption| + Skill::AbsorptionPlus | + Skill::AbsorptionPlusPlus => panic!("should only trigger from absorb"), Skill::HybridBlast => panic!("should only trigger from hybrid"), - Skill::CounterAttackI | - Skill::CounterAttackII | - Skill::CounterAttackIII => panic!("should only trigger from counter"), + Skill::CounterAttack| + Skill::CounterAttackPlus | + Skill::CounterAttackPlusPlus => panic!("should only trigger from counter"), // Not used @@ -492,153 +492,153 @@ pub enum Skill { // Evade, // actively evade // Nightmare, // Sleep, - AmplifyI, - AmplifyII, - AmplifyIII, + Amplify, + AmplifyPlus, + AmplifyPlusPlus, - BanishI, - BanishII, - BanishIII, + Banish, + BanishPlus, + BanishPlusPlus, - BashI, - BashII, - BashIII, + Bash, + BashPlus, + BashPlusPlus, - BlastI, - BlastII, - BlastIII, + Blast, + BlastPlus, + BlastPlusPlus, - ChaosI, - ChaosII, - ChaosIII, + Chaos, + ChaosPlus, + ChaosPlusPlus, - SustainI, - SustainII, - SustainIII, + Sustain, + SustainPlus, + SustainPlusPlus, - ElectrifyI, - ElectrifyII, - ElectrifyIII, - ElectrocuteI, - ElectrocuteII, - ElectrocuteIII, - ElectrocuteTickI, - ElectrocuteTickII, - ElectrocuteTickIII, + Electrify, + ElectrifyPlus, + ElectrifyPlusPlus, + Electrocute, + ElectrocutePlus, + ElectrocutePlusPlus, + ElectrocuteTick, + ElectrocuteTickPlus, + ElectrocuteTickPlusPlus, - CurseI, - CurseII, - CurseIII, + Curse, + CursePlus, + CursePlusPlus, - DecayI, // dot - DecayII, - DecayIII, - DecayTickI, // dot - DecayTickII, - DecayTickIII, + Decay, // dot + DecayPlus, + DecayPlusPlus, + DecayTick, // dot + DecayTickPlus, + DecayTickPlusPlus, - HasteI, - HasteII, - HasteIII, + Haste, + HastePlus, + HastePlusPlus, HasteStrike, - HealI, - HealII, - HealIII, + Heal, + HealPlus, + HealPlusPlus, - HexI, - HexII, - HexIII, + Hex, + HexPlus, + HexPlusPlus, - AbsorptionI, - AbsorptionII, - AbsorptionIII, - AbsorbI, - AbsorbII, - AbsorbIII, + Absorption, + AbsorptionPlus, + AbsorptionPlusPlus, + Absorb, + AbsorbPlus, + AbsorbPlusPlus, HybridBlast, - HybridI, - HybridII, - HybridIII, + Hybrid, + HybridPlus, + HybridPlusPlus, - InvertI, - InvertII, - InvertIII, + Invert, + InvertPlus, + InvertPlusPlus, - CounterI, // avoid all damage - CounterII, - CounterIII, - PurgeI, - PurgeII, - PurgeIII, + Counter, // avoid all damage + CounterPlus, + CounterPlusPlus, + Purge, + PurgePlus, + PurgePlusPlus, - PurifyI, - PurifyII, - PurifyIII, + Purify, + PurifyPlus, + PurifyPlusPlus, - RechargeI, - RechargeII, - RechargeIII, + Recharge, + RechargePlus, + RechargePlusPlus, - ReflectI, - ReflectII, - ReflectIII, + Reflect, + ReflectPlus, + ReflectPlusPlus, - CounterAttackI, - CounterAttackII, - CounterAttackIII, + CounterAttack, + CounterAttackPlus, + CounterAttackPlusPlus, - RuinI, - RuinII, - RuinIII, + Ruin, + RuinPlus, + RuinPlusPlus, - LinkI, - LinkII, - LinkIII, + Link, + LinkPlus, + LinkPlusPlus, - SilenceI, - SilenceII, - SilenceIII, + Silence, + SilencePlus, + SilencePlusPlus, - SiphonI, - SiphonII, - SiphonIII, - SiphonTickI, - SiphonTickII, - SiphonTickIII, + Siphon, + SiphonPlus, + SiphonPlusPlus, + SiphonTick, + SiphonTickPlus, + SiphonTickPlusPlus, - SlayI, - SlayII, - SlayIII, + Slay, + SlayPlus, + SlayPlusPlus, - SleepI, - SleepII, - SleepIII, + Sleep, + SleepPlus, + SleepPlusPlus, - RestrictI, - RestrictII, - RestrictIII, + Restrict, + RestrictPlus, + RestrictPlusPlus, - StrikeI, - StrikeII, - StrikeIII, + Strike, + StrikePlus, + StrikePlusPlus, - InterceptI, - InterceptII, - InterceptIII, + Intercept, + InterceptPlus, + InterceptPlusPlus, - BreakI, // no damage stun, adds vulnerable - BreakII, - BreakIII, + Break, // no damage stun, adds vulnerable + BreakPlus, + BreakPlusPlus, - TriageI, // hot - TriageII, - TriageIII, + Triage, // hot + TriagePlus, + TriagePlusPlus, - TriageTickI, - TriageTickII, - TriageTickIII, + TriageTick, + TriageTickPlus, + TriageTickPlusPlus, } impl Skill { @@ -647,85 +647,85 @@ impl Skill { // Attack Base Skill::Attack => 80, // Base - Skill::BlastI => 110, // BB - Skill::BlastII => 130, // BB - Skill::BlastIII => 150, // BB + Skill::Blast=> 110, // BB + Skill::BlastPlus => 130, // BB + Skill::BlastPlusPlus => 150, // BB - Skill::ChaosI => 40, // BR - Skill::ChaosII => 50, // BR - Skill::ChaosIII => 60, // BR + Skill::Chaos=> 40, // BR + Skill::ChaosPlus => 50, // BR + Skill::ChaosPlusPlus => 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::Heal=> 130, //GG + Skill::HealPlus => 160, //GG + Skill::HealPlusPlus => 200, //GG + Skill::SiphonTick=> 40, // GB + Skill::SiphonTickPlus => 70, + Skill::SiphonTickPlusPlus => 110, - Skill::SlayI => 70, // RG - Skill::SlayII => 90, - Skill::SlayIII => 120, + Skill::Slay=> 70, // RG + Skill::SlayPlus => 90, + Skill::SlayPlusPlus => 120, - Skill::StrikeI => 90, //RR - Skill::StrikeII => 110, - Skill::StrikeIII => 140, + Skill::Strike=> 90, //RR + Skill::StrikePlus => 110, + Skill::StrikePlusPlus => 140, // Block Base - Skill::ElectrocuteTickI => 80, - Skill::ElectrocuteTickII => 100, - Skill::ElectrocuteTickIII => 130, + Skill::ElectrocuteTick=> 80, + Skill::ElectrocuteTickPlus => 100, + Skill::ElectrocuteTickPlusPlus => 130, - Skill::CounterI => 110, - Skill::CounterII => 145, - Skill::CounterIII => 200, - Skill::CounterAttackI => 70, - Skill::CounterAttackII => 95, - Skill::CounterAttackIII => 120, + Skill::Counter=> 110, + Skill::CounterPlus => 145, + Skill::CounterPlusPlus => 200, + Skill::CounterAttack=> 70, + Skill::CounterAttackPlus => 95, + Skill::CounterAttackPlusPlus => 120, - Skill::PurifyI => 45, //Green dmg (heal) - Skill::PurifyII => 70, - Skill::PurifyIII => 105, + Skill::Purify=> 45, //Green dmg (heal) + Skill::PurifyPlus => 70, + Skill::PurifyPlusPlus => 105, - Skill::ReflectI => 45, //restore blue life (heal) - Skill::ReflectII => 70, - Skill::ReflectIII => 100, + Skill::Reflect=> 45, //restore blue life (heal) + Skill::ReflectPlus => 70, + Skill::ReflectPlusPlus => 100, - Skill::RechargeI => 85, //restore red and blue life (heal) - Skill::RechargeII => 130, - Skill::RechargeIII => 200, + Skill::Recharge=> 85, //restore red and blue life (heal) + Skill::RechargePlus => 130, + Skill::RechargePlusPlus => 200, // Stun Base - Skill::SleepI => 240, //Green dmg (heal) - Skill::SleepII => 300, - Skill::SleepIII => 400, + Skill::Sleep=> 240, //Green dmg (heal) + Skill::SleepPlus => 300, + Skill::SleepPlusPlus => 400, - Skill::BashI => 65, - Skill::BashII => 95, - Skill::BashIII => 140, + Skill::Bash=> 65, + Skill::BashPlus => 95, + Skill::BashPlusPlus => 140, // 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::RestrictI => 40, // Deals more per red skill on target - Skill::RestrictII => 65, - Skill::RestrictIII => 100, + Skill::DecayTick=> 25, + Skill::DecayTickPlus => 45, + Skill::DecayTickPlusPlus => 70, + Skill::Silence=> 55, // Deals more per blue skill on target + Skill::SilencePlus => 80, + Skill::SilencePlusPlus => 110, + Skill::Restrict=> 40, // Deals more per red skill on target + Skill::RestrictPlus => 65, + Skill::RestrictPlusPlus => 100, // Buff base Skill::HybridBlast => 25, Skill::HasteStrike => 30, - Skill::LinkI => 140, - Skill::LinkII => 200, - Skill::LinkIII => 300, - Skill::InterceptI => 80, - Skill::InterceptII => 110, - Skill::InterceptIII => 150, - Skill::TriageTickI => 75, - Skill::TriageTickII => 110, - Skill::TriageTickIII => 140, + Skill::Link=> 140, + Skill::LinkPlus => 200, + Skill::LinkPlusPlus => 300, + Skill::Intercept=> 80, + Skill::InterceptPlus => 110, + Skill::InterceptPlusPlus => 150, + Skill::TriageTick=> 75, + Skill::TriageTickPlus => 110, + Skill::TriageTickPlusPlus => 140, _ => 100, } @@ -734,157 +734,157 @@ impl Skill { pub fn effect(&self) -> Vec { match self { // Modifiers - Skill::AmplifyI => vec![ConstructEffect {effect: Effect::Amplify, duration: 2, + Skill::Amplify => vec![ConstructEffect {effect: Effect::Amplify, duration: 2, meta: Some(EffectMeta::Multiplier(150)), tick: None}], - Skill::AmplifyII => vec![ConstructEffect {effect: Effect::Amplify, duration: 3, + Skill::AmplifyPlus => vec![ConstructEffect {effect: Effect::Amplify, duration: 3, meta: Some(EffectMeta::Multiplier(175)), tick: None}], - Skill::AmplifyIII => vec![ConstructEffect {effect: Effect::Amplify, duration: 4, + Skill::AmplifyPlusPlus => vec![ConstructEffect {effect: Effect::Amplify, duration: 4, meta: Some(EffectMeta::Multiplier(200)), 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::Banish => vec![ConstructEffect {effect: Effect::Banish, duration: 1,meta: None, tick: None}], + Skill::BanishPlus => vec![ConstructEffect {effect: Effect::Banish, duration: 2,meta: None, tick: None}], + Skill::BanishPlusPlus => 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::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::Electrify => vec![ConstructEffect {effect: Effect::Electric, duration: 2, + meta: Some(EffectMeta::Skill(Skill::Electrocute)), tick: None}], + Skill::ElectrifyPlus => vec![ConstructEffect {effect: Effect::Electric, duration: 3, + meta: Some(EffectMeta::Skill(Skill::ElectrocutePlus)), tick: None}], + Skill::ElectrifyPlusPlus => vec![ConstructEffect {effect: Effect::Electric, duration: 4, + meta: Some(EffectMeta::Skill(Skill::ElectrocutePlusPlus)), tick: None}], + Skill::Electrocute => vec![ConstructEffect {effect: Effect::Electrocute, duration: 3, + meta: Some(EffectMeta::Skill(Skill::ElectrocuteTick)), tick: None}], + Skill::ElectrocutePlus => vec![ConstructEffect {effect: Effect::Electrocute, duration: 4, + meta: Some(EffectMeta::Skill(Skill::ElectrocuteTickPlus)), tick: None}], + Skill::ElectrocutePlusPlus => vec![ConstructEffect {effect: Effect::Electrocute, duration: 5, + meta: Some(EffectMeta::Skill(Skill::ElectrocuteTickPlusPlus)), tick: None}], - Skill::SustainI => vec![ConstructEffect {effect: Effect::Sustain, duration: 1, meta: None, tick: None }], - Skill::SustainII => vec![ConstructEffect {effect: Effect::Sustain, duration: 2, meta: None, tick: None }], - Skill::SustainIII => vec![ConstructEffect {effect: Effect::Sustain, duration: 3, meta: None, tick: None }], + Skill::Sustain => vec![ConstructEffect {effect: Effect::Sustain, duration: 1, meta: None, tick: None }], + Skill::SustainPlus => vec![ConstructEffect {effect: Effect::Sustain, duration: 2, meta: None, tick: None }], + Skill::SustainPlusPlus => vec![ConstructEffect {effect: Effect::Sustain, duration: 3, meta: None, tick: None }], - Skill::CurseI => vec![ConstructEffect {effect: Effect::Curse, duration: 2, + Skill::Curse => vec![ConstructEffect {effect: Effect::Curse, duration: 2, meta: Some(EffectMeta::Multiplier(150)), tick: None}], - Skill::CurseII => vec![ConstructEffect {effect: Effect::Curse, duration: 2, + Skill::CursePlus => vec![ConstructEffect {effect: Effect::Curse, duration: 2, meta: Some(EffectMeta::Multiplier(200)), tick: None}], - Skill::CurseIII => vec![ConstructEffect {effect: Effect::Curse, duration: 3, + Skill::CursePlusPlus => vec![ConstructEffect {effect: Effect::Curse, duration: 3, meta: Some(EffectMeta::Multiplier(250)), 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 }, + Skill::Decay => 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 }, + meta: Some(EffectMeta::Skill(Skill::DecayTick)), tick: None}], + Skill::DecayPlus => 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 }, + meta: Some(EffectMeta::Skill(Skill::DecayTickPlus)), tick: None}], + Skill::DecayPlusPlus => 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}], + meta: Some(EffectMeta::Skill(Skill::DecayTickPlusPlus)), tick: None}], - Skill::HasteI => vec![ConstructEffect {effect: Effect::Haste, duration: 2, + Skill::Haste => vec![ConstructEffect {effect: Effect::Haste, duration: 2, meta: Some(EffectMeta::Multiplier(150)), tick: None }], - Skill::HasteII => vec![ConstructEffect {effect: Effect::Haste, duration: 3, + Skill::HastePlus => vec![ConstructEffect {effect: Effect::Haste, duration: 3, meta: Some(EffectMeta::Multiplier(175)), tick: None }], - Skill::HasteIII => vec![ConstructEffect {effect: Effect::Haste, duration: 4, + Skill::HastePlusPlus => 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::Hex => vec![ConstructEffect {effect: Effect::Hex, duration: 2, meta: None, tick: None}], + Skill::HexPlus => vec![ConstructEffect {effect: Effect::Hex, duration: 3, meta: None, tick: None}], + Skill::HexPlusPlus => vec![ConstructEffect {effect: Effect::Hex, duration: 4, meta: None, tick: None}], - Skill::AbsorbI => vec![ConstructEffect {effect: Effect::Absorb, duration: 2, - meta: Some(EffectMeta::Skill(Skill::AbsorptionI)), tick: None}], - Skill::AbsorbII => vec![ConstructEffect {effect: Effect::Absorb, duration: 3, - meta: Some(EffectMeta::Skill(Skill::AbsorptionII)), tick: None}], - Skill::AbsorbIII => vec![ConstructEffect {effect: Effect::Absorb, duration: 4, - meta: Some(EffectMeta::Skill(Skill::AbsorptionIII)), tick: None}], + Skill::Absorb => vec![ConstructEffect {effect: Effect::Absorb, duration: 2, + meta: Some(EffectMeta::Skill(Skill::Absorption)), tick: None}], + Skill::AbsorbPlus => vec![ConstructEffect {effect: Effect::Absorb, duration: 3, + meta: Some(EffectMeta::Skill(Skill::AbsorptionPlus)), tick: None}], + Skill::AbsorbPlusPlus => vec![ConstructEffect {effect: Effect::Absorb, duration: 4, + meta: Some(EffectMeta::Skill(Skill::AbsorptionPlusPlus)), tick: None}], - Skill::AbsorptionI => vec![ConstructEffect {effect: Effect::Absorption, duration: 5, meta: None, tick: None}], - Skill::AbsorptionII => vec![ConstructEffect {effect: Effect::Absorption, duration: 7, meta: None, tick: None}], - Skill::AbsorptionIII => vec![ConstructEffect {effect: Effect::Absorption, duration: 9, meta: None, tick: None}], + Skill::Absorption => vec![ConstructEffect {effect: Effect::Absorption, duration: 5, meta: None, tick: None}], + Skill::AbsorptionPlus => vec![ConstructEffect {effect: Effect::Absorption, duration: 7, meta: None, tick: None}], + Skill::AbsorptionPlusPlus => vec![ConstructEffect {effect: Effect::Absorption, duration: 9, meta: None, tick: None}], - Skill::HybridI => vec![ConstructEffect {effect: Effect::Hybrid, duration: 2, + Skill::Hybrid => vec![ConstructEffect {effect: Effect::Hybrid, duration: 2, meta: Some(EffectMeta::Multiplier(150)), tick: None }], - Skill::HybridII => vec![ConstructEffect {effect: Effect::Hybrid, duration: 3, + Skill::HybridPlus => vec![ConstructEffect {effect: Effect::Hybrid, duration: 3, meta: Some(EffectMeta::Multiplier(175)), tick: None }], - Skill::HybridIII => vec![ConstructEffect {effect: Effect::Hybrid, duration: 4, + Skill::HybridPlusPlus => vec![ConstructEffect {effect: Effect::Hybrid, duration: 4, meta: Some(EffectMeta::Multiplier(225)), 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::Invert => vec![ConstructEffect {effect: Effect::Invert, duration: 2, meta: None, tick: None}], + Skill::InvertPlus => vec![ConstructEffect {effect: Effect::Invert, duration: 3, meta: None, tick: None}], + Skill::InvertPlusPlus => vec![ConstructEffect {effect: Effect::Invert, duration: 4, meta: None, tick: None}], - Skill::CounterI => vec![ConstructEffect {effect: Effect::Counter, duration: 2, - meta: Some(EffectMeta::Skill(Skill::CounterAttackI)), tick: None}], - Skill::CounterII => vec![ConstructEffect {effect: Effect::Counter, duration: 2, - meta: Some(EffectMeta::Skill(Skill::CounterAttackII)), tick: None}], - Skill::CounterIII => vec![ConstructEffect {effect: Effect::Counter, duration: 2, - meta: Some(EffectMeta::Skill(Skill::CounterAttackIII)), tick: None}], + Skill::Counter => vec![ConstructEffect {effect: Effect::Counter, duration: 2, + meta: Some(EffectMeta::Skill(Skill::CounterAttack)), tick: None}], + Skill::CounterPlus => vec![ConstructEffect {effect: Effect::Counter, duration: 2, + meta: Some(EffectMeta::Skill(Skill::CounterAttackPlus)), tick: None}], + Skill::CounterPlusPlus => vec![ConstructEffect {effect: Effect::Counter, duration: 2, + meta: Some(EffectMeta::Skill(Skill::CounterAttackPlusPlus)), 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::Reflect => vec![ConstructEffect {effect: Effect::Reflect, duration: 1, meta: None, tick: None }], + Skill::ReflectPlus => vec![ConstructEffect {effect: Effect::Reflect, duration: 2, meta: None, tick: None }], + Skill::ReflectPlusPlus => vec![ConstructEffect {effect: Effect::Reflect, duration: 3, meta: None, tick: None }], - Skill::BreakI => vec![ConstructEffect {effect: Effect::Stun, duration: 1, meta: None, tick: None}, + Skill::Break => 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::BreakII => vec![ConstructEffect {effect: Effect::Stun, duration: 1, meta: None, tick: None}, + Skill::BreakPlus => 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::BreakIII => vec![ConstructEffect {effect: Effect::Stun, duration: 2, meta: None, tick: None}, + Skill::BreakPlusPlus => 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::Ruin => vec![ConstructEffect {effect: Effect::Stun, duration: 1, meta: None, tick: None}], + Skill::RuinPlus => vec![ConstructEffect {effect: Effect::Stun, duration: 1, meta: None, tick: None}], + Skill::RuinPlusPlus => vec![ConstructEffect {effect: Effect::Stun, duration: 2, meta: None, tick: None}], - Skill::PurgeI => vec![ConstructEffect {effect: Effect::Purge, duration: 1, meta: None, tick: None}], - Skill::PurgeII => vec![ConstructEffect {effect: Effect::Purge, duration: 2, meta: None, tick: None}], - Skill::PurgeIII => vec![ConstructEffect {effect: Effect::Purge, duration: 3, meta: None, tick: None}], + Skill::Purge => vec![ConstructEffect {effect: Effect::Purge, duration: 1, meta: None, tick: None}], + Skill::PurgePlus => vec![ConstructEffect {effect: Effect::Purge, duration: 2, meta: None, tick: None}], + Skill::PurgePlusPlus => vec![ConstructEffect {effect: Effect::Purge, duration: 3, meta: None, tick: None}], - Skill::LinkI => vec![ConstructEffect {effect: Effect::Link, duration: 2, meta: None, tick: None}], - Skill::LinkII => vec![ConstructEffect {effect: Effect::Link, duration: 3, meta: None, tick: None}], - Skill::LinkIII => vec![ConstructEffect {effect: Effect::Link, duration: 4, meta: None, tick: None}], + Skill::Link => vec![ConstructEffect {effect: Effect::Link, duration: 2, meta: None, tick: None}], + Skill::LinkPlus => vec![ConstructEffect {effect: Effect::Link, duration: 3, meta: None, tick: None}], + Skill::LinkPlusPlus => vec![ConstructEffect {effect: Effect::Link, 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::Silence => vec![ConstructEffect {effect: Effect::Silence, duration: 2, meta: None, tick: None}], + Skill::SilencePlus => vec![ConstructEffect {effect: Effect::Silence, duration: 3, meta: None, tick: None}], + Skill::SilencePlusPlus => 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::Siphon => vec![ConstructEffect {effect: Effect::Siphon, duration: 2, + meta: Some(EffectMeta::Skill(Skill::SiphonTick)), tick: None}], + Skill::SiphonPlus => vec![ConstructEffect {effect: Effect::Siphon, duration: 3, + meta: Some(EffectMeta::Skill(Skill::SiphonTickPlus)), tick: None}], + Skill::SiphonPlusPlus => vec![ConstructEffect {effect: Effect::Siphon, duration: 4, + meta: Some(EffectMeta::Skill(Skill::SiphonTickPlusPlus)), 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::Sleep => vec![ConstructEffect {effect: Effect::Stun, duration: 2, meta: None, tick: None}], + Skill::SleepPlus => vec![ConstructEffect {effect: Effect::Stun, duration: 3, meta: None, tick: None}], + Skill::SleepPlusPlus => vec![ConstructEffect {effect: Effect::Stun, duration: 4, meta: None, tick: None}], - Skill::RestrictI => vec![ConstructEffect {effect: Effect::Restrict, duration: 2, meta: None, tick: None}], - Skill::RestrictII => vec![ConstructEffect {effect: Effect::Restrict, duration: 3, meta: None, tick: None}], - Skill::RestrictIII => vec![ConstructEffect {effect: Effect::Restrict, duration: 4, meta: None, tick: None}], + Skill::Restrict => vec![ConstructEffect {effect: Effect::Restrict, duration: 2, meta: None, tick: None}], + Skill::RestrictPlus => vec![ConstructEffect {effect: Effect::Restrict, duration: 3, meta: None, tick: None}], + Skill::RestrictPlusPlus => vec![ConstructEffect {effect: Effect::Restrict, duration: 4, meta: None, tick: None}], - Skill::BashI => vec![ConstructEffect {effect: Effect::Stun, duration: 2, - meta: Some(EffectMeta::Skill(Skill::BashI)), tick: None}], - Skill::BashII => vec![ConstructEffect {effect: Effect::Stun, duration: 2, - meta: Some(EffectMeta::Skill(Skill::BashII)), tick: None}], - Skill::BashIII => vec![ConstructEffect {effect: Effect::Stun, duration: 2, - meta: Some(EffectMeta::Skill(Skill::BashIII)), tick: None}], + Skill::Bash => vec![ConstructEffect {effect: Effect::Stun, duration: 2, + meta: Some(EffectMeta::Skill(Skill::Bash)), tick: None}], + Skill::BashPlus => vec![ConstructEffect {effect: Effect::Stun, duration: 2, + meta: Some(EffectMeta::Skill(Skill::BashPlus)), tick: None}], + Skill::BashPlusPlus => vec![ConstructEffect {effect: Effect::Stun, duration: 2, + meta: Some(EffectMeta::Skill(Skill::BashPlusPlus)), tick: None}], Skill::Stun => vec![ConstructEffect {effect: Effect::Stun, duration: 2, meta: None, tick: None}], - Skill::InterceptI => vec![ConstructEffect {effect: Effect::Intercept, duration: 2, meta: None, tick: None}], - Skill::InterceptII => vec![ConstructEffect {effect: Effect::Intercept, duration: 3, meta: None, tick: None}], - Skill::InterceptIII => vec![ConstructEffect {effect: Effect::Intercept, duration: 4, meta: None, tick: None}], + Skill::Intercept => vec![ConstructEffect {effect: Effect::Intercept, duration: 2, meta: None, tick: None}], + Skill::InterceptPlus => vec![ConstructEffect {effect: Effect::Intercept, duration: 3, meta: None, tick: None}], + Skill::InterceptPlusPlus => vec![ConstructEffect {effect: Effect::Intercept, 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}], + Skill::Triage => vec![ConstructEffect {effect: Effect::Triage, duration: 2, + meta: Some(EffectMeta::Skill(Skill::TriageTick)), tick: None}], + Skill::TriagePlus => vec![ConstructEffect {effect: Effect::Triage, duration: 3, + meta: Some(EffectMeta::Skill(Skill::TriageTickPlus)), tick: None}], + Skill::TriagePlusPlus => vec![ConstructEffect {effect: Effect::Triage, duration: 4, + meta: Some(EffectMeta::Skill(Skill::TriageTickPlusPlus)), tick: None}], _ => { panic!("{:?} no skill effect", self); }, @@ -897,128 +897,128 @@ impl Skill { Skill::Debuff => Some(1), Skill::Buff => None, - Skill::StrikeI => None, - Skill::StrikeII => None, - Skill::StrikeIII => None, + Skill::Strike=> None, + Skill::StrikePlus => None, + Skill::StrikePlusPlus => None, Skill::Block => None, // reduce damage - Skill::CounterI | - Skill::CounterII | - Skill::CounterIII => Some(2), // avoid all damage + Skill::Counter| + Skill::CounterPlus | + Skill::CounterPlusPlus => Some(2), // avoid all damage - Skill::RestrictI => Some(2), - Skill::RestrictII => Some(2), - Skill::RestrictIII => Some(2), + Skill::Restrict=> Some(2), + Skill::RestrictPlus => Some(2), + Skill::RestrictPlusPlus => Some(2), Skill::Stun => Some(2), - Skill::BashI => Some(2), - Skill::BashII => Some(2), - Skill::BashIII => Some(2), + Skill::Bash=> Some(2), + Skill::BashPlus => Some(2), + Skill::BashPlusPlus => Some(2), - Skill::HealI => None, - Skill::HealII => None, - Skill::HealIII => None, + Skill::Heal=> None, + Skill::HealPlus => None, + Skill::HealPlusPlus => None, - Skill::TriageI => None, // hot - Skill::TriageII => None, // hot - Skill::TriageIII => None, // hot + Skill::Triage=> None, // hot + Skill::TriagePlus => None, // hot + Skill::TriagePlusPlus => None, // hot - Skill::BreakI => Some(1), // no damage stun, adds vulnerable - Skill::BreakII => Some(1), - Skill::BreakIII => Some(1), + Skill::Break=> Some(1), // no damage stun, adds vulnerable + Skill::BreakPlus => Some(1), + Skill::BreakPlusPlus => Some(1), - Skill::BlastI => None, - Skill::BlastII => None, - Skill::BlastIII => None, + Skill::Blast=> None, + Skill::BlastPlus => None, + Skill::BlastPlusPlus => None, - Skill::ChaosI => None, - Skill::ChaosII => None, - Skill::ChaosIII => None, + Skill::Chaos=> None, + Skill::ChaosPlus => None, + Skill::ChaosPlusPlus => None, - Skill::AmplifyI => Some(1), - Skill::AmplifyII => Some(1), - Skill::AmplifyIII => Some(1), - Skill::HybridI | - Skill::HybridII | - Skill::HybridIII => Some(3), + Skill::Amplify=> Some(1), + Skill::AmplifyPlus => Some(1), + Skill::AmplifyPlusPlus => Some(1), + Skill::Hybrid| + Skill::HybridPlus | + Skill::HybridPlusPlus => 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::Invert=> Some(2), + Skill::InvertPlus => Some(2), + Skill::InvertPlusPlus => Some(2), + Skill::Decay=> Some(1), // dot + Skill::DecayPlus => Some(1), + Skill::DecayPlusPlus => Some(1), + Skill::Siphon| + Skill::SiphonPlus | + Skill::SiphonPlusPlus => None, - Skill::CurseI => Some(1), - Skill::CurseII => Some(1), - Skill::CurseIII => Some(1), + Skill::Curse=> Some(1), + Skill::CursePlus => Some(1), + Skill::CursePlusPlus => Some(1), - Skill::LinkI => Some(2), - Skill::LinkII => Some(2), - Skill::LinkIII => Some(2), + Skill::Link=> Some(2), + Skill::LinkPlus => Some(2), + Skill::LinkPlusPlus => Some(2), - Skill::SilenceI => Some(3), - Skill::SilenceII => Some(2), - Skill::SilenceIII => Some(2), + Skill::Silence=> Some(3), + Skill::SilencePlus => Some(2), + Skill::SilencePlusPlus => Some(2), - Skill::PurifyI => None, - Skill::PurifyII => None, - Skill::PurifyIII => None, + Skill::Purify=> None, + Skill::PurifyPlus => None, + Skill::PurifyPlusPlus => None, - Skill::PurgeI => None, - Skill::PurgeII => None, - Skill::PurgeIII => None, + Skill::Purge=> None, + Skill::PurgePlus => None, + Skill::PurgePlusPlus => None, - Skill::BanishI => Some(1), - Skill::BanishII => Some(1), - Skill::BanishIII => Some(1), + Skill::Banish=> Some(1), + Skill::BanishPlus => Some(1), + Skill::BanishPlusPlus => Some(1), - Skill::HexI => Some(1), - Skill::HexII => Some(2), - Skill::HexIII => Some(2), + Skill::Hex=> Some(1), + Skill::HexPlus => Some(2), + Skill::HexPlusPlus => Some(2), - Skill::HasteI => Some(2), - Skill::HasteII => Some(2), - Skill::HasteIII => Some(2), + Skill::Haste=> Some(2), + Skill::HastePlus => Some(2), + Skill::HastePlusPlus => Some(2), - Skill::ReflectI => Some(2), - Skill::ReflectII => Some(2), - Skill::ReflectIII => Some(2), + Skill::Reflect=> Some(2), + Skill::ReflectPlus => Some(2), + Skill::ReflectPlusPlus => Some(2), - Skill::RechargeI => Some(2), - Skill::RechargeII => Some(2), - Skill::RechargeIII => Some(2), + Skill::Recharge=> Some(2), + Skill::RechargePlus => Some(2), + Skill::RechargePlusPlus => Some(2), - Skill::RuinI => Some(3), - Skill::RuinII => Some(2), - Skill::RuinIII => Some(2), + Skill::Ruin=> Some(3), + Skill::RuinPlus => Some(2), + Skill::RuinPlusPlus => Some(2), - Skill::SlayI => None, - Skill::SlayII => None, - Skill::SlayIII => None, + Skill::Slay=> None, + Skill::SlayPlus => None, + Skill::SlayPlusPlus => None, - Skill::SleepI => Some(3), - Skill::SleepII => Some(3), - Skill::SleepIII => Some(3), + Skill::Sleep=> Some(3), + Skill::SleepPlus => Some(3), + Skill::SleepPlusPlus => Some(3), - Skill::SustainI => Some(1), - Skill::SustainII => Some(2), - Skill::SustainIII => Some(3), + Skill::Sustain=> Some(1), + Skill::SustainPlus => Some(2), + Skill::SustainPlusPlus => Some(3), - Skill::InterceptI => Some(2), - Skill::InterceptII => Some(2), - Skill::InterceptIII => Some(2), + Skill::Intercept=> Some(2), + Skill::InterceptPlus => Some(2), + Skill::InterceptPlusPlus => Some(2), - Skill::ElectrifyI =>Some(1), - Skill::ElectrifyII =>Some(1), - Skill::ElectrifyIII =>Some(1), + Skill::Electrify=>Some(1), + Skill::ElectrifyPlus =>Some(1), + Skill::ElectrifyPlusPlus =>Some(1), - Skill::AbsorbI | - Skill::AbsorbII | - Skill::AbsorbIII => Some(1), + Skill::Absorb| + Skill::AbsorbPlus | + Skill::AbsorbPlusPlus => Some(1), //----------- // Never cast directly @@ -1026,65 +1026,65 @@ impl Skill { // Trigger Skill::HybridBlast | Skill::HasteStrike | - Skill::CounterAttackI | - Skill::CounterAttackII | - Skill::CounterAttackIII | // counter - Skill::ElectrocuteI | - Skill::ElectrocuteII | - Skill::ElectrocuteIII | - Skill::AbsorptionI | - Skill::AbsorptionII | - Skill::AbsorptionIII | + Skill::CounterAttack| + Skill::CounterAttackPlus | + Skill::CounterAttackPlusPlus | // counter + Skill::Electrocute| + Skill::ElectrocutePlus | + Skill::ElectrocutePlusPlus | + Skill::Absorption| + Skill::AbsorptionPlus | + Skill::AbsorptionPlusPlus | // Ticks - Skill::ElectrocuteTickI | - Skill::ElectrocuteTickII | - Skill::ElectrocuteTickIII | - Skill::DecayTickI | - Skill::DecayTickII | - Skill::DecayTickIII | - Skill::SiphonTickI | - Skill::SiphonTickII | - Skill::SiphonTickIII | - Skill::TriageTickI | - Skill::TriageTickII | - Skill::TriageTickIII => None, + Skill::ElectrocuteTick| + Skill::ElectrocuteTickPlus | + Skill::ElectrocuteTickPlusPlus | + Skill::DecayTick| + Skill::DecayTickPlus | + Skill::DecayTickPlusPlus | + Skill::SiphonTick| + Skill::SiphonTickPlus | + Skill::SiphonTickPlusPlus | + Skill::TriageTick| + Skill::TriageTickPlus | + Skill::TriageTickPlusPlus => None, } } pub fn ko_castable(&self) -> bool { match self { - Skill::ElectrocuteTickI | - Skill::ElectrocuteTickII | - Skill::ElectrocuteTickIII | - Skill::DecayTickI | - Skill::DecayTickII | - Skill::DecayTickIII | - Skill::SiphonTickI | - Skill::SiphonTickII | - Skill::SiphonTickIII | + Skill::ElectrocuteTick| + Skill::ElectrocuteTickPlus | + Skill::ElectrocuteTickPlusPlus | + Skill::DecayTick| + Skill::DecayTickPlus | + Skill::DecayTickPlusPlus | + Skill::SiphonTick| + Skill::SiphonTickPlus | + Skill::SiphonTickPlusPlus | - Skill::TriageTickI | - Skill::TriageTickII | - Skill::TriageTickIII => true, + Skill::TriageTick| + Skill::TriageTickPlus | + Skill::TriageTickPlusPlus => true, _ => false, } } pub fn is_tick(&self) -> bool { match self { - Skill::ElectrocuteTickI | - Skill::ElectrocuteTickII | - Skill::ElectrocuteTickIII | - Skill::DecayTickI | - Skill::DecayTickII | - Skill::DecayTickIII | - Skill::SiphonTickI | - Skill::SiphonTickII | - Skill::SiphonTickIII | + Skill::ElectrocuteTick| + Skill::ElectrocuteTickPlus | + Skill::ElectrocuteTickPlusPlus | + Skill::DecayTick| + Skill::DecayTickPlus | + Skill::DecayTickPlusPlus | + Skill::SiphonTick| + Skill::SiphonTickPlus | + Skill::SiphonTickPlusPlus | - Skill::TriageTickI | - Skill::TriageTickII | - Skill::TriageTickIII => true, + Skill::TriageTick| + Skill::TriageTickPlus | + Skill::TriageTickPlusPlus => true, _ => false, } @@ -1092,25 +1092,25 @@ impl Skill { pub fn speed(&self) -> u64 { match self { - Skill::StrikeI => Item::from(Skill::StrikeI).speed().pct(150), - Skill::StrikeII => Skill::StrikeI.speed(), - Skill::StrikeIII => Skill::StrikeI.speed(), + Skill::Strike=> Item::from(Skill::Strike).speed().pct(150), + Skill::StrikePlus => Skill::Strike.speed(), + Skill::StrikePlusPlus => Skill::Strike.speed(), - Skill::SiphonTickI | - Skill::SiphonTickII | - Skill::SiphonTickIII => Skill::SiphonI.speed(), + Skill::SiphonTick| + Skill::SiphonTickPlus | + Skill::SiphonTickPlusPlus => Skill::Siphon.speed(), - Skill::DecayTickI | - Skill::DecayTickII | - Skill::DecayTickIII => Skill::DecayI.speed(), + Skill::DecayTick| + Skill::DecayTickPlus | + Skill::DecayTickPlusPlus => Skill::Decay.speed(), - Skill::TriageTickI | - Skill::TriageTickII | - Skill::TriageTickIII => Skill::TriageI.speed(), + Skill::TriageTick| + Skill::TriageTickPlus | + Skill::TriageTickPlusPlus => Skill::Triage.speed(), - Skill::ElectrocuteTickI | - Skill::ElectrocuteTickII | - Skill::ElectrocuteTickIII => Skill::ElectrifyI.speed(), + Skill::ElectrocuteTick| + Skill::ElectrocuteTickPlus | + Skill::ElectrocuteTickPlusPlus => Skill::Electrify.speed(), _ => Item::from(*self).speed(), } @@ -1118,9 +1118,9 @@ impl Skill { pub fn aoe(&self) -> bool { match self { - Skill::RuinI | - Skill::RuinII | - Skill::RuinIII => true, + Skill::Ruin| + Skill::RuinPlus | + Skill::RuinPlusPlus => true, _ => false, } } @@ -1128,12 +1128,12 @@ impl Skill { pub fn self_targeting(&self) -> bool { match self { Skill::Block | - Skill::SustainI | - Skill::SustainII | - Skill::SustainIII | - Skill::CounterI | - Skill::CounterII | - Skill::CounterIII => true, + Skill::Sustain| + Skill::SustainPlus | + Skill::SustainPlusPlus | + Skill::Counter| + Skill::CounterPlus | + Skill::CounterPlusPlus => true, _ => false, } @@ -1143,50 +1143,50 @@ impl Skill { let mut rng = thread_rng(); match self { - Skill::AmplifyI | - Skill::AmplifyII | - Skill::AmplifyIII | + Skill::Amplify| + Skill::AmplifyPlus | + Skill::AmplifyPlusPlus | Skill::Block | - Skill::SustainI | - Skill::SustainII | - Skill::SustainIII | - Skill::ElectrifyI | - Skill::ElectrifyII | - Skill::ElectrifyIII | - Skill::HasteI | - Skill::HasteII | - Skill::HasteIII | - Skill::HealI | - Skill::HealII | - Skill::HealIII | - Skill::AbsorbI | - Skill::AbsorbII | - Skill::AbsorbIII | - Skill::InvertI | - Skill::InvertII | - Skill::InvertIII | - Skill::CounterI | - Skill::CounterII | - Skill::CounterIII | - Skill::PurifyI | - Skill::PurifyII | - Skill::PurifyIII | - Skill::RechargeI | - Skill::RechargeII | - Skill::RechargeIII | - Skill::ReflectI | - Skill::ReflectII | - Skill::ReflectIII | - Skill::LinkI | - Skill::LinkII | - Skill::LinkIII | - Skill::TriageI | - Skill::TriageII | - Skill::TriageIII => true, + Skill::Sustain| + Skill::SustainPlus | + Skill::SustainPlusPlus | + Skill::Electrify| + Skill::ElectrifyPlus | + Skill::ElectrifyPlusPlus | + Skill::Haste| + Skill::HastePlus | + Skill::HastePlusPlus | + Skill::Heal| + Skill::HealPlus | + Skill::HealPlusPlus | + Skill::Absorb| + Skill::AbsorbPlus | + Skill::AbsorbPlusPlus | + Skill::Invert| + Skill::InvertPlus | + Skill::InvertPlusPlus | + Skill::Counter| + Skill::CounterPlus | + Skill::CounterPlusPlus | + Skill::Purify| + Skill::PurifyPlus | + Skill::PurifyPlusPlus | + Skill::Recharge| + Skill::RechargePlus | + Skill::RechargePlusPlus | + Skill::Reflect| + Skill::ReflectPlus | + Skill::ReflectPlusPlus | + Skill::Link| + Skill::LinkPlus | + Skill::LinkPlusPlus | + Skill::Triage| + Skill::TriagePlus | + Skill::TriagePlusPlus => true, - Skill::BanishI | - Skill::BanishII | - Skill::BanishIII => rng.gen_bool(0.5), + Skill::Banish| + Skill::BanishPlus | + Skill::BanishPlusPlus => rng.gen_bool(0.5), _ => false, } @@ -1623,7 +1623,7 @@ fn link_hit(source: &Construct, target: &Construct, mut results: Resolutions, ga Colour::Green => link_target.deal_green_damage(skill, amount), }; - results.push(Resolution::new(target, link_target).event(Event::Skill { skill: Skill::LinkI })); + results.push(Resolution::new(target, link_target).event(Event::Skill { skill: Skill::Link})); res.into_iter().for_each(|e| results.push(Resolution::new(&source, &link_target) .event(e).stages(EventStages::EndPost))); } else { @@ -1722,15 +1722,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] @@ -1741,7 +1741,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)); @@ -1785,10 +1785,10 @@ mod tests { x.red_power.force(10000000000000); // multiplication of int max will cause overflow - sustain(&mut y.clone(), &mut y, vec![], Skill::SustainI); + sustain(&mut y.clone(), &mut y, vec![], Skill::Sustain); assert!(y.affected(Effect::Sustain)); - 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, stages: _ } = results.remove(0); match event { Event::Immunity { skill: _, immunity } => assert!(immunity.contains(&Effect::Sustain)), @@ -1817,11 +1817,11 @@ mod tests { y.red_life.force(64); y.red_life.reduce(64); x.red_power.force(512); - 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 - heal(&mut x, &mut y, vec![], Skill::HealI); + heal(&mut x, &mut y, vec![], Skill::Heal); assert!(y.green_life() < 1024); // attack should heal and recharge red shield @@ -1851,17 +1851,17 @@ 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![]; - results = resolve(Skill::BlastI, &mut x, &mut y, results); + results = resolve(Skill::Blast, &mut x, &mut y, results); assert!(x.green_life() < 1024); let Resolution { source: _, target: _, event, stages: _ } = results.remove(0); match event { - Event::Reflection { skill } => assert_eq!(skill, Skill::BlastI), + Event::Reflection { skill } => assert_eq!(skill, Skill::Blast), _ => panic!("not reflection"), }; @@ -1882,10 +1882,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, stages: _ } = results.remove(0); match event { @@ -1895,14 +1895,14 @@ mod tests { let Resolution { source: _, target: _, event, stages: _ } = 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, stages: _ } = 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"), @@ -1927,7 +1927,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); @@ -1945,9 +1945,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, stages: _ } = results.remove(0); match event { @@ -1965,9 +1965,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] @@ -1977,7 +1977,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); } @@ -1987,10 +1987,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)); } @@ -2005,7 +2005,7 @@ mod tests { let stun_cd = y.skills.iter().find(|cs| cs.skill == Skill::Stun).unwrap().cd.unwrap(); - bash(&mut x, &mut y, vec![], Skill::BashI); + bash(&mut x, &mut y, vec![], Skill::Bash); assert!(!x.effects.iter().any(|e| e.effect == Effect::Stun)); assert!(y.skills.iter().any(|cs| cs.skill == Skill::Stun && cs.cd.unwrap() == stun_cd + 1)); } @@ -2017,12 +2017,12 @@ mod tests { let mut y = Construct::new() .named(&"pretaliation".to_string()) - .learn(Skill::HealI) - .learn(Skill::HealII); + .learn(Skill::Heal) + .learn(Skill::HealPlus); - purge(&mut x, &mut y, vec![], Skill::PurgeI); + purge(&mut x, &mut y, vec![], Skill::Purge); // 2 turns at lvl 1 assert!(y.effects.iter().any(|e| e.effect == Effect::Purge && e.duration == 2)); - assert!(y.disabled(Skill::HealI).is_some()); + assert!(y.disabled(Skill::Heal).is_some()); } } diff --git a/server/src/spec.rs b/server/src/spec.rs index f501a0e7..0f6b5125 100644 --- a/server/src/spec.rs +++ b/server/src/spec.rs @@ -38,66 +38,66 @@ impl SpecValues { #[derive(Debug,Copy,Clone,Serialize,Deserialize,PartialEq,PartialOrd,Ord,Eq)] pub enum Spec { Speed, - SpeedRRI, - SpeedBBI, - SpeedGGI, - SpeedRGI, - SpeedGBI, - SpeedRBI, + SpeedRR, + SpeedBB, + SpeedGG, + SpeedRG, + SpeedGB, + SpeedRB, - SpeedRRII, - SpeedBBII, - SpeedGGII, - SpeedRGII, - SpeedGBII, - SpeedRBII, + SpeedRRPlus, + SpeedBBPlus, + SpeedGGPlus, + SpeedRGPlus, + SpeedGBPlus, + SpeedRBPlus, - SpeedRRIII, - SpeedBBIII, - SpeedGGIII, - SpeedRGIII, - SpeedGBIII, - SpeedRBIII, + SpeedRRPlusPlus, + SpeedBBPlusPlus, + SpeedGGPlusPlus, + SpeedRGPlusPlus, + SpeedGBPlusPlus, + SpeedRBPlusPlus, Life, - LifeGGI, - LifeRRI, - LifeBBI, - LifeRGI, - LifeGBI, - LifeRBI, - LifeGGII, - LifeRRII, - LifeBBII, - LifeRGII, - LifeGBII, - LifeRBII, - LifeGGIII, - LifeRRIII, - LifeBBIII, - LifeRGIII, - LifeGBIII, - LifeRBIII, + LifeGG, + LifeRR, + LifeBB, + LifeRG, + LifeGB, + LifeRB, + LifeGGPlus, + LifeRRPlus, + LifeBBPlus, + LifeRGPlus, + LifeGBPlus, + LifeRBPlus, + LifeGGPlusPlus, + LifeRRPlusPlus, + LifeBBPlusPlus, + LifeRGPlusPlus, + LifeGBPlusPlus, + LifeRBPlusPlus, Power, - PowerRRI, - PowerGGI, - PowerBBI, - PowerRGI, - PowerGBI, - PowerRBI, - PowerRRII, - PowerGGII, - PowerBBII, - PowerRGII, - PowerGBII, - PowerRBII, - PowerRRIII, - PowerGGIII, - PowerBBIII, - PowerRGIII, - PowerGBIII, - PowerRBIII, + PowerRR, + PowerGG, + PowerBB, + PowerRG, + PowerGB, + PowerRB, + PowerRRPlus, + PowerGGPlus, + PowerBBPlus, + PowerRGPlus, + PowerGBPlus, + PowerRBPlus, + PowerRRPlusPlus, + PowerGGPlusPlus, + PowerBBPlusPlus, + PowerRGPlusPlus, + PowerGBPlusPlus, + PowerRBPlusPlus, } @@ -105,66 +105,66 @@ impl Spec { pub fn affects(&self) -> Vec { match *self { Spec::Power => vec![Stat::BluePower, Stat::RedPower, Stat::GreenPower], - Spec::PowerRRI => vec![Stat::RedPower], - Spec::PowerGGI => vec![Stat::GreenPower], - Spec::PowerBBI => vec![Stat::BluePower], - Spec::PowerRGI => vec![Stat::GreenPower, Stat::RedPower], - Spec::PowerGBI => vec![Stat::GreenPower, Stat::BluePower], - Spec::PowerRBI => vec![Stat::RedPower, Stat::BluePower], - Spec::PowerRRII => vec![Stat::RedPower], - Spec::PowerGGII => vec![Stat::GreenPower], - Spec::PowerBBII => vec![Stat::BluePower], - Spec::PowerRGII => vec![Stat::GreenPower, Stat::RedPower], - Spec::PowerGBII => vec![Stat::GreenPower, Stat::BluePower], - Spec::PowerRBII => vec![Stat::RedPower, Stat::BluePower], - Spec::PowerRRIII => vec![Stat::RedPower], - Spec::PowerGGIII => vec![Stat::GreenPower], - Spec::PowerBBIII => vec![Stat::BluePower], - Spec::PowerRGIII => vec![Stat::GreenPower, Stat::RedPower], - Spec::PowerGBIII => vec![Stat::GreenPower, Stat::BluePower], - Spec::PowerRBIII => vec![Stat::RedPower, Stat::BluePower], + Spec::PowerRR => vec![Stat::RedPower], + Spec::PowerGG => vec![Stat::GreenPower], + Spec::PowerBB => vec![Stat::BluePower], + Spec::PowerRG => vec![Stat::GreenPower, Stat::RedPower], + Spec::PowerGB => vec![Stat::GreenPower, Stat::BluePower], + Spec::PowerRB => vec![Stat::RedPower, Stat::BluePower], + Spec::PowerRRPlus => vec![Stat::RedPower], + Spec::PowerGGPlus => vec![Stat::GreenPower], + Spec::PowerBBPlus => vec![Stat::BluePower], + Spec::PowerRGPlus => vec![Stat::GreenPower, Stat::RedPower], + Spec::PowerGBPlus => vec![Stat::GreenPower, Stat::BluePower], + Spec::PowerRBPlus => vec![Stat::RedPower, Stat::BluePower], + Spec::PowerRRPlusPlus => vec![Stat::RedPower], + Spec::PowerGGPlusPlus => vec![Stat::GreenPower], + Spec::PowerBBPlusPlus => vec![Stat::BluePower], + Spec::PowerRGPlusPlus => vec![Stat::GreenPower, Stat::RedPower], + Spec::PowerGBPlusPlus => vec![Stat::GreenPower, Stat::BluePower], + Spec::PowerRBPlusPlus => vec![Stat::RedPower, Stat::BluePower], Spec::Speed => vec![Stat::Speed], - Spec::SpeedRRI => vec![Stat::Speed], - Spec::SpeedBBI => vec![Stat::Speed], - Spec::SpeedGGI => vec![Stat::Speed], - Spec::SpeedRGI => vec![Stat::Speed], - Spec::SpeedGBI => vec![Stat::Speed], - Spec::SpeedRBI => vec![Stat::Speed], - Spec::SpeedRRII => vec![Stat::Speed], - Spec::SpeedBBII => vec![Stat::Speed], - Spec::SpeedGGII => vec![Stat::Speed], - Spec::SpeedRGII => vec![Stat::Speed], - Spec::SpeedGBII => vec![Stat::Speed], - Spec::SpeedRBII => vec![Stat::Speed], - Spec::SpeedRRIII => vec![Stat::Speed], - Spec::SpeedBBIII => vec![Stat::Speed], - Spec::SpeedGGIII => vec![Stat::Speed], - Spec::SpeedRGIII => vec![Stat::Speed], - Spec::SpeedGBIII => vec![Stat::Speed], - Spec::SpeedRBIII => vec![Stat::Speed], + Spec::SpeedRR => vec![Stat::Speed], + Spec::SpeedBB => vec![Stat::Speed], + Spec::SpeedGG => vec![Stat::Speed], + Spec::SpeedRG => vec![Stat::Speed], + Spec::SpeedGB => vec![Stat::Speed], + Spec::SpeedRB => vec![Stat::Speed], + Spec::SpeedRRPlus => vec![Stat::Speed], + Spec::SpeedBBPlus => vec![Stat::Speed], + Spec::SpeedGGPlus => vec![Stat::Speed], + Spec::SpeedRGPlus => vec![Stat::Speed], + Spec::SpeedGBPlus => vec![Stat::Speed], + Spec::SpeedRBPlus => vec![Stat::Speed], + Spec::SpeedRRPlusPlus => vec![Stat::Speed], + Spec::SpeedBBPlusPlus => vec![Stat::Speed], + Spec::SpeedGGPlusPlus => vec![Stat::Speed], + Spec::SpeedRGPlusPlus => vec![Stat::Speed], + Spec::SpeedGBPlusPlus => vec![Stat::Speed], + Spec::SpeedRBPlusPlus => vec![Stat::Speed], Spec::Life => vec![Stat::GreenLife], - Spec::LifeRRI => vec![Stat::RedLife], - Spec::LifeBBI => vec![Stat::BlueLife], - Spec::LifeGGI => vec![Stat::GreenLife], - Spec::LifeRGI => vec![Stat::GreenLife, Stat::RedLife], - Spec::LifeGBI => vec![Stat::GreenLife, Stat::BlueLife], - Spec::LifeRBI => vec![Stat::BlueLife, Stat::RedLife], - Spec::LifeRRII => vec![Stat::RedLife], - Spec::LifeBBII => vec![Stat::BlueLife], - Spec::LifeGGII => vec![Stat::GreenLife], - Spec::LifeRGII => vec![Stat::GreenLife, Stat::RedLife], - Spec::LifeGBII => vec![Stat::GreenLife, Stat::BlueLife], - Spec::LifeRBII => vec![Stat::BlueLife, Stat::RedLife], - Spec::LifeRRIII => vec![Stat::RedLife], - Spec::LifeBBIII => vec![Stat::BlueLife], - Spec::LifeGGIII => vec![Stat::GreenLife], - Spec::LifeRGIII => vec![Stat::GreenLife, Stat::RedLife], - Spec::LifeGBIII => vec![Stat::GreenLife, Stat::BlueLife], - Spec::LifeRBIII => vec![Stat::BlueLife, Stat::RedLife], + Spec::LifeRR => vec![Stat::RedLife], + Spec::LifeBB => vec![Stat::BlueLife], + Spec::LifeGG => vec![Stat::GreenLife], + Spec::LifeRG => vec![Stat::GreenLife, Stat::RedLife], + Spec::LifeGB => vec![Stat::GreenLife, Stat::BlueLife], + Spec::LifeRB => vec![Stat::BlueLife, Stat::RedLife], + Spec::LifeRRPlus => vec![Stat::RedLife], + Spec::LifeBBPlus => vec![Stat::BlueLife], + Spec::LifeGGPlus => vec![Stat::GreenLife], + Spec::LifeRGPlus => vec![Stat::GreenLife, Stat::RedLife], + Spec::LifeGBPlus => vec![Stat::GreenLife, Stat::BlueLife], + Spec::LifeRBPlus => vec![Stat::BlueLife, Stat::RedLife], + Spec::LifeRRPlusPlus => vec![Stat::RedLife], + Spec::LifeBBPlusPlus => vec![Stat::BlueLife], + Spec::LifeGGPlusPlus => vec![Stat::GreenLife], + Spec::LifeRGPlusPlus => vec![Stat::GreenLife, Stat::RedLife], + Spec::LifeGBPlusPlus => vec![Stat::GreenLife, Stat::BlueLife], + Spec::LifeRBPlusPlus => vec![Stat::BlueLife, Stat::RedLife], } } @@ -175,7 +175,7 @@ impl Spec { bonuses: vec![] }, - Spec::PowerRRI => SpecValues { + Spec::PowerRR=> SpecValues { multi: 10, base: 25, bonuses: vec![ SpecBonus { req: Colours { red: 5, green: 0, blue: 0 }, bonus: 25 }, @@ -184,7 +184,7 @@ impl Spec { ], }, - Spec::PowerGGI => SpecValues { + Spec::PowerGG=> SpecValues { multi: 10, base: 25, bonuses: vec![ SpecBonus { req: Colours { red: 0, green: 5, blue: 0 }, bonus: 25 }, @@ -193,7 +193,7 @@ impl Spec { ], }, - Spec::PowerBBI => SpecValues { + Spec::PowerBB=> SpecValues { multi: 10, base: 25, bonuses: vec![ SpecBonus { req: Colours { red: 0, green: 0, blue: 5 }, bonus: 25 }, @@ -202,7 +202,7 @@ impl Spec { ], }, - Spec::PowerRGI => SpecValues { + Spec::PowerRG=> SpecValues { multi: 5, base: 15, bonuses: vec![ SpecBonus { req: Colours { red: 2, green: 2, blue: 0 }, bonus: 15 }, @@ -211,7 +211,7 @@ impl Spec { ], }, - Spec::PowerGBI => SpecValues { + Spec::PowerGB=> SpecValues { multi: 5, base: 15, bonuses: vec![ SpecBonus { req: Colours { red: 0, green: 2, blue: 2 }, bonus: 15 }, @@ -220,7 +220,7 @@ impl Spec { ], }, - Spec::PowerRBI => SpecValues { + Spec::PowerRB=> SpecValues { multi: 5, base: 15, bonuses: vec![ SpecBonus { req: Colours { red: 2, green: 0, blue: 2 }, bonus: 15 }, @@ -229,7 +229,7 @@ impl Spec { ], }, - Spec::PowerRRII => SpecValues { + Spec::PowerRRPlus => SpecValues { multi: 10, base: 40, bonuses: vec![ SpecBonus { req: Colours { red: 5, green: 0, blue: 0 }, bonus: 40 }, @@ -238,7 +238,7 @@ impl Spec { ], }, - Spec::PowerGGII => SpecValues { + Spec::PowerGGPlus => SpecValues { multi: 10, base: 40, bonuses: vec![ SpecBonus { req: Colours { red: 0, green: 5, blue: 0 }, bonus: 40 }, @@ -247,7 +247,7 @@ impl Spec { ], }, - Spec::PowerBBII => SpecValues { + Spec::PowerBBPlus => SpecValues { multi: 10, base: 40, bonuses: vec![ SpecBonus { req: Colours { red: 0, green: 0, blue: 5 }, bonus: 40 }, @@ -256,7 +256,7 @@ impl Spec { ], }, - Spec::PowerRGII => SpecValues { + Spec::PowerRGPlus => SpecValues { multi: 7, base: 25, bonuses: vec![ SpecBonus { req: Colours { red: 2, green: 2, blue: 0 }, bonus: 25 }, @@ -265,7 +265,7 @@ impl Spec { ], }, - Spec::PowerGBII => SpecValues { + Spec::PowerGBPlus => SpecValues { multi: 7, base: 25, bonuses: vec![ SpecBonus { req: Colours { red: 0, green: 2, blue: 2 }, bonus: 25 }, @@ -274,7 +274,7 @@ impl Spec { ], }, - Spec::PowerRBII => SpecValues { + Spec::PowerRBPlus => SpecValues { multi: 7, base: 25, bonuses: vec![ SpecBonus { req: Colours { red: 2, green: 0, blue: 2 }, bonus: 25 }, @@ -282,7 +282,7 @@ impl Spec { SpecBonus { req: Colours { red: 10, green: 0, blue: 10 }, bonus: 25 } ], }, - Spec::PowerRRIII => SpecValues { + Spec::PowerRRPlusPlus => SpecValues { multi: 20, base: 60, bonuses: vec![ SpecBonus { req: Colours { red: 5, green: 0, blue: 0 }, bonus: 60 }, @@ -291,7 +291,7 @@ impl Spec { ], }, - Spec::PowerGGIII => SpecValues { + Spec::PowerGGPlusPlus => SpecValues { multi: 20, base: 60, bonuses: vec![ SpecBonus { req: Colours { red: 0, green: 5, blue: 0 }, bonus: 60 }, @@ -300,7 +300,7 @@ impl Spec { ], }, - Spec::PowerBBIII => SpecValues { + Spec::PowerBBPlusPlus => SpecValues { multi: 20, base: 60, bonuses: vec![ SpecBonus { req: Colours { red: 0, green: 0, blue: 5 }, bonus: 60 }, @@ -309,7 +309,7 @@ impl Spec { ], }, - Spec::PowerRGIII => SpecValues { + Spec::PowerRGPlusPlus => SpecValues { multi: 20, base: 40, bonuses: vec![ SpecBonus { req: Colours { red: 2, green: 2, blue: 0 }, bonus: 40 }, @@ -318,7 +318,7 @@ impl Spec { ], }, - Spec::PowerGBIII => SpecValues { + Spec::PowerGBPlusPlus => SpecValues { multi: 20, base: 40, bonuses: vec![ SpecBonus { req: Colours { red: 0, green: 2, blue: 2 }, bonus: 25 }, @@ -327,7 +327,7 @@ impl Spec { ], }, - Spec::PowerRBIII => SpecValues { + Spec::PowerRBPlusPlus => SpecValues { multi: 20, base: 40, bonuses: vec![ SpecBonus { req: Colours { red: 2, green: 0, blue: 2 }, bonus: 25 }, @@ -341,7 +341,7 @@ impl Spec { bonuses: vec![] }, - Spec::SpeedRRI => SpecValues { + Spec::SpeedRR=> SpecValues { multi: 20, base: 80, bonuses: vec![ SpecBonus { req: Colours { red: 5, green: 0, blue: 0 }, bonus: 80 }, @@ -350,7 +350,7 @@ impl Spec { ], }, - Spec::SpeedGGI => SpecValues { + Spec::SpeedGG=> SpecValues { multi: 20, base: 80, bonuses: vec![ SpecBonus { req: Colours { red: 0, green: 5, blue: 0 }, bonus: 80 }, @@ -359,7 +359,7 @@ impl Spec { ], }, - Spec::SpeedBBI => SpecValues { + Spec::SpeedBB=> SpecValues { multi: 20, base: 80, bonuses: vec![ SpecBonus { req: Colours { red: 0, green: 0, blue: 5 }, bonus: 80 }, @@ -368,7 +368,7 @@ impl Spec { ], }, - Spec::SpeedRGI => SpecValues { + Spec::SpeedRG=> SpecValues { multi: 15, base: 60, bonuses: vec![ SpecBonus { req: Colours { red: 2, green: 2, blue: 0 }, bonus: 60 }, @@ -377,7 +377,7 @@ impl Spec { ], }, - Spec::SpeedGBI => SpecValues { + Spec::SpeedGB=> SpecValues { multi: 15, base: 60, bonuses: vec![ SpecBonus { req: Colours { red: 0, green: 2, blue: 2 }, bonus: 60 }, @@ -386,7 +386,7 @@ impl Spec { ], }, - Spec::SpeedRBI => SpecValues { + Spec::SpeedRB=> SpecValues { multi: 15, base: 60, bonuses: vec![ SpecBonus { req: Colours { red: 2, green: 0, blue: 2 }, bonus: 60 }, @@ -395,7 +395,7 @@ impl Spec { ], }, - Spec::SpeedRRII => SpecValues { + Spec::SpeedRRPlus => SpecValues { multi: 20, base: 120, bonuses: vec![ SpecBonus { req: Colours { red: 5, green: 0, blue: 0 }, bonus: 120 }, @@ -404,7 +404,7 @@ impl Spec { ], }, - Spec::SpeedGGII => SpecValues { + Spec::SpeedGGPlus => SpecValues { multi: 20, base: 120, bonuses: vec![ SpecBonus { req: Colours { red: 0, green: 5, blue: 0 }, bonus: 120 }, @@ -413,7 +413,7 @@ impl Spec { ], }, - Spec::SpeedBBII => SpecValues { + Spec::SpeedBBPlus => SpecValues { multi: 20, base: 120, bonuses: vec![ SpecBonus { req: Colours { red: 0, green: 0, blue: 5 }, bonus: 120 }, @@ -422,7 +422,7 @@ impl Spec { ], }, - Spec::SpeedRGII => SpecValues { + Spec::SpeedRGPlus => SpecValues { multi: 15, base: 80, bonuses: vec![ SpecBonus { req: Colours { red: 2, green: 2, blue: 0 }, bonus: 80 }, @@ -431,7 +431,7 @@ impl Spec { ], }, - Spec::SpeedGBII => SpecValues { + Spec::SpeedGBPlus => SpecValues { multi: 15, base: 80, bonuses: vec![ SpecBonus { req: Colours { red: 0, green: 2, blue: 2 }, bonus: 80 }, @@ -440,7 +440,7 @@ impl Spec { ], }, - Spec::SpeedRBII => SpecValues { + Spec::SpeedRBPlus => SpecValues { multi: 15, base: 80, bonuses: vec![ SpecBonus { req: Colours { red: 2, green: 0, blue: 2 }, bonus: 80 }, @@ -449,7 +449,7 @@ impl Spec { ], }, - Spec::SpeedRRIII => SpecValues { + Spec::SpeedRRPlusPlus => SpecValues { multi: 20, base: 160, bonuses: vec![ SpecBonus { req: Colours { red: 5, green: 0, blue: 0 }, bonus: 160 }, @@ -458,7 +458,7 @@ impl Spec { ], }, - Spec::SpeedGGIII => SpecValues { + Spec::SpeedGGPlusPlus => SpecValues { multi: 20, base: 160, bonuses: vec![ SpecBonus { req: Colours { red: 0, green: 5, blue: 0 }, bonus: 160 }, @@ -467,7 +467,7 @@ impl Spec { ], }, - Spec::SpeedBBIII => SpecValues { + Spec::SpeedBBPlusPlus => SpecValues { multi: 20, base: 160, bonuses: vec![ SpecBonus { req: Colours { red: 0, green: 0, blue: 5 }, bonus: 160 }, @@ -476,7 +476,7 @@ impl Spec { ], }, - Spec::SpeedRGIII => SpecValues { + Spec::SpeedRGPlusPlus => SpecValues { multi: 15, base: 120, bonuses: vec![ SpecBonus { req: Colours { red: 2, green: 2, blue: 0 }, bonus: 120 }, @@ -485,7 +485,7 @@ impl Spec { ], }, - Spec::SpeedGBIII => SpecValues { + Spec::SpeedGBPlusPlus => SpecValues { multi: 15, base: 120, bonuses: vec![ SpecBonus { req: Colours { red: 0, green: 2, blue: 2 }, bonus: 120 }, @@ -494,7 +494,7 @@ impl Spec { ], }, - Spec::SpeedRBIII => SpecValues { + Spec::SpeedRBPlusPlus => SpecValues { multi: 15, base: 120, bonuses: vec![ SpecBonus { req: Colours { red: 2, green: 0, blue: 2 }, bonus: 120 }, @@ -507,7 +507,7 @@ impl Spec { multi: 0, base: 100, bonuses: vec![]}, - Spec::LifeRRI => SpecValues { + Spec::LifeRR=> SpecValues { multi: 50, base: 200, bonuses: vec![ SpecBonus { req: Colours { red: 5, green: 0, blue: 0 }, bonus: 100 }, @@ -516,7 +516,7 @@ impl Spec { ], }, - Spec::LifeGGI => SpecValues { + Spec::LifeGG=> SpecValues { multi: 50, base: 200, bonuses: vec![ SpecBonus { req: Colours { red: 0, green: 5, blue: 0 }, bonus: 100 }, @@ -525,7 +525,7 @@ impl Spec { ], }, - Spec::LifeBBI => SpecValues { + Spec::LifeBB=> SpecValues { multi: 50, base: 200, bonuses: vec![ SpecBonus { req: Colours { red: 0, green: 0, blue: 5 }, bonus: 100 }, @@ -534,7 +534,7 @@ impl Spec { ], }, - Spec::LifeRGI => SpecValues { + Spec::LifeRG=> SpecValues { multi: 40, base: 150, bonuses: vec![ SpecBonus { req: Colours { red: 2, green: 2, blue: 0 }, bonus: 75 }, @@ -543,7 +543,7 @@ impl Spec { ], }, - Spec::LifeGBI => SpecValues { + Spec::LifeGB=> SpecValues { multi: 40, base: 150, bonuses: vec![ SpecBonus { req: Colours { red: 0, green: 2, blue: 2 }, bonus: 75 }, @@ -552,7 +552,7 @@ impl Spec { ], }, - Spec::LifeRBI => SpecValues { + Spec::LifeRB=> SpecValues { multi: 40, base: 150, bonuses: vec![ SpecBonus { req: Colours { red: 2, green: 0, blue: 2 }, bonus: 75 }, @@ -561,7 +561,7 @@ impl Spec { ], }, - Spec::LifeRRII => SpecValues { + Spec::LifeRRPlus => SpecValues { multi: 50, base: 300, bonuses: vec![ SpecBonus { req: Colours { red: 5, green: 0, blue: 0 }, bonus: 150 }, @@ -570,7 +570,7 @@ impl Spec { ], }, - Spec::LifeGGII => SpecValues { + Spec::LifeGGPlus => SpecValues { multi: 50, base: 300, bonuses: vec![ SpecBonus { req: Colours { red: 0, green: 5, blue: 0 }, bonus: 150 }, @@ -579,7 +579,7 @@ impl Spec { ], }, - Spec::LifeBBII => SpecValues { + Spec::LifeBBPlus => SpecValues { multi: 50, base: 300, bonuses: vec![ SpecBonus { req: Colours { red: 0, green: 0, blue: 5 }, bonus: 150 }, @@ -588,7 +588,7 @@ impl Spec { ], }, - Spec::LifeRGII => SpecValues { + Spec::LifeRGPlus => SpecValues { multi: 40, base: 200, bonuses: vec![ SpecBonus { req: Colours { red: 2, green: 2, blue: 0 }, bonus: 100 }, @@ -597,7 +597,7 @@ impl Spec { ], }, - Spec::LifeGBII => SpecValues { + Spec::LifeGBPlus => SpecValues { multi: 40, base: 200, bonuses: vec![ SpecBonus { req: Colours { red: 0, green: 2, blue: 2 }, bonus: 100 }, @@ -606,7 +606,7 @@ impl Spec { ], }, - Spec::LifeRBII => SpecValues { + Spec::LifeRBPlus => SpecValues { multi: 40, base: 200, bonuses: vec![ SpecBonus { req: Colours { red: 2, green: 0, blue: 2 }, bonus: 100 }, @@ -614,7 +614,7 @@ impl Spec { SpecBonus { req: Colours { red: 10, green: 0, blue: 10 }, bonus: 100 } ], }, - Spec::LifeRRIII => SpecValues { + Spec::LifeRRPlusPlus => SpecValues { multi: 40, base: 300, bonuses: vec![ SpecBonus { req: Colours { red: 5, green: 0, blue: 0 }, bonus: 300 }, @@ -623,7 +623,7 @@ impl Spec { ], }, - Spec::LifeGGIII => SpecValues { + Spec::LifeGGPlusPlus => SpecValues { multi: 40, base: 300, bonuses: vec![ SpecBonus { req: Colours { red: 0, green: 5, blue: 0 }, bonus: 300 }, @@ -632,7 +632,7 @@ impl Spec { ], }, - Spec::LifeBBIII => SpecValues { + Spec::LifeBBPlusPlus => SpecValues { multi: 40, base: 300, bonuses: vec![ SpecBonus { req: Colours { red: 0, green: 0, blue: 5 }, bonus: 300 }, @@ -641,7 +641,7 @@ impl Spec { ], }, - Spec::LifeRGIII => SpecValues { + Spec::LifeRGPlusPlus => SpecValues { multi: 40, base: 200, bonuses: vec![ SpecBonus { req: Colours { red: 2, green: 2, blue: 0 }, bonus: 200 }, @@ -650,7 +650,7 @@ impl Spec { ], }, - Spec::LifeGBIII => SpecValues { + Spec::LifeGBPlusPlus => SpecValues { multi: 40, base: 200, bonuses: vec![ SpecBonus { req: Colours { red: 0, green: 2, blue: 2 }, bonus: 200 }, @@ -659,7 +659,7 @@ impl Spec { ], }, - Spec::LifeRBIII => SpecValues { + Spec::LifeRBPlusPlus => SpecValues { multi: 40, base: 200, bonuses: vec![ SpecBonus { req: Colours { red: 2, green: 0, blue: 2 }, bonus: 200 }, @@ -675,67 +675,67 @@ impl Spec { // Percentage multipliers based on base value Spec::Power | Spec::Speed => modified + base.pct(self.values().base), - Spec::PowerRRI | - Spec::PowerGGI | - Spec::PowerBBI | - Spec::PowerRGI | - Spec::PowerGBI | - Spec::PowerRBI | - Spec::PowerRRII | - Spec::PowerGGII | - Spec::PowerBBII | - Spec::PowerRGII | - Spec::PowerGBII | - Spec::PowerRBII | - Spec::PowerRRIII | - Spec::PowerGGIII | - Spec::PowerBBIII | - Spec::PowerRGIII | - Spec::PowerGBIII | - Spec::PowerRBIII | + Spec::PowerRR| + Spec::PowerGG| + Spec::PowerBB| + Spec::PowerRG| + Spec::PowerGB| + Spec::PowerRB| + Spec::PowerRRPlus | + Spec::PowerGGPlus | + Spec::PowerBBPlus | + Spec::PowerRGPlus | + Spec::PowerGBPlus | + Spec::PowerRBPlus | + Spec::PowerRRPlusPlus | + Spec::PowerGGPlusPlus | + Spec::PowerBBPlusPlus | + Spec::PowerRGPlusPlus | + Spec::PowerGBPlusPlus | + Spec::PowerRBPlusPlus | - Spec::SpeedRRI | - Spec::SpeedGGI | - Spec::SpeedBBI | - Spec::SpeedRGI | - Spec::SpeedGBI | - Spec::SpeedRBI | - Spec::SpeedRRII | - Spec::SpeedGGII | - Spec::SpeedBBII | - Spec::SpeedRGII | - Spec::SpeedGBII | - Spec::SpeedRBII | - Spec::SpeedRRIII | - Spec::SpeedGGIII | - Spec::SpeedBBIII | - Spec::SpeedRGIII | - Spec::SpeedGBIII | - Spec::SpeedRBIII => modified + { + Spec::SpeedRR| + Spec::SpeedGG| + Spec::SpeedBB| + Spec::SpeedRG| + Spec::SpeedGB| + Spec::SpeedRB| + Spec::SpeedRRPlus | + Spec::SpeedGGPlus | + Spec::SpeedBBPlus | + Spec::SpeedRGPlus | + Spec::SpeedGBPlus | + Spec::SpeedRBPlus | + Spec::SpeedRRPlusPlus | + Spec::SpeedGGPlusPlus | + Spec::SpeedBBPlusPlus | + Spec::SpeedRGPlusPlus | + Spec::SpeedGBPlusPlus | + Spec::SpeedRBPlusPlus => modified + { base.pct(cmp::min(self.values().calc_multi(construct_colours), self.values().max_value(player_colours))) }, // Flat bonus Spec::Life => modified + self.values().base, - Spec::LifeRRI | - Spec::LifeGGI | - Spec::LifeBBI | - Spec::LifeRGI | - Spec::LifeGBI | - Spec::LifeRBI | - Spec::LifeRRII | - Spec::LifeGGII | - Spec::LifeBBII | - Spec::LifeRGII | - Spec::LifeGBII | - Spec::LifeRBII | - Spec::LifeRRIII | - Spec::LifeGGIII | - Spec::LifeBBIII | - Spec::LifeRGIII | - Spec::LifeGBIII | - Spec::LifeRBIII => modified + { - cmp::min(self.values().calc_multi(construct_colours), + Spec::LifeRR| + Spec::LifeGG| + Spec::LifeBB| + Spec::LifeRG| + Spec::LifeGB| + Spec::LifeRB| + Spec::LifeRRPlus | + Spec::LifeGGPlus | + Spec::LifeBBPlus | + Spec::LifeRGPlus | + Spec::LifeGBPlus | + Spec::LifeRBPlus | + Spec::LifeRRPlusPlus | + Spec::LifeGGPlusPlus | + Spec::LifeBBPlusPlus | + Spec::LifeRGPlusPlus | + Spec::LifeGBPlusPlus | + Spec::LifeRBPlusPlus => modified + { + cmp::min(self.values().calc_multi(construct_colours), self.values().max_value(player_colours)) }, } diff --git a/server/src/vbox.rs b/server/src/vbox.rs index ea39f181..6123f910 100644 --- a/server/src/vbox.rs +++ b/server/src/vbox.rs @@ -210,7 +210,7 @@ mod tests { let mut vbox = Vbox::new(); vbox.bound = vec![Item::Attack, Item::Green, Item::Green]; vbox.combine(vec![1,2,0]).unwrap(); - assert_eq!(vbox.bound[0], Item::HealI); + assert_eq!(vbox.bound[0], Item::Heal); } #[test] @@ -228,14 +228,14 @@ mod tests { #[test] fn reclaim_test() { let mut vbox = Vbox::new(); - vbox.bound = vec![Item::StrikeI]; + vbox.bound = vec![Item::Strike]; vbox.reclaim(0).unwrap(); assert_eq!(vbox.bits, 22); } #[test] fn colours_count_test() { - let strike = Item::StrikeI; + let strike = Item::Strike; let mut count = Colours::new(); strike.colours(&mut count);