From 723201b74cd3657237c1bc92961f774e2fda061c Mon Sep 17 00:00:00 2001 From: ntr Date: Fri, 5 Jul 2019 15:42:37 +1000 Subject: [PATCH] scatter --- COMBOS.md | 2 +- client/index.html | 1 + client/package.json | 2 +- client/src/animations.test.jsx | 8 +- client/src/components/animations.jsx | 7 +- client/src/components/anims/absorb.jsx | 40 +- client/src/components/anims/scatter.jsx | 77 +++ .../anims/{clutch.jsx => sustain.jsx} | 15 - client/src/constants.jsx | 1 + client/src/utils.jsx | 21 +- server/src/effect.rs | 10 +- server/src/game.rs | 10 +- server/src/item.rs | 465 +++++++++--------- server/src/skill.rs | 58 +-- 14 files changed, 397 insertions(+), 320 deletions(-) create mode 100644 client/src/components/anims/scatter.jsx rename client/src/components/anims/{clutch.jsx => sustain.jsx} (89%) diff --git a/COMBOS.md b/COMBOS.md index 3b2ec596..a75ea911 100644 --- a/COMBOS.md +++ b/COMBOS.md @@ -80,7 +80,7 @@ RB - Hex RR - Empower GR - Triage -BB - Absorbtion +BB - Absorb RG - Sustain GB - Amplify RB - Haste diff --git a/client/index.html b/client/index.html index bfb399e6..2dc752d5 100644 --- a/client/index.html +++ b/client/index.html @@ -16,6 +16,7 @@ + diff --git a/client/package.json b/client/package.json index 2e7b152f..cdcc5ce7 100644 --- a/client/package.json +++ b/client/package.json @@ -5,7 +5,7 @@ "main": "index.js", "scripts": { "start": "parcel index.html --host 0.0.0.0 --port 40080 --no-source-maps", - "anims": "parcel animations.html --host 0.0.0.0 --port 40080 --no-source-maps --no-hmr", + "anims": "parcel animations.html --host 0.0.0.0 --port 40080 --no-source-maps", "build": "rm -rf dist && parcel build index.html && cp -r assets/molecules/ dist/", "scss": "node-sass --watch assets/scss -o assets/styles", "lint": "eslint --fix --ext .jsx src/", diff --git a/client/src/animations.test.jsx b/client/src/animations.test.jsx index 467fa351..8e6a2860 100644 --- a/client/src/animations.test.jsx +++ b/client/src/animations.test.jsx @@ -74,12 +74,13 @@ const SKILLS = [ 'Buff', 'Block', 'Stun', + 'AbsorbI', + 'AbsorptionI', 'AmplifyI', 'BanishI', 'BashI', 'BlastI', 'ChaosI', - 'SustainI', 'CounterAttackI', 'CounterI', 'CurseI', @@ -90,10 +91,8 @@ const SKILLS = [ 'ElectrocuteTickI', 'HasteI', 'HasteStrike', - 'AbsorbI', 'HealI', 'HexI', - 'AbsorbtionI', 'HybridBlast', 'HybridI', 'InterceptI', @@ -102,6 +101,7 @@ const SKILLS = [ 'PurifyI', 'RechargeI', 'ReflectI', + 'RestrictI', 'RuinI', 'ScatterI', 'SilenceI', @@ -109,8 +109,8 @@ const SKILLS = [ 'SiphonTickI', 'SlayI', 'SleepI', - 'RestrictI', 'StrikeI', + 'SustainI', 'ThrowI', 'TriageI', 'TriageTickI', diff --git a/client/src/components/animations.jsx b/client/src/components/animations.jsx index de1096a6..a69c1ad3 100644 --- a/client/src/components/animations.jsx +++ b/client/src/components/animations.jsx @@ -4,6 +4,7 @@ const anime = require('animejs').default; const AttackCharge = require('./anims/attack.charge'); const Amplify = require('./anims/amplify'); +const Absorb = require('./anims/absorb'); const Banish = require('./anims/banish'); const Bash = require('./anims/bash'); const Blast = require('./anims/blast'); @@ -19,7 +20,6 @@ const Electrify = require('./anims/electrify'); const Electrocute = require('./anims/electrocute'); const Haste = require('./anims/haste'); const Heal = require('./anims/heal'); -const Hex = require('./anims/hex'); const Hybrid = require('./anims/hybrid'); const Intercept = require('./anims/intercept'); const Invert = require('./anims/invert'); @@ -27,6 +27,7 @@ const Purify = require('./anims/purify'); const Recharge = require('./anims/recharge'); const Refl = require('./anims/reflect'); const Restrict = require('./anims/restrict'); +const Scatter = require('./anims/scatter'); const Siphon = require('./anims/siphon'); const SiphonTick = require('./anims/siphon.tick'); const Slay = require('./anims/slay'); @@ -122,7 +123,7 @@ function animations(props) { case 'Haste': return ; case 'Triage': return ; case 'TriageTick': return ; - case 'Scatter': return false; + case 'Scatter': return ; case 'Hybrid': return ; case 'Intercept': return ; @@ -140,7 +141,7 @@ function animations(props) { case 'Stun': return ; case 'Banish': return ; case 'Bash': return ; - case 'Hex': return ; + case 'Absorb': return ; case 'Sleep': return ; case 'Throw': return false; case 'Ruin': return false; diff --git a/client/src/components/anims/absorb.jsx b/client/src/components/anims/absorb.jsx index 4b9eec13..107ff911 100644 --- a/client/src/components/anims/absorb.jsx +++ b/client/src/components/anims/absorb.jsx @@ -31,12 +31,15 @@ class Absorb extends Component { - - - + + + + ); } @@ -51,13 +54,24 @@ class Absorb extends Component { easing: 'easeInOutSine', })); - anime({ - targets: ['#absorb path'], - strokeDashoffset: [anime.setDashoffset, 0], - duration: 2000, - easing: 'linear', - loop: true, - }); + this.animations.push(anime({ + targets: ['#absorb polygon'], + points: '64 124.94732621931382 8.574 96.00354944613788 8.62269130211947 32.03166105954991 64 4 119.37730869788052 32.03166105954991 119.426 96.00354944613788', + easing: 'easeOutExpo', + + delay: TIMES.TARGET_DELAY_MS, + duration: TIMES.TARGET_DURATION_MS, + })); + + this.animations.push(anime({ + targets: ['#absorb polygon.white'], + strokeWidth: [2, 1], + easing: 'easeInOutSine', + direction: 'alternate', + + delay: TIMES.TARGET_DELAY_MS, + duration: TIMES.TARGET_DURATION_MS, + })); } // this is necessary because diff --git a/client/src/components/anims/scatter.jsx b/client/src/components/anims/scatter.jsx new file mode 100644 index 00000000..ab26af47 --- /dev/null +++ b/client/src/components/anims/scatter.jsx @@ -0,0 +1,77 @@ +const preact = require('preact'); +const { Component } = require('preact'); + +const anime = require('animejs').default; + +const { TIMES } = require('../../constants'); + +class Scatter extends Component { + constructor() { + super(); + this.animations = []; + } + + render() { + return ( + + + + + + + + + + + + + + + ); + } + + componentDidMount() { + this.animations.push(anime({ + targets: ['#scatter'], + opacity: [ + { value: 1, delay: TIMES.TARGET_DELAY_MS, duration: 1000 }, + // { value: 0, delay: TIMES.TARGET_DURATION_MS * 0.6, duration: TIMES.TARGET_DURATION_MS * 0.2 }, + ], + easing: 'easeInOutSine', + })); + + anime({ + targets: ['#scatter path'], + strokeDashoffset: [anime.setDashoffset, 0], + duration: TIMES.TARGET_DURATION_MS * 0.8, + delay: TIMES.TARGET_DELAY_MS, + easing: 'easeInOutSine', + }); + } + + // this is necessary because + // skipping / timing / unmounting race conditions + // can cause the animations to cut short, this will ensure the values are reset + // because preact will recycle all these components + componentWillUnmount() { + for (let i = this.animations.length - 1; i >= 0; i--) { + this.animations[i].reset(); + } + } +} + +module.exports = Scatter; diff --git a/client/src/components/anims/clutch.jsx b/client/src/components/anims/sustain.jsx similarity index 89% rename from client/src/components/anims/clutch.jsx rename to client/src/components/anims/sustain.jsx index 035f282e..21e56ac9 100644 --- a/client/src/components/anims/clutch.jsx +++ b/client/src/components/anims/sustain.jsx @@ -123,18 +123,3 @@ class Sustain extends Component { } module.exports = Sustain; - - -/* - - -*/ \ No newline at end of file diff --git a/client/src/constants.jsx b/client/src/constants.jsx index 3e6ff11b..f8c0ecff 100644 --- a/client/src/constants.jsx +++ b/client/src/constants.jsx @@ -19,6 +19,7 @@ module.exports = { RED: '#a52a2a', BLUE: '#3498db', WHITE: '#f5f5f5', // whitesmoke + PURPLE: '#9355b5' // 6lack - that far cover }, INFO: { diff --git a/client/src/utils.jsx b/client/src/utils.jsx index 02234713..d8c5a31c 100644 --- a/client/src/utils.jsx +++ b/client/src/utils.jsx @@ -371,6 +371,7 @@ const removeTier = skill => { if (skill.includes('Ruin')) return 'Ruin'; if (skill.includes('Throw')) return 'Throw'; if (skill.includes('Hex')) return 'Hex'; + if (skill.includes('Absorb')) return 'Absorb'; if (skill.includes('Banish')) return 'Banish'; return skill; @@ -379,20 +380,20 @@ const removeTier = skill => { const SERVER = process.env.NODE_ENV === 'production' ? '/api/' : 'http://localhost:40000/api'; function postData(url = '/', data = {}) { - // Default options are marked with * + // Default options are marked with * return fetch(`${SERVER}${url}`, { - method: "POST", // *GET, POST, PUT, DELETE, etc. - // mode: "no-cors", // no-cors, cors, *same-origin - cache: "no-cache", // *default, no-cache, reload, force-cache, only-if-cached - credentials: "include", // include, same-origin, *omit + method: 'POST', // *GET, POST, PUT, DELETE, etc. + // mode: 'no-cors', // no-cors, cors, *same-origin + cache: 'no-cache', // *default, no-cache, reload, force-cache, only-if-cached + credentials: 'include', // include, same-origin, *omit headers: { - 'Accept': 'application/json', - 'content-type': 'application/json' + Accept: 'application/json', + 'content-type': 'application/json', }, - redirect: "error", // manual, *follow, error - // referrer: "", // no-referrer, *client + redirect: 'error', // manual, *follow, error + // referrer: ', // no-referrer, *client body: JSON.stringify(data), // body data type must match "Content-Type" header - }) + }); } module.exports = { diff --git a/server/src/effect.rs b/server/src/effect.rs index 36b92390..bd881cfc 100644 --- a/server/src/effect.rs +++ b/server/src/effect.rs @@ -34,8 +34,8 @@ pub enum Effect { // absorbtion is the buff // absorb is the increased damage - Absorbtion, Absorb, + Absorption, // magic immunity Scatter, @@ -114,7 +114,7 @@ impl Effect { Effect::Block => vec![Stat::RedDamageTaken], Effect::Buff => vec![Stat::RedPower, Stat::Speed], - Effect::Absorb => vec![Stat::RedPower, Stat::BluePower], + Effect::Absorption => vec![Stat::RedPower, Stat::BluePower], Effect::Amplify => vec![Stat::RedPower, Stat::BluePower], Effect::Curse => vec![Stat::BlueDamageTaken], @@ -148,7 +148,7 @@ impl Effect { Effect::Scatter => value >> 1, - Effect::Absorb => value + match meta { + Effect::Absorption => value + match meta { Some(EffectMeta::AddedDamage(d)) => d, _ => panic!("absorb meta not damage"), }, @@ -180,7 +180,7 @@ impl Effect { Effect::Slow => Some(Colour::Blue), Effect::Haste => Some(Colour::Green), - Effect::Absorb => Some(Colour::Green), + Effect::Absorption => Some(Colour::Green), Effect::Reflect => Some(Colour::Green), Effect::Amplify => Some(Colour::Green), Effect::Silence => Some(Colour::Blue), @@ -190,7 +190,7 @@ impl Effect { Effect::Electric => Some(Colour::Green), Effect::Electrocute => Some(Colour::Blue), - Effect::Absorbtion => Some(Colour::Green), + Effect::Absorb => Some(Colour::Green), // magic Effect::Hybrid => Some(Colour::Green), diff --git a/server/src/game.rs b/server/src/game.rs index 329a685e..6cd0291b 100644 --- a/server/src/game.rs +++ b/server/src/game.rs @@ -1197,18 +1197,18 @@ mod tests { // let x_construct = x_player.constructs[0].clone(); // let y_construct = y_player.constructs[0].clone(); - // game.construct_by_id(x_construct.id).unwrap().learn_mut(Skill::Absorbtion); + // game.construct_by_id(x_construct.id).unwrap().learn_mut(Skill::Absorb); - // while game.construct_by_id(x_construct.id).unwrap().skill_on_cd(Skill::Absorbtion).is_some() { + // while game.construct_by_id(x_construct.id).unwrap().skill_on_cd(Skill::Absorb).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::Absorbtion).unwrap(); + // game.add_skill(x_player.id, x_construct.id, Some(x_construct.id), Skill::Absorb).unwrap(); // game.player_ready(x_player.id).unwrap(); // game.player_ready(y_player.id).unwrap(); // game = game.resolve_phase_start(); - // assert!(game.construct_by_id(x_construct.id).unwrap().affected(Effect::Absorbtion)); + // assert!(game.construct_by_id(x_construct.id).unwrap().affected(Effect::Absorb)); // // attack and receive debuff // game.add_skill(y_player.id, y_construct.id, Some(x_construct.id), Skill::TestAttack).unwrap(); @@ -1217,7 +1217,7 @@ mod tests { // game = game.resolve_phase_start(); // info!("{:#?}", game); - // assert!(game.construct_by_id(y_construct.id).unwrap().affected(Effect::Absorb)); + // assert!(game.construct_by_id(y_construct.id).unwrap().affected(Effect::Absorption)); // } #[test] diff --git a/server/src/item.rs b/server/src/item.rs index ee59ecce..51d0a901 100644 --- a/server/src/item.rs +++ b/server/src/item.rs @@ -88,6 +88,9 @@ pub enum Item { AmplifyI, AmplifyII, AmplifyIII, + AbsorbI, + AbsorbII, + AbsorbIII, BanishI, BanishII, BanishIII, @@ -112,18 +115,15 @@ pub enum Item { DecayI, DecayII, DecayIII, - AbsorbtionI, - AbsorbtionII, - AbsorbtionIII, + HexI, + HexII, + HexIII, HasteI, HasteII, HasteIII, HealI, HealII, HealIII, - HexI, - HexII, - HexIII, HybridI, HybridII, HybridIII, @@ -295,105 +295,102 @@ impl Item { pub fn into_skill(&self) -> Option { match self { - Item::Attack => Some(Skill::Attack), - Item::AmplifyI => Some(Skill::AmplifyI), - Item::AmplifyII => Some(Skill::AmplifyII), - Item::AmplifyIII => Some(Skill::AmplifyIII), - Item::BanishI => Some(Skill::BanishI), - Item::BanishII => Some(Skill::BanishII), - Item::BanishIII => Some(Skill::BanishIII), - Item::BlastI => Some(Skill::BlastI), - Item::BlastII => Some(Skill::BlastII), - Item::BlastIII => Some(Skill::BlastIII), - 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::CurseI => Some(Skill::CurseI), - Item::CurseII => Some(Skill::CurseII), - Item::CurseIII => Some(Skill::CurseIII), - Item::Debuff => Some(Skill::Debuff), - Item::DecayI => Some(Skill::DecayI), - Item::DecayII => Some(Skill::DecayII), - Item::DecayIII => Some(Skill::DecayIII), - 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::HexI => Some(Skill::HexI), - Item::HexII => Some(Skill::HexII), - Item::HexIII => Some(Skill::HexIII), - Item::AbsorbtionI => Some(Skill::AbsorbtionI), - Item::AbsorbtionII => Some(Skill::AbsorbtionII), - Item::AbsorbtionIII=> Some(Skill::AbsorbtionIII), - Item::HybridI => Some(Skill::HybridI), - Item::HybridII => Some(Skill::HybridII), - Item::HybridIII => Some(Skill::HybridIII), - Item::InvertI => Some(Skill::InvertI), - Item::InvertII => Some(Skill::InvertII), - Item::InvertIII => Some(Skill::InvertIII), + 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::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::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::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::RuinI => Some(Skill::RuinI), - Item::RuinII => Some(Skill::RuinII), - Item::RuinIII => Some(Skill::RuinIII), - Item::ScatterI => Some(Skill::ScatterI), - Item::ScatterII => Some(Skill::ScatterII), - Item::ScatterIII => Some(Skill::ScatterIII), - Item::SilenceI => Some(Skill::SilenceI), - Item::SilenceII => Some(Skill::SilenceII), - Item::SilenceIII => Some(Skill::SilenceIII), - 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::SiphonI => Some(Skill::SiphonI), - Item::SiphonII => Some(Skill::SiphonII), - Item::SiphonIII => Some(Skill::SiphonIII), - Item::RestrictI => Some(Skill::RestrictI), - Item::RestrictII => Some(Skill::RestrictII), - Item::RestrictIII => Some(Skill::RestrictIII), - Item::BashI => Some(Skill::BashI), - Item::BashII => Some(Skill::BashII), - Item::BashIII => Some(Skill::BashIII), - Item::Stun => Some(Skill::Stun), - Item::StrikeI => Some(Skill::StrikeI), - Item::StrikeII => Some(Skill::StrikeII), - Item::StrikeIII => Some(Skill::StrikeIII), - Item::SustainI => Some(Skill::SustainI), - Item::SustainII => Some(Skill::SustainII), - Item::SustainIII => Some(Skill::SustainIII), - Item::InterceptI => Some(Skill::InterceptI), - Item::InterceptII => Some(Skill::InterceptII), - Item::InterceptIII => Some(Skill::InterceptIII), - Item::ThrowI => Some(Skill::ThrowI), - Item::ThrowII => Some(Skill::ThrowII), - Item::ThrowIII => Some(Skill::ThrowIII), + Item::CurseI => Some(Skill::CurseI), + Item::CurseII => Some(Skill::CurseII), + Item::CurseIII => Some(Skill::CurseIII), + 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::TriageI => Some(Skill::TriageI), - Item::TriageII => Some(Skill::TriageII), - Item::TriageIII => Some(Skill::TriageIII), - _ => None, + 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::ScatterI => Some(Skill::ScatterI), + Item::ScatterII => Some(Skill::ScatterII), + Item::ScatterIII => Some(Skill::ScatterIII), + 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::Stun => Some(Skill::Stun), + Item::SustainI => Some(Skill::SustainI), + Item::SustainII => Some(Skill::SustainII), + Item::SustainIII => Some(Skill::SustainIII), + Item::ThrowI => Some(Skill::ThrowI), + Item::ThrowII => Some(Skill::ThrowII), + Item::ThrowIII => Some(Skill::ThrowIII), + Item::TriageI => Some(Skill::TriageI), + Item::TriageII => Some(Skill::TriageII), + Item::TriageIII => Some(Skill::TriageIII), + _ => None, } } @@ -626,12 +623,12 @@ impl Item { self.into_skill().unwrap().effect()[1].get_skill().unwrap().multiplier(), self.into_skill().unwrap().effect()[1].get_duration()), - Item::AbsorbtionI | - Item::AbsorbtionII | - Item::AbsorbtionIII => format!( - "Gain Absorbtion for {:?}T. {} Absorb lasts {:?}T", + Item::AbsorbI | + Item::AbsorbII | + Item::AbsorbIII => format!( + "Gain Absorb for {:?}T. {} Absorption lasts {:?}T", self.into_skill().unwrap().effect()[0].get_duration(), - "When attacked by Absorbtion you gain Absorb which increased red and blue power based on Damage taken.", + "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 | @@ -856,9 +853,9 @@ impl Item { Item::ThrowI => vec![Item::Stun, Item::Red, Item::Green], Item::ThrowII => vec![Item::ThrowI, Item::ThrowI, Item::ThrowI], Item::ThrowIII => vec![Item::ThrowII, Item::ThrowII, Item::ThrowII], - Item::HexI => vec![Item::Stun, Item::Green, Item::Blue], - Item::HexII => vec![Item::HexI, Item::HexI, Item::HexI], - Item::HexIII => vec![Item::HexII, Item::HexII, Item::HexII], + 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], @@ -951,129 +948,129 @@ impl Item { impl From for Item { fn from(skill: Skill) -> Item { match skill { - Skill::AmplifyI => Item::AmplifyI, - Skill::AmplifyII => Item::AmplifyII, - Skill::AmplifyIII => Item::AmplifyIII, - Skill::Attack => Item::Attack, - Skill::BanishI => Item::BanishI, - Skill::BanishII => Item::BanishII, - Skill::BanishIII => Item::BanishIII, - Skill::BlastI => Item::BlastI, - Skill::BlastII => Item::BlastII, - Skill::BlastIII => Item::BlastIII, - Skill::Block => Item::Block, - Skill::Buff => Item::Buff, - Skill::ChaosI => Item::ChaosI, - Skill::ChaosII => Item::ChaosII, - Skill::ChaosIII => Item::ChaosIII, - Skill::ElectrifyI => Item::ElectrifyI, - Skill::ElectrifyII => Item::ElectrifyII, - Skill::ElectrifyIII => Item::ElectrifyIII, - Skill::SustainI => Item::SustainI, - Skill::SustainII => Item::SustainII, - Skill::SustainIII => Item::SustainIII, - Skill::CurseI => Item::CurseI, - Skill::CurseII => Item::CurseII, - Skill::CurseIII => Item::CurseIII, - Skill::DecayI => Item::DecayI, - Skill::DecayII => Item::DecayII, - Skill::DecayIII => Item::DecayIII, - Skill::Debuff => Item::Debuff, - Skill::HasteI => Item::HasteI, - Skill::HasteII => Item::HasteII, - Skill::HasteIII => Item::HasteIII, - Skill::AbsorbtionI => Item::AbsorbtionI, - Skill::AbsorbtionII => Item::AbsorbtionII, - Skill::AbsorbtionIII => Item::AbsorbtionIII, - 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::InvertI => Item::InvertI, - Skill::InvertII => Item::InvertII, - Skill::InvertIII => Item::InvertIII, - Skill::CounterI => Item::CounterI, - Skill::CounterII => Item::CounterII, - Skill::CounterIII => Item::CounterIII, - 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::RuinI => Item::RuinI, - Skill::RuinII => Item::RuinII, - Skill::RuinIII => Item::RuinIII, - Skill::ScatterI => Item::ScatterI, - Skill::ScatterII => Item::ScatterII, - Skill::ScatterIII => Item::ScatterIII, - 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::RestrictI => Item::RestrictI, - Skill::RestrictII => Item::RestrictII, - Skill::RestrictIII => Item::RestrictIII, - Skill::BashI => Item::BashI, - Skill::BashII => Item::BashII, - Skill::BashIII => Item::BashIII, - Skill::StrikeI => Item::StrikeI, - Skill::StrikeII => Item::StrikeII, - Skill::StrikeIII => Item::StrikeIII, - Skill::Stun => Item::Stun, - Skill::InterceptI => Item::InterceptI, - Skill::InterceptII => Item::InterceptII, - Skill::InterceptIII => Item::InterceptIII, - Skill::ThrowI => Item::ThrowI, - Skill::ThrowII => Item::ThrowII, - Skill::ThrowIII => Item::ThrowIII, - Skill::TriageI => Item::TriageI, - Skill::TriageII => Item::TriageII, - Skill::TriageIII => Item::TriageIII, + 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::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::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::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::ScatterI => Item::ScatterI, + Skill::ScatterII => Item::ScatterII, + Skill::ScatterIII => Item::ScatterIII, + 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::Stun => Item::Stun, + Skill::SustainI => Item::SustainI, + Skill::SustainII => Item::SustainII, + Skill::SustainIII => Item::SustainIII, + Skill::ThrowI => Item::ThrowI, + Skill::ThrowII => Item::ThrowII, + Skill::ThrowIII => Item::ThrowIII, + Skill::TriageI => Item::TriageI, + Skill::TriageII => Item::TriageII, + Skill::TriageIII => Item::TriageIII, // 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::AbsorbI => Item::AbsorbtionI, - Skill::AbsorbII => Item::AbsorbtionII, - Skill::AbsorbIII => Item::AbsorbtionIII, - 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::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, } } } @@ -1172,9 +1169,9 @@ pub fn get_combos() -> Vec { 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::AbsorbtionI.combo(), item: Item::AbsorbtionI }, - Combo { components: Item::AbsorbtionII.combo(), item: Item::AbsorbtionII }, - Combo { components: Item::AbsorbtionIII.combo(), item: Item::AbsorbtionIII }, + 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 }, @@ -1241,9 +1238,9 @@ pub fn get_combos() -> Vec { Combo { components: Item::ThrowI.combo(), item: Item::ThrowI }, Combo { components: Item::ThrowII.combo(), item: Item::ThrowII }, Combo { components: Item::ThrowIII.combo(), item: Item::ThrowIII }, - Combo { components: Item::HexI.combo(), item: Item::HexI }, - Combo { components: Item::HexII.combo(), item: Item::HexII }, - Combo { components: Item::HexIII.combo(), item: Item::HexIII }, + 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 }, diff --git a/server/src/skill.rs b/server/src/skill.rs index 97477a6b..6b582295 100644 --- a/server/src/skill.rs +++ b/server/src/skill.rs @@ -176,9 +176,9 @@ pub fn resolve(skill: Skill, source: &mut Construct, target: &mut Construct, mut Skill::HexII | Skill::HexIII => hex(source, target, resolutions, skill), - Skill::AbsorbtionI | - Skill::AbsorbtionII | - Skill::AbsorbtionIII => absorbtion(source, target, resolutions, skill), + Skill::AbsorbI | + Skill::AbsorbII | + Skill::AbsorbIII => absorbtion(source, target, resolutions, skill), Skill::HybridI | Skill::HybridII | @@ -271,9 +271,9 @@ pub fn resolve(skill: Skill, source: &mut Construct, target: &mut Construct, mut Skill::ElectrocuteII | Skill::ElectrocuteIII => panic!("should only trigger from electrify hit"), Skill::HasteStrike => panic!("should only trigger from haste"), - Skill::AbsorbI | - Skill::AbsorbII | - Skill::AbsorbIII => panic!("should only trigger from absorb"), + Skill::AbsorptionI | + Skill::AbsorptionII | + Skill::AbsorptionIII => panic!("should only trigger from absorb"), Skill::HybridBlast => panic!("should only trigger from hybrid"), Skill::CounterAttackI | Skill::CounterAttackII | @@ -304,9 +304,9 @@ fn post_resolve(_skill: Skill, game: &mut Game, mut resolutions: Resolutions) -> }; } - if target.affected(Effect::Absorbtion) { + if target.affected(Effect::Absorb) { let ConstructEffect { effect: _, duration: _, meta, tick: _ } = target.effects.iter() - .find(|e| e.effect == Effect::Absorbtion).unwrap().clone(); + .find(|e| e.effect == Effect::Absorb).unwrap().clone(); match meta { Some(EffectMeta::Skill(s)) => { resolutions = absorb(&mut target, &mut source, resolutions, skill, amount, s); @@ -544,12 +544,12 @@ pub enum Skill { HexII, HexIII, + AbsorptionI, + AbsorptionII, + AbsorptionIII, AbsorbI, AbsorbII, AbsorbIII, - AbsorbtionI, - AbsorbtionII, - AbsorbtionIII, HybridBlast, HybridI, @@ -790,16 +790,16 @@ impl Skill { 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::AbsorbtionI => vec![ConstructEffect {effect: Effect::Absorbtion, duration: 2, - meta: Some(EffectMeta::Skill(Skill::AbsorbI)), tick: None}], - Skill::AbsorbtionII => vec![ConstructEffect {effect: Effect::Absorbtion, duration: 3, - meta: Some(EffectMeta::Skill(Skill::AbsorbII)), tick: None}], - Skill::AbsorbtionIII => vec![ConstructEffect {effect: Effect::Absorbtion, duration: 4, - meta: Some(EffectMeta::Skill(Skill::AbsorbIII)), 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::AbsorbI => vec![ConstructEffect {effect: Effect::Absorb, duration: 5, meta: None, tick: None}], - Skill::AbsorbII => vec![ConstructEffect {effect: Effect::Absorb, duration: 7, meta: None, tick: None}], - Skill::AbsorbIII => vec![ConstructEffect {effect: Effect::Absorb, duration: 9, meta: None, 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::HybridI => vec![ConstructEffect {effect: Effect::Hybrid, duration: 2, meta: Some(EffectMeta::Multiplier(150)), tick: None }], @@ -1010,9 +1010,9 @@ impl Skill { Skill::ElectrifyIII =>Some(1), - Skill::AbsorbtionI | - Skill::AbsorbtionII | - Skill::AbsorbtionIII => Some(1), + Skill::AbsorbI | + Skill::AbsorbII | + Skill::AbsorbIII => Some(1), //----------- // Never cast directly @@ -1026,9 +1026,9 @@ impl Skill { Skill::ElectrocuteI | Skill::ElectrocuteII | Skill::ElectrocuteIII | - Skill::AbsorbI | - Skill::AbsorbII | - Skill::AbsorbIII | + Skill::AbsorptionI | + Skill::AbsorptionII | + Skill::AbsorptionIII | // Ticks Skill::ElectrocuteTickI | Skill::ElectrocuteTickII | @@ -1153,9 +1153,9 @@ impl Skill { Skill::HealI | Skill::HealII | Skill::HealIII | - Skill::AbsorbtionI | - Skill::AbsorbtionII | - Skill::AbsorbtionIII | + Skill::AbsorbI | + Skill::AbsorbII | + Skill::AbsorbIII | Skill::InvertI | Skill::InvertII | Skill::InvertIII |