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
GR - Triage
BB - Absorbtion
BB - Absorb
RG - Sustain
GB - Amplify
RB - Haste

1
client/index.html
View File

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

2
client/package.json
View File

@ -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/",

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

@ -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',

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

@ -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 <Haste />;
case 'Triage': return <Triage />;
case 'TriageTick': return <TriageTick />;
case 'Scatter': return false;
case 'Scatter': return <Scatter player={player} />;
case 'Hybrid': return <Hybrid />;
case 'Intercept': return <Intercept player={player} />;
@ -140,7 +141,7 @@ function animations(props) {
case 'Stun': return <Stun />;
case 'Banish': return <Banish id={construct.id} />;
case 'Bash': return <Bash />;
case 'Hex': return <Hex />;
case 'Absorb': return <Absorb />;
case 'Sleep': return <Sleep />;
case 'Throw': return false;
case 'Ruin': return false;

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

@ -31,12 +31,15 @@ class Absorb extends Component {
</feMerge>
</filter>
</defs>
<g class='blue' filter='url(#absorbFilter)'>
<path d= "
M 64 4
L 64 96
"/>
</g>
<polygon
class='blue'
points="64 68.64 8.574 100 63.446 67.68 64 4 64.554 67.68 119.426 100"
filter="url(#absorbFilter)">
</polygon>
<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>
);
}
@ -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

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;
/* <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',
BLUE: '#3498db',
WHITE: '#f5f5f5', // whitesmoke
PURPLE: '#9355b5' // 6lack - that far cover
},
INFO: {

19
client/src/utils.jsx
View File

@ -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;
@ -381,18 +382,18 @@ const SERVER = process.env.NODE_ENV === 'production' ? '/api/' : 'http://localho
function postData(url = '/', data = {}) {
// 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 = {

10
server/src/effect.rs
View File

@ -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),

10
server/src/game.rs
View File

@ -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]

139
server/src/item.rs
View File

@ -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,13 +295,19 @@ impl Item {
pub fn into_skill(&self) -> Option<Skill> {
match self {
Item::Attack => Some(Skill::Attack),
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),
@ -310,6 +316,9 @@ impl Item {
Item::ChaosI => Some(Skill::ChaosI),
Item::ChaosII => Some(Skill::ChaosII),
Item::ChaosIII => Some(Skill::ChaosIII),
Item::CounterI => Some(Skill::CounterI),
Item::CounterII => Some(Skill::CounterII),
Item::CounterIII => Some(Skill::CounterIII),
Item::CurseI => Some(Skill::CurseI),
Item::CurseII => Some(Skill::CurseII),
Item::CurseIII => Some(Skill::CurseIII),
@ -317,27 +326,24 @@ impl Item {
Item::DecayI => Some(Skill::DecayI),
Item::DecayII => Some(Skill::DecayII),
Item::DecayIII => Some(Skill::DecayIII),
Item::ElectrifyI => Some(Skill::ElectrifyI),
Item::ElectrifyII => Some(Skill::ElectrifyII),
Item::ElectrifyIII => Some(Skill::ElectrifyIII),
Item::HasteI => Some(Skill::HasteI),
Item::HasteII => Some(Skill::HasteII),
Item::HasteIII => Some(Skill::HasteIII),
Item::HealI => Some(Skill::HealI),
Item::HealII => Some(Skill::HealII),
Item::HealIII => Some(Skill::HealIII),
Item::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::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::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),
@ -350,6 +356,9 @@ impl Item {
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),
@ -359,37 +368,25 @@ impl Item {
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::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::Stun => Some(Skill::Stun),
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::ElectrifyII => Some(Skill::ElectrifyII),
Item::ElectrifyIII => Some(Skill::ElectrifyIII),
Item::TriageI => Some(Skill::TriageI),
Item::TriageII => Some(Skill::TriageII),
Item::TriageIII => Some(Skill::TriageIII),
@ -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,6 +948,9 @@ impl Item {
impl From<Skill> for Item {
fn from(skill: Skill) -> Item {
match skill {
Skill::AbsorbI => Item::AbsorbI,
Skill::AbsorbII => Item::AbsorbII,
Skill::AbsorbIII => Item::AbsorbIII,
Skill::AmplifyI => Item::AmplifyI,
Skill::AmplifyII => Item::AmplifyII,
Skill::AmplifyIII => Item::AmplifyIII,
@ -958,6 +958,9 @@ impl From<Skill> for Item {
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,
@ -966,25 +969,22 @@ impl From<Skill> for Item {
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::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::Debuff => Item::Debuff,
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::AbsorbtionI => Item::AbsorbtionI,
Skill::AbsorbtionII => Item::AbsorbtionII,
Skill::AbsorbtionIII => Item::AbsorbtionIII,
Skill::HealI => Item::HealI,
Skill::HealII => Item::HealII,
Skill::HealIII => Item::HealIII,
@ -994,12 +994,12 @@ impl From<Skill> for Item {
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::CounterI => Item::CounterI,
Skill::CounterII => Item::CounterII,
Skill::CounterIII => Item::CounterIII,
Skill::PurgeI => Item::PurgeI,
Skill::PurgeII => Item::PurgeII,
Skill::PurgeIII => Item::PurgeIII,
@ -1012,6 +1012,9 @@ impl From<Skill> for Item {
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,
@ -1030,19 +1033,13 @@ impl From<Skill> for Item {
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::SustainI => Item::SustainI,
Skill::SustainII => Item::SustainII,
Skill::SustainIII => Item::SustainIII,
Skill::ThrowI => Item::ThrowI,
Skill::ThrowII => Item::ThrowII,
Skill::ThrowIII => Item::ThrowIII,
@ -1060,9 +1057,9 @@ impl From<Skill> for Item {
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::AbsorptionI => Item::AbsorbI,
Skill::AbsorptionII => Item::AbsorbII,
Skill::AbsorptionIII => Item::AbsorbIII,
Skill::HasteStrike => Item::HasteI,
Skill::HybridBlast => Item::HybridI,
Skill::CounterAttackI => Item::CounterI,
@ -1172,9 +1169,9 @@ pub fn get_combos() -> Vec<Combo> {
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> {
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 },

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::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 |