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

21
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;
@ -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 = {

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]

465
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,105 +295,102 @@ impl Item {
pub fn into_skill(&self) -> Option<Skill> {
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<Skill> 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> {
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 |