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 |