ntr/mnml
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

scatter

Browse Source
This commit is contained in:
ntr 2019-07-05 15:42:37 +10:00
parent 3f974cb0fa
commit 723201b74c
14 changed files with 397 additions and 320 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
COMBOS.md
View File

@ -80,7 +80,7 @@ RB - Hex
RR - Empower RR - Empower
GR - Triage GR - Triage
BB - Absorbtion BB - Absorb
RG - Sustain RG - Sustain
GB - Amplify GB - Amplify
RB - Haste RB - Haste

1
client/index.html
View File

@ -16,6 +16,7 @@
</head> </head>
</head> </head>
<body> <body>
<noscript>js is required to run mnml</noscript>
</body> </body>
<script src="https://js.stripe.com/v3/"></script> <script src="https://js.stripe.com/v3/"></script>
<script src="./index.js"></script> <script src="./index.js"></script>

2
client/package.json
View File

@ -5,7 +5,7 @@
"main": "index.js", "main": "index.js",
"scripts": { "scripts": {
"start": "parcel index.html --host 0.0.0.0 --port 40080 --no-source-maps", "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/", "build": "rm -rf dist && parcel build index.html && cp -r assets/molecules/ dist/",
"scss": "node-sass --watch assets/scss -o assets/styles", "scss": "node-sass --watch assets/scss -o assets/styles",
"lint": "eslint --fix --ext .jsx src/", "lint": "eslint --fix --ext .jsx src/",

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

@ -74,12 +74,13 @@ const SKILLS = [
'Buff', 'Buff',
'Block', 'Block',
'Stun', 'Stun',
'AbsorbI',
'AbsorptionI',
'AmplifyI', 'AmplifyI',
'BanishI', 'BanishI',
'BashI', 'BashI',
'BlastI', 'BlastI',
'ChaosI', 'ChaosI',
'SustainI',
'CounterAttackI', 'CounterAttackI',
'CounterI', 'CounterI',
'CurseI', 'CurseI',
@ -90,10 +91,8 @@ const SKILLS = [
'ElectrocuteTickI', 'ElectrocuteTickI',
'HasteI', 'HasteI',
'HasteStrike', 'HasteStrike',
'AbsorbI',
'HealI', 'HealI',
'HexI', 'HexI',
'AbsorbtionI',
'HybridBlast', 'HybridBlast',
'HybridI', 'HybridI',
'InterceptI', 'InterceptI',
@ -102,6 +101,7 @@ const SKILLS = [
'PurifyI', 'PurifyI',
'RechargeI', 'RechargeI',
'ReflectI', 'ReflectI',
'RestrictI',
'RuinI', 'RuinI',
'ScatterI', 'ScatterI',
'SilenceI', 'SilenceI',
@ -109,8 +109,8 @@ const SKILLS = [
'SiphonTickI', 'SiphonTickI',
'SlayI', 'SlayI',
'SleepI', 'SleepI',
'RestrictI',
'StrikeI', 'StrikeI',
'SustainI',
'ThrowI', 'ThrowI',
'TriageI', 'TriageI',
'TriageTickI', 'TriageTickI',

7
client/src/components/animations.jsx
View File

@ -4,6 +4,7 @@ const anime = require('animejs').default;
const AttackCharge = require('./anims/attack.charge'); const AttackCharge = require('./anims/attack.charge');
const Amplify = require('./anims/amplify'); const Amplify = require('./anims/amplify');
const Absorb = require('./anims/absorb');
const Banish = require('./anims/banish'); const Banish = require('./anims/banish');
const Bash = require('./anims/bash'); const Bash = require('./anims/bash');
const Blast = require('./anims/blast'); const Blast = require('./anims/blast');
@ -19,7 +20,6 @@ const Electrify = require('./anims/electrify');
const Electrocute = require('./anims/electrocute'); const Electrocute = require('./anims/electrocute');
const Haste = require('./anims/haste'); const Haste = require('./anims/haste');
const Heal = require('./anims/heal'); const Heal = require('./anims/heal');
const Hex = require('./anims/hex');
const Hybrid = require('./anims/hybrid'); const Hybrid = require('./anims/hybrid');
const Intercept = require('./anims/intercept'); const Intercept = require('./anims/intercept');
const Invert = require('./anims/invert'); const Invert = require('./anims/invert');
@ -27,6 +27,7 @@ const Purify = require('./anims/purify');
const Recharge = require('./anims/recharge'); const Recharge = require('./anims/recharge');
const Refl = require('./anims/reflect'); const Refl = require('./anims/reflect');
const Restrict = require('./anims/restrict'); const Restrict = require('./anims/restrict');
const Scatter = require('./anims/scatter');
const Siphon = require('./anims/siphon'); const Siphon = require('./anims/siphon');
const SiphonTick = require('./anims/siphon.tick'); const SiphonTick = require('./anims/siphon.tick');
const Slay = require('./anims/slay'); const Slay = require('./anims/slay');
@ -122,7 +123,7 @@ function animations(props) {
case 'Haste': return <Haste />; case 'Haste': return <Haste />;
case 'Triage': return <Triage />; case 'Triage': return <Triage />;
case 'TriageTick': return <TriageTick />; case 'TriageTick': return <TriageTick />;
case 'Scatter': return false; case 'Scatter': return <Scatter player={player} />;
case 'Hybrid': return <Hybrid />; case 'Hybrid': return <Hybrid />;
case 'Intercept': return <Intercept player={player} />; case 'Intercept': return <Intercept player={player} />;
@ -140,7 +141,7 @@ function animations(props) {
case 'Stun': return <Stun />; case 'Stun': return <Stun />;
case 'Banish': return <Banish id={construct.id} />; case 'Banish': return <Banish id={construct.id} />;
case 'Bash': return <Bash />; case 'Bash': return <Bash />;
case 'Hex': return <Hex />; case 'Absorb': return <Absorb />;
case 'Sleep': return <Sleep />; case 'Sleep': return <Sleep />;
case 'Throw': return false; case 'Throw': return false;
case 'Ruin': return false; case 'Ruin': return false;

40
client/src/components/anims/absorb.jsx
View File

@ -31,12 +31,15 @@ class Absorb extends Component {
</feMerge> </feMerge>
</filter> </filter>
</defs> </defs>
<g class='blue' filter='url(#absorbFilter)'> <polygon
<path d= " class='blue'
M 64 4 points="64 68.64 8.574 100 63.446 67.68 64 4 64.554 67.68 119.426 100"
L 64 96 filter="url(#absorbFilter)">
"/> </polygon>
</g> <polygon
class='white'
points="64 68.64 8.574 100 63.446 67.68 64 4 64.554 67.68 119.426 100">
</polygon>
</svg> </svg>
); );
} }
@ -51,13 +54,24 @@ class Absorb extends Component {
easing: 'easeInOutSine', easing: 'easeInOutSine',
})); }));
anime({ this.animations.push(anime({
targets: ['#absorb path'], targets: ['#absorb polygon'],
strokeDashoffset: [anime.setDashoffset, 0], points: '64 124.94732621931382 8.574 96.00354944613788 8.62269130211947 32.03166105954991 64 4 119.37730869788052 32.03166105954991 119.426 96.00354944613788',
duration: 2000, easing: 'easeOutExpo',
easing: 'linear',
loop: true, 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 // this is necessary because

77
client/src/components/anims/scatter.jsx Normal file
View File

@ -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 (
<svg
class='skill-animation blue'
version="1.1"
id="scatter"
xmlns="http://www.w3.org/2000/svg"
viewBox="0 0 128 128">
<defs>
<filter id="scatterFilter">
<feGaussianBlur in="SourceGraphic" stdDeviation="5" />
<feMerge>
<feMergeNode />
<feMergeNode in="SourceGraphic" />
</feMerge>
</filter>
</defs>
<g class='blue' filter='url(#scatterFilter)' stroke-width="4px" stroke-linecap="round" >
<path d= "
M 4 4
h 30
q 30 0 30 30
q 0 30 30 30
h 30
q 0 -30 -30 -30
h -60
q -30 0 -30 -30
"/>
</g>
</svg>
);
}
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;

15
client/src/components/anims/clutch.jsx → client/src/components/anims/sustain.jsx
View File

@ -123,18 +123,3 @@ class Sustain extends Component {
} }
module.exports = Sustain; module.exports = Sustain;
/* <polyline
points='128,168 80,240 176,240 128,168'
style={{ filter: 'url("#sustainFilter")' }}
/>
<polyline
points='176,240 212,216 128,96 44,216 80,240'
style={{ filter: 'url("#sustainFilter")' }}
/>
<polyline
points='212,216 248,192 128,24 8,192 44,216'
style={{ filter: 'url("#sustainFilter")' }}
/>
*/

1
client/src/constants.jsx
View File

@ -19,6 +19,7 @@ module.exports = {
RED: '#a52a2a', RED: '#a52a2a',
BLUE: '#3498db', BLUE: '#3498db',
WHITE: '#f5f5f5', // whitesmoke WHITE: '#f5f5f5', // whitesmoke
PURPLE: '#9355b5' // 6lack - that far cover
}, },
INFO: { INFO: {

21
client/src/utils.jsx
View File

@ -371,6 +371,7 @@ const removeTier = skill => {
if (skill.includes('Ruin')) return 'Ruin'; if (skill.includes('Ruin')) return 'Ruin';
if (skill.includes('Throw')) return 'Throw'; if (skill.includes('Throw')) return 'Throw';
if (skill.includes('Hex')) return 'Hex'; if (skill.includes('Hex')) return 'Hex';
if (skill.includes('Absorb')) return 'Absorb';
if (skill.includes('Banish')) return 'Banish'; if (skill.includes('Banish')) return 'Banish';
return skill; return skill;
@ -379,20 +380,20 @@ const removeTier = skill => {
const SERVER = process.env.NODE_ENV === 'production' ? '/api/' : 'http://localhost:40000/api'; const SERVER = process.env.NODE_ENV === 'production' ? '/api/' : 'http://localhost:40000/api';
function postData(url = '/', data = {}) { function postData(url = '/', data = {}) {
// Default options are marked with * // Default options are marked with *
return fetch(`${SERVER}${url}`, { return fetch(`${SERVER}${url}`, {
method: "POST", // *GET, POST, PUT, DELETE, etc. method: 'POST', // *GET, POST, PUT, DELETE, etc.
// mode: "no-cors", // no-cors, cors, *same-origin // mode: 'no-cors', // no-cors, cors, *same-origin
cache: "no-cache", // *default, no-cache, reload, force-cache, only-if-cached cache: 'no-cache', // *default, no-cache, reload, force-cache, only-if-cached
credentials: "include", // include, same-origin, *omit credentials: 'include', // include, same-origin, *omit
headers: { headers: {
'Accept': 'application/json', Accept: 'application/json',
'content-type': 'application/json' 'content-type': 'application/json',
}, },
redirect: "error", // manual, *follow, error redirect: 'error', // manual, *follow, error
// referrer: "", // no-referrer, *client // referrer: ', // no-referrer, *client
body: JSON.stringify(data), // body data type must match "Content-Type" header body: JSON.stringify(data), // body data type must match "Content-Type" header
}) });
} }
module.exports = { module.exports = {

10
server/src/effect.rs
View File

@ -34,8 +34,8 @@ pub enum Effect {
// absorbtion is the buff // absorbtion is the buff
// absorb is the increased damage // absorb is the increased damage
Absorbtion,
Absorb, Absorb,
Absorption,
// magic immunity // magic immunity
Scatter, Scatter,
@ -114,7 +114,7 @@ impl Effect {
Effect::Block => vec![Stat::RedDamageTaken], Effect::Block => vec![Stat::RedDamageTaken],
Effect::Buff => vec![Stat::RedPower, Stat::Speed], 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::Amplify => vec![Stat::RedPower, Stat::BluePower],
Effect::Curse => vec![Stat::BlueDamageTaken], Effect::Curse => vec![Stat::BlueDamageTaken],
@ -148,7 +148,7 @@ impl Effect {
Effect::Scatter => value >> 1, Effect::Scatter => value >> 1,
Effect::Absorb => value + match meta { Effect::Absorption => value + match meta {
Some(EffectMeta::AddedDamage(d)) => d, Some(EffectMeta::AddedDamage(d)) => d,
_ => panic!("absorb meta not damage"), _ => panic!("absorb meta not damage"),
}, },
@ -180,7 +180,7 @@ impl Effect {
Effect::Slow => Some(Colour::Blue), Effect::Slow => Some(Colour::Blue),
Effect::Haste => Some(Colour::Green), Effect::Haste => Some(Colour::Green),
Effect::Absorb => Some(Colour::Green), Effect::Absorption => Some(Colour::Green),
Effect::Reflect => Some(Colour::Green), Effect::Reflect => Some(Colour::Green),
Effect::Amplify => Some(Colour::Green), Effect::Amplify => Some(Colour::Green),
Effect::Silence => Some(Colour::Blue), Effect::Silence => Some(Colour::Blue),
@ -190,7 +190,7 @@ impl Effect {
Effect::Electric => Some(Colour::Green), Effect::Electric => Some(Colour::Green),
Effect::Electrocute => Some(Colour::Blue), Effect::Electrocute => Some(Colour::Blue),
Effect::Absorbtion => Some(Colour::Green), Effect::Absorb => Some(Colour::Green),
// magic // magic
Effect::Hybrid => Some(Colour::Green), Effect::Hybrid => Some(Colour::Green),

10
server/src/game.rs
View File

@ -1197,18 +1197,18 @@ mod tests {
// let x_construct = x_player.constructs[0].clone(); // let x_construct = x_player.constructs[0].clone();
// let y_construct = y_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(); // game.construct_by_id(x_construct.id).unwrap().reduce_cooldowns();
// } // }
// // apply buff // // 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(x_player.id).unwrap();
// game.player_ready(y_player.id).unwrap(); // game.player_ready(y_player.id).unwrap();
// game = game.resolve_phase_start(); // 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 // // attack and receive debuff
// game.add_skill(y_player.id, y_construct.id, Some(x_construct.id), Skill::TestAttack).unwrap(); // 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(); // game = game.resolve_phase_start();
// info!("{:#?}", game); // 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] #[test]

465
server/src/item.rs
View File

@ -88,6 +88,9 @@ pub enum Item {
AmplifyI, AmplifyI,
AmplifyII, AmplifyII,
AmplifyIII, AmplifyIII,
AbsorbI,
AbsorbII,
AbsorbIII,
BanishI, BanishI,
BanishII, BanishII,
BanishIII, BanishIII,
@ -112,18 +115,15 @@ pub enum Item {
DecayI, DecayI,
DecayII, DecayII,
DecayIII, DecayIII,
AbsorbtionI, HexI,
AbsorbtionII, HexII,
AbsorbtionIII, HexIII,
HasteI, HasteI,
HasteII, HasteII,
HasteIII, HasteIII,
HealI, HealI,
HealII, HealII,
HealIII, HealIII,
HexI,
HexII,
HexIII,
HybridI, HybridI,
HybridII, HybridII,
HybridIII, HybridIII,
@ -295,105 +295,102 @@ impl Item {
pub fn into_skill(&self) -> Option<Skill> { pub fn into_skill(&self) -> Option<Skill> {
match self { match self {
Item::Attack => Some(Skill::Attack), Item::AbsorbI => Some(Skill::AbsorbI),
Item::AmplifyI => Some(Skill::AmplifyI), Item::AbsorbII => Some(Skill::AbsorbII),
Item::AmplifyII => Some(Skill::AmplifyII), Item::AbsorbIII => Some(Skill::AbsorbIII),
Item::AmplifyIII => Some(Skill::AmplifyIII), Item::AmplifyI => Some(Skill::AmplifyI),
Item::BanishI => Some(Skill::BanishI), Item::AmplifyII => Some(Skill::AmplifyII),
Item::BanishII => Some(Skill::BanishII), Item::AmplifyIII => Some(Skill::AmplifyIII),
Item::BanishIII => Some(Skill::BanishIII), Item::Attack => Some(Skill::Attack),
Item::BlastI => Some(Skill::BlastI), Item::BanishI => Some(Skill::BanishI),
Item::BlastII => Some(Skill::BlastII), Item::BanishII => Some(Skill::BanishII),
Item::BlastIII => Some(Skill::BlastIII), Item::BanishIII => Some(Skill::BanishIII),
Item::Block => Some(Skill::Block), Item::BashI => Some(Skill::BashI),
Item::Buff => Some(Skill::Buff), Item::BashII => Some(Skill::BashII),
Item::ChaosI => Some(Skill::ChaosI), Item::BashIII => Some(Skill::BashIII),
Item::ChaosII => Some(Skill::ChaosII), Item::BlastI => Some(Skill::BlastI),
Item::ChaosIII => Some(Skill::ChaosIII), Item::BlastII => Some(Skill::BlastII),
Item::CurseI => Some(Skill::CurseI), Item::BlastIII => Some(Skill::BlastIII),
Item::CurseII => Some(Skill::CurseII), Item::Block => Some(Skill::Block),
Item::CurseIII => Some(Skill::CurseIII), Item::Buff => Some(Skill::Buff),
Item::Debuff => Some(Skill::Debuff), Item::ChaosI => Some(Skill::ChaosI),
Item::DecayI => Some(Skill::DecayI), Item::ChaosII => Some(Skill::ChaosII),
Item::DecayII => Some(Skill::DecayII), Item::ChaosIII => Some(Skill::ChaosIII),
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::CounterI => Some(Skill::CounterI), Item::CounterI => Some(Skill::CounterI),
Item::CounterII => Some(Skill::CounterII), Item::CounterII => Some(Skill::CounterII),
Item::CounterIII => Some(Skill::CounterIII), Item::CounterIII => Some(Skill::CounterIII),
Item::PurgeI => Some(Skill::PurgeI), Item::CurseI => Some(Skill::CurseI),
Item::PurgeII => Some(Skill::PurgeII), Item::CurseII => Some(Skill::CurseII),
Item::PurgeIII => Some(Skill::PurgeIII), Item::CurseIII => Some(Skill::CurseIII),
Item::PurifyI => Some(Skill::PurifyI), Item::Debuff => Some(Skill::Debuff),
Item::PurifyII => Some(Skill::PurifyII), Item::DecayI => Some(Skill::DecayI),
Item::PurifyIII => Some(Skill::PurifyIII), Item::DecayII => Some(Skill::DecayII),
Item::RechargeI => Some(Skill::RechargeI), Item::DecayIII => Some(Skill::DecayIII),
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::ElectrifyI => Some(Skill::ElectrifyI), Item::ElectrifyI => Some(Skill::ElectrifyI),
Item::ElectrifyII => Some(Skill::ElectrifyII), Item::ElectrifyII => Some(Skill::ElectrifyII),
Item::ElectrifyIII => Some(Skill::ElectrifyIII), Item::ElectrifyIII => Some(Skill::ElectrifyIII),
Item::TriageI => Some(Skill::TriageI), Item::HasteI => Some(Skill::HasteI),
Item::TriageII => Some(Skill::TriageII), Item::HasteII => Some(Skill::HasteII),
Item::TriageIII => Some(Skill::TriageIII), Item::HasteIII => Some(Skill::HasteIII),
_ => None, 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_skill().unwrap().multiplier(),
self.into_skill().unwrap().effect()[1].get_duration()), self.into_skill().unwrap().effect()[1].get_duration()),
Item::AbsorbtionI | Item::AbsorbI |
Item::AbsorbtionII | Item::AbsorbII |
Item::AbsorbtionIII => format!( Item::AbsorbIII => format!(
"Gain Absorbtion for {:?}T. {} Absorb lasts {:?}T", "Gain Absorb for {:?}T. {} Absorption lasts {:?}T",
self.into_skill().unwrap().effect()[0].get_duration(), 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()), self.into_skill().unwrap().effect()[0].get_skill().unwrap().effect()[0].get_duration()),
Item::HasteI | Item::HasteI |
@ -856,9 +853,9 @@ impl Item {
Item::ThrowI => vec![Item::Stun, Item::Red, Item::Green], Item::ThrowI => vec![Item::Stun, Item::Red, Item::Green],
Item::ThrowII => vec![Item::ThrowI, Item::ThrowI, Item::ThrowI], Item::ThrowII => vec![Item::ThrowI, Item::ThrowI, Item::ThrowI],
Item::ThrowIII => vec![Item::ThrowII, Item::ThrowII, Item::ThrowII], Item::ThrowIII => vec![Item::ThrowII, Item::ThrowII, Item::ThrowII],
Item::HexI => vec![Item::Stun, Item::Green, Item::Blue], Item::AbsorbI => vec![Item::Stun, Item::Green, Item::Blue],
Item::HexII => vec![Item::HexI, Item::HexI, Item::HexI], Item::AbsorbII => vec![Item::AbsorbI, Item::AbsorbI, Item::AbsorbI],
Item::HexIII => vec![Item::HexII, Item::HexII, Item::HexII], Item::AbsorbIII => vec![Item::AbsorbII, Item::AbsorbII, Item::AbsorbII],
Item::BanishI => vec![Item::Stun, Item::Red, Item::Blue], Item::BanishI => vec![Item::Stun, Item::Red, Item::Blue],
Item::BanishII => vec![Item::BanishI, Item::BanishI, Item::BanishI], Item::BanishII => vec![Item::BanishI, Item::BanishI, Item::BanishI],
Item::BanishIII => vec![Item::BanishII, Item::BanishII, Item::BanishII], Item::BanishIII => vec![Item::BanishII, Item::BanishII, Item::BanishII],
@ -951,129 +948,129 @@ impl Item {
impl From<Skill> for Item { impl From<Skill> for Item {
fn from(skill: Skill) -> Item { fn from(skill: Skill) -> Item {
match skill { match skill {
Skill::AmplifyI => Item::AmplifyI, Skill::AbsorbI => Item::AbsorbI,
Skill::AmplifyII => Item::AmplifyII, Skill::AbsorbII => Item::AbsorbII,
Skill::AmplifyIII => Item::AmplifyIII, Skill::AbsorbIII => Item::AbsorbIII,
Skill::Attack => Item::Attack, Skill::AmplifyI => Item::AmplifyI,
Skill::BanishI => Item::BanishI, Skill::AmplifyII => Item::AmplifyII,
Skill::BanishII => Item::BanishII, Skill::AmplifyIII => Item::AmplifyIII,
Skill::BanishIII => Item::BanishIII, Skill::Attack => Item::Attack,
Skill::BlastI => Item::BlastI, Skill::BanishI => Item::BanishI,
Skill::BlastII => Item::BlastII, Skill::BanishII => Item::BanishII,
Skill::BlastIII => Item::BlastIII, Skill::BanishIII => Item::BanishIII,
Skill::Block => Item::Block, Skill::BashI => Item::BashI,
Skill::Buff => Item::Buff, Skill::BashII => Item::BashII,
Skill::ChaosI => Item::ChaosI, Skill::BashIII => Item::BashIII,
Skill::ChaosII => Item::ChaosII, Skill::BlastI => Item::BlastI,
Skill::ChaosIII => Item::ChaosIII, Skill::BlastII => Item::BlastII,
Skill::ElectrifyI => Item::ElectrifyI, Skill::BlastIII => Item::BlastIII,
Skill::ElectrifyII => Item::ElectrifyII, Skill::Block => Item::Block,
Skill::ElectrifyIII => Item::ElectrifyIII, Skill::Buff => Item::Buff,
Skill::SustainI => Item::SustainI, Skill::ChaosI => Item::ChaosI,
Skill::SustainII => Item::SustainII, Skill::ChaosII => Item::ChaosII,
Skill::SustainIII => Item::SustainIII, Skill::ChaosIII => Item::ChaosIII,
Skill::CurseI => Item::CurseI, Skill::CounterI => Item::CounterI,
Skill::CurseII => Item::CurseII, Skill::CounterII => Item::CounterII,
Skill::CurseIII => Item::CurseIII, Skill::CounterIII => Item::CounterIII,
Skill::DecayI => Item::DecayI, Skill::CurseI => Item::CurseI,
Skill::DecayII => Item::DecayII, Skill::CurseII => Item::CurseII,
Skill::DecayIII => Item::DecayIII, Skill::CurseIII => Item::CurseIII,
Skill::Debuff => Item::Debuff, Skill::Debuff => Item::Debuff,
Skill::HasteI => Item::HasteI, Skill::DecayI => Item::DecayI,
Skill::HasteII => Item::HasteII, Skill::DecayII => Item::DecayII,
Skill::HasteIII => Item::HasteIII, Skill::DecayIII => Item::DecayIII,
Skill::AbsorbtionI => Item::AbsorbtionI, Skill::ElectrifyI => Item::ElectrifyI,
Skill::AbsorbtionII => Item::AbsorbtionII, Skill::ElectrifyII => Item::ElectrifyII,
Skill::AbsorbtionIII => Item::AbsorbtionIII, Skill::ElectrifyIII => Item::ElectrifyIII,
Skill::HealI => Item::HealI, Skill::HasteI => Item::HasteI,
Skill::HealII => Item::HealII, Skill::HasteII => Item::HasteII,
Skill::HealIII => Item::HealIII, Skill::HasteIII => Item::HasteIII,
Skill::HexI => Item::HexI, Skill::HealI => Item::HealI,
Skill::HexII => Item::HexII, Skill::HealII => Item::HealII,
Skill::HexIII => Item::HexIII, Skill::HealIII => Item::HealIII,
Skill::HybridI => Item::HybridI, Skill::HexI => Item::HexI,
Skill::HybridII => Item::HybridII, Skill::HexII => Item::HexII,
Skill::HybridIII => Item::HybridIII, Skill::HexIII => Item::HexIII,
Skill::InvertI => Item::InvertI, Skill::HybridI => Item::HybridI,
Skill::InvertII => Item::InvertII, Skill::HybridII => Item::HybridII,
Skill::InvertIII => Item::InvertIII, Skill::HybridIII => Item::HybridIII,
Skill::CounterI => Item::CounterI, Skill::InterceptI => Item::InterceptI,
Skill::CounterII => Item::CounterII, Skill::InterceptII => Item::InterceptII,
Skill::CounterIII => Item::CounterIII, Skill::InterceptIII => Item::InterceptIII,
Skill::PurgeI => Item::PurgeI, Skill::InvertI => Item::InvertI,
Skill::PurgeII => Item::PurgeII, Skill::InvertII => Item::InvertII,
Skill::PurgeIII => Item::PurgeIII, Skill::InvertIII => Item::InvertIII,
Skill::PurifyI => Item::PurifyI, Skill::PurgeI => Item::PurgeI,
Skill::PurifyII => Item::PurifyII, Skill::PurgeII => Item::PurgeII,
Skill::PurifyIII => Item::PurifyIII, Skill::PurgeIII => Item::PurgeIII,
Skill::RechargeI => Item::RechargeI, Skill::PurifyI => Item::PurifyI,
Skill::RechargeII => Item::RechargeII, Skill::PurifyII => Item::PurifyII,
Skill::RechargeIII => Item::RechargeIII, Skill::PurifyIII => Item::PurifyIII,
Skill::ReflectI => Item::ReflectI, Skill::RechargeI => Item::RechargeI,
Skill::ReflectII => Item::ReflectII, Skill::RechargeII => Item::RechargeII,
Skill::ReflectIII => Item::ReflectIII, Skill::RechargeIII => Item::RechargeIII,
Skill::RuinI => Item::RuinI, Skill::ReflectI => Item::ReflectI,
Skill::RuinII => Item::RuinII, Skill::ReflectII => Item::ReflectII,
Skill::RuinIII => Item::RuinIII, Skill::ReflectIII => Item::ReflectIII,
Skill::ScatterI => Item::ScatterI, Skill::RestrictI => Item::RestrictI,
Skill::ScatterII => Item::ScatterII, Skill::RestrictII => Item::RestrictII,
Skill::ScatterIII => Item::ScatterIII, Skill::RestrictIII => Item::RestrictIII,
Skill::SilenceI => Item::SilenceI, Skill::RuinI => Item::RuinI,
Skill::SilenceII => Item::SilenceII, Skill::RuinII => Item::RuinII,
Skill::SilenceIII => Item::SilenceIII, Skill::RuinIII => Item::RuinIII,
Skill::SiphonI => Item::SiphonI, Skill::ScatterI => Item::ScatterI,
Skill::SiphonII => Item::SiphonII, Skill::ScatterII => Item::ScatterII,
Skill::SiphonIII => Item::SiphonIII, Skill::ScatterIII => Item::ScatterIII,
Skill::SlayI => Item::SlayI, Skill::SilenceI => Item::SilenceI,
Skill::SlayII => Item::SlayII, Skill::SilenceII => Item::SilenceII,
Skill::SlayIII => Item::SlayIII, Skill::SilenceIII => Item::SilenceIII,
Skill::SleepI => Item::SleepI, Skill::SiphonI => Item::SiphonI,
Skill::SleepII => Item::SleepII, Skill::SiphonII => Item::SiphonII,
Skill::SleepIII => Item::SleepIII, Skill::SiphonIII => Item::SiphonIII,
Skill::RestrictI => Item::RestrictI, Skill::SlayI => Item::SlayI,
Skill::RestrictII => Item::RestrictII, Skill::SlayII => Item::SlayII,
Skill::RestrictIII => Item::RestrictIII, Skill::SlayIII => Item::SlayIII,
Skill::BashI => Item::BashI, Skill::SleepI => Item::SleepI,
Skill::BashII => Item::BashII, Skill::SleepII => Item::SleepII,
Skill::BashIII => Item::BashIII, Skill::SleepIII => Item::SleepIII,
Skill::StrikeI => Item::StrikeI, Skill::StrikeI => Item::StrikeI,
Skill::StrikeII => Item::StrikeII, Skill::StrikeII => Item::StrikeII,
Skill::StrikeIII => Item::StrikeIII, Skill::StrikeIII => Item::StrikeIII,
Skill::Stun => Item::Stun, Skill::Stun => Item::Stun,
Skill::InterceptI => Item::InterceptI, Skill::SustainI => Item::SustainI,
Skill::InterceptII => Item::InterceptII, Skill::SustainII => Item::SustainII,
Skill::InterceptIII => Item::InterceptIII, Skill::SustainIII => Item::SustainIII,
Skill::ThrowI => Item::ThrowI, Skill::ThrowI => Item::ThrowI,
Skill::ThrowII => Item::ThrowII, Skill::ThrowII => Item::ThrowII,
Skill::ThrowIII => Item::ThrowIII, Skill::ThrowIII => Item::ThrowIII,
Skill::TriageI => Item::TriageI, Skill::TriageI => Item::TriageI,
Skill::TriageII => Item::TriageII, Skill::TriageII => Item::TriageII,
Skill::TriageIII => Item::TriageIII, Skill::TriageIII => Item::TriageIII,
// Convert subskills into parent skills // Convert subskills into parent skills
Skill::ElectrocuteI => Item::ElectrifyI, Skill::ElectrocuteI => Item::ElectrifyI,
Skill::ElectrocuteII => Item::ElectrifyII, Skill::ElectrocuteII => Item::ElectrifyII,
Skill::ElectrocuteIII => Item::ElectrifyIII, Skill::ElectrocuteIII => Item::ElectrifyIII,
Skill::ElectrocuteTickI => Item::ElectrifyI, Skill::ElectrocuteTickI => Item::ElectrifyI,
Skill::ElectrocuteTickII => Item::ElectrifyII, Skill::ElectrocuteTickII => Item::ElectrifyII,
Skill::ElectrocuteTickIII => Item::ElectrifyII, Skill::ElectrocuteTickIII => Item::ElectrifyII,
Skill::DecayTickI => Item::DecayI, Skill::DecayTickI => Item::DecayI,
Skill::DecayTickII => Item::DecayII, Skill::DecayTickII => Item::DecayII,
Skill::DecayTickIII => Item::DecayIII, Skill::DecayTickIII => Item::DecayIII,
Skill::AbsorbI => Item::AbsorbtionI, Skill::AbsorptionI => Item::AbsorbI,
Skill::AbsorbII => Item::AbsorbtionII, Skill::AbsorptionII => Item::AbsorbII,
Skill::AbsorbIII => Item::AbsorbtionIII, Skill::AbsorptionIII => Item::AbsorbIII,
Skill::HasteStrike => Item::HasteI, Skill::HasteStrike => Item::HasteI,
Skill::HybridBlast => Item::HybridI, Skill::HybridBlast => Item::HybridI,
Skill::CounterAttackI => Item::CounterI, Skill::CounterAttackI => Item::CounterI,
Skill::CounterAttackII => Item::CounterII, Skill::CounterAttackII => Item::CounterII,
Skill::CounterAttackIII => Item::CounterIII, Skill::CounterAttackIII => Item::CounterIII,
Skill::SiphonTickI => Item::SiphonI, Skill::SiphonTickI => Item::SiphonI,
Skill::SiphonTickII => Item::SiphonII, Skill::SiphonTickII => Item::SiphonII,
Skill::SiphonTickIII => Item::SiphonIII, Skill::SiphonTickIII => Item::SiphonIII,
Skill::TriageTickI => Item::TriageI, Skill::TriageTickI => Item::TriageI,
Skill::TriageTickII => Item::TriageII, Skill::TriageTickII => Item::TriageII,
Skill::TriageTickIII => Item::TriageIII, Skill::TriageTickIII => Item::TriageIII,
} }
} }
} }
@ -1172,9 +1169,9 @@ pub fn get_combos() -> Vec<Combo> {
Combo { components: Item::HasteI.combo(), item: Item::HasteI }, Combo { components: Item::HasteI.combo(), item: Item::HasteI },
Combo { components: Item::HasteII.combo(), item: Item::HasteII }, Combo { components: Item::HasteII.combo(), item: Item::HasteII },
Combo { components: Item::HasteIII.combo(), item: Item::HasteIII }, Combo { components: Item::HasteIII.combo(), item: Item::HasteIII },
Combo { components: Item::AbsorbtionI.combo(), item: Item::AbsorbtionI }, Combo { components: Item::AbsorbI.combo(), item: Item::AbsorbI },
Combo { components: Item::AbsorbtionII.combo(), item: Item::AbsorbtionII }, Combo { components: Item::AbsorbII.combo(), item: Item::AbsorbII },
Combo { components: Item::AbsorbtionIII.combo(), item: Item::AbsorbtionIII }, Combo { components: Item::AbsorbIII.combo(), item: Item::AbsorbIII },
Combo { components: Item::HybridI.combo(), item: Item::HybridI }, Combo { components: Item::HybridI.combo(), item: Item::HybridI },
Combo { components: Item::HybridII.combo(), item: Item::HybridII }, Combo { components: Item::HybridII.combo(), item: Item::HybridII },
Combo { components: Item::HybridIII.combo(), item: Item::HybridIII }, Combo { components: Item::HybridIII.combo(), item: Item::HybridIII },
@ -1241,9 +1238,9 @@ pub fn get_combos() -> Vec<Combo> {
Combo { components: Item::ThrowI.combo(), item: Item::ThrowI }, Combo { components: Item::ThrowI.combo(), item: Item::ThrowI },
Combo { components: Item::ThrowII.combo(), item: Item::ThrowII }, Combo { components: Item::ThrowII.combo(), item: Item::ThrowII },
Combo { components: Item::ThrowIII.combo(), item: Item::ThrowIII }, Combo { components: Item::ThrowIII.combo(), item: Item::ThrowIII },
Combo { components: Item::HexI.combo(), item: Item::HexI }, Combo { components: Item::AbsorbI.combo(), item: Item::AbsorbI },
Combo { components: Item::HexII.combo(), item: Item::HexII }, Combo { components: Item::AbsorbII.combo(), item: Item::AbsorbII },
Combo { components: Item::HexIII.combo(), item: Item::HexIII }, Combo { components: Item::AbsorbIII.combo(), item: Item::AbsorbIII },
Combo { components: Item::BanishI.combo(), item: Item::BanishI }, Combo { components: Item::BanishI.combo(), item: Item::BanishI },
Combo { components: Item::BanishII.combo(), item: Item::BanishII }, Combo { components: Item::BanishII.combo(), item: Item::BanishII },
Combo { components: Item::BanishIII.combo(), item: Item::BanishIII }, Combo { components: Item::BanishIII.combo(), item: Item::BanishIII },

58
server/src/skill.rs
View File

@ -176,9 +176,9 @@ pub fn resolve(skill: Skill, source: &mut Construct, target: &mut Construct, mut
Skill::HexII | Skill::HexII |
Skill::HexIII => hex(source, target, resolutions, skill), Skill::HexIII => hex(source, target, resolutions, skill),
Skill::AbsorbtionI | Skill::AbsorbI |
Skill::AbsorbtionII | Skill::AbsorbII |
Skill::AbsorbtionIII => absorbtion(source, target, resolutions, skill), Skill::AbsorbIII => absorbtion(source, target, resolutions, skill),
Skill::HybridI | Skill::HybridI |
Skill::HybridII | Skill::HybridII |
@ -271,9 +271,9 @@ pub fn resolve(skill: Skill, source: &mut Construct, target: &mut Construct, mut
Skill::ElectrocuteII | Skill::ElectrocuteII |
Skill::ElectrocuteIII => panic!("should only trigger from electrify hit"), Skill::ElectrocuteIII => panic!("should only trigger from electrify hit"),
Skill::HasteStrike => panic!("should only trigger from haste"), Skill::HasteStrike => panic!("should only trigger from haste"),
Skill::AbsorbI | Skill::AbsorptionI |
Skill::AbsorbII | Skill::AbsorptionII |
Skill::AbsorbIII => panic!("should only trigger from absorb"), Skill::AbsorptionIII => panic!("should only trigger from absorb"),
Skill::HybridBlast => panic!("should only trigger from hybrid"), Skill::HybridBlast => panic!("should only trigger from hybrid"),
Skill::CounterAttackI | Skill::CounterAttackI |
Skill::CounterAttackII | 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() 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 { match meta {
Some(EffectMeta::Skill(s)) => { Some(EffectMeta::Skill(s)) => {
resolutions = absorb(&mut target, &mut source, resolutions, skill, amount, s); resolutions = absorb(&mut target, &mut source, resolutions, skill, amount, s);
@ -544,12 +544,12 @@ pub enum Skill {
HexII, HexII,
HexIII, HexIII,
AbsorptionI,
AbsorptionII,
AbsorptionIII,
AbsorbI, AbsorbI,
AbsorbII, AbsorbII,
AbsorbIII, AbsorbIII,
AbsorbtionI,
AbsorbtionII,
AbsorbtionIII,
HybridBlast, HybridBlast,
HybridI, HybridI,
@ -790,16 +790,16 @@ impl Skill {
Skill::HexII => vec![ConstructEffect {effect: Effect::Hex, duration: 3, 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::HexIII => vec![ConstructEffect {effect: Effect::Hex, duration: 4, meta: None, tick: None}],
Skill::AbsorbtionI => vec![ConstructEffect {effect: Effect::Absorbtion, duration: 2, Skill::AbsorbI => vec![ConstructEffect {effect: Effect::Absorb, duration: 2,
meta: Some(EffectMeta::Skill(Skill::AbsorbI)), tick: None}], meta: Some(EffectMeta::Skill(Skill::AbsorptionI)), tick: None}],
Skill::AbsorbtionII => vec![ConstructEffect {effect: Effect::Absorbtion, duration: 3, Skill::AbsorbII => vec![ConstructEffect {effect: Effect::Absorb, duration: 3,
meta: Some(EffectMeta::Skill(Skill::AbsorbII)), tick: None}], meta: Some(EffectMeta::Skill(Skill::AbsorptionII)), tick: None}],
Skill::AbsorbtionIII => vec![ConstructEffect {effect: Effect::Absorbtion, duration: 4, Skill::AbsorbIII => vec![ConstructEffect {effect: Effect::Absorb, duration: 4,
meta: Some(EffectMeta::Skill(Skill::AbsorbIII)), tick: None}], meta: Some(EffectMeta::Skill(Skill::AbsorptionIII)), tick: None}],
Skill::AbsorbI => vec![ConstructEffect {effect: Effect::Absorb, duration: 5, meta: None, tick: None}], Skill::AbsorptionI => vec![ConstructEffect {effect: Effect::Absorption, duration: 5, meta: None, tick: None}],
Skill::AbsorbII => vec![ConstructEffect {effect: Effect::Absorb, duration: 7, meta: None, tick: None}], Skill::AbsorptionII => vec![ConstructEffect {effect: Effect::Absorption, duration: 7, meta: None, tick: None}],
Skill::AbsorbIII => vec![ConstructEffect {effect: Effect::Absorb, duration: 9, 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, Skill::HybridI => vec![ConstructEffect {effect: Effect::Hybrid, duration: 2,
meta: Some(EffectMeta::Multiplier(150)), tick: None }], meta: Some(EffectMeta::Multiplier(150)), tick: None }],
@ -1010,9 +1010,9 @@ impl Skill {
Skill::ElectrifyIII =>Some(1), Skill::ElectrifyIII =>Some(1),
Skill::AbsorbtionI | Skill::AbsorbI |
Skill::AbsorbtionII | Skill::AbsorbII |
Skill::AbsorbtionIII => Some(1), Skill::AbsorbIII => Some(1),
//----------- //-----------
// Never cast directly // Never cast directly
@ -1026,9 +1026,9 @@ impl Skill {
Skill::ElectrocuteI | Skill::ElectrocuteI |
Skill::ElectrocuteII | Skill::ElectrocuteII |
Skill::ElectrocuteIII | Skill::ElectrocuteIII |
Skill::AbsorbI | Skill::AbsorptionI |
Skill::AbsorbII | Skill::AbsorptionII |
Skill::AbsorbIII | Skill::AbsorptionIII |
// Ticks // Ticks
Skill::ElectrocuteTickI | Skill::ElectrocuteTickI |
Skill::ElectrocuteTickII | Skill::ElectrocuteTickII |
@ -1153,9 +1153,9 @@ impl Skill {
Skill::HealI | Skill::HealI |
Skill::HealII | Skill::HealII |
Skill::HealIII | Skill::HealIII |
Skill::AbsorbtionI | Skill::AbsorbI |
Skill::AbsorbtionII | Skill::AbsorbII |
Skill::AbsorbtionIII | Skill::AbsorbIII |
Skill::InvertI | Skill::InvertI |
Skill::InvertII | Skill::InvertII |
Skill::InvertIII | Skill::InvertIII |