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

hatred -> absorb, clutch -> sustain

Browse Source
This commit is contained in:
ntr 2019-07-05 14:11:00 +10:00
parent 640938827d
commit 3f974cb0fa
14 changed files with 221 additions and 147 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
CHANGELOG.md
View File

@ -18,7 +18,7 @@ Added `Buff` as a skill
### Changed ### Changed
`Clutch` now grants immunity to disables. `Sustain` now grants immunity to disables.
*BALANCE* *BALANCE*
- purify - purify
@ -170,8 +170,8 @@ New skill `Hybrid`
Debuff duration increased 2T -> 3T Debuff duration increased 2T -> 3T
Switch clutch with intercept Switch sustain with intercept
Clutch now GR + Block (was GR + Buff) Sustain now GR + Block (was GR + Buff)
Intercept now GR + Buff Intercept now GR + Buff
No longer self-target only No longer self-target only

4
COMBOS.md
View File

@ -80,8 +80,8 @@ RB - Hex
RR - Empower RR - Empower
GR - Triage GR - Triage
BB - Hostility BB - Absorbtion
RG - Clutch RG - Sustain
GB - Amplify GB - Amplify
RB - Haste RB - Haste

2
WORKLOG.md
View File

@ -69,7 +69,7 @@
mobile info page mobile info page
rework scatter rework scatter
hatred maybe absorb maybe
reconnect based on time delta reconnect based on time delta

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

@ -79,7 +79,7 @@ const SKILLS = [
'BashI', 'BashI',
'BlastI', 'BlastI',
'ChaosI', 'ChaosI',
'ClutchI', 'SustainI',
'CounterAttackI', 'CounterAttackI',
'CounterI', 'CounterI',
'CurseI', 'CurseI',
@ -90,10 +90,10 @@ const SKILLS = [
'ElectrocuteTickI', 'ElectrocuteTickI',
'HasteI', 'HasteI',
'HasteStrike', 'HasteStrike',
'HatredI', 'AbsorbI',
'HealI', 'HealI',
'HexI', 'HexI',
'HostilityI', 'AbsorbtionI',
'HybridBlast', 'HybridBlast',
'HybridI', 'HybridI',
'InterceptI', 'InterceptI',

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

@ -10,7 +10,7 @@ const Blast = require('./anims/blast');
const Block = require('./anims/block'); const Block = require('./anims/block');
const Buff = require('./anims/buff'); const Buff = require('./anims/buff');
const Chaos = require('./anims/chaos'); const Chaos = require('./anims/chaos');
const Clutch = require('./anims/clutch'); const Sustain = require('./anims/sustain');
const Counter = require('./anims/counter'); const Counter = require('./anims/counter');
const Curse = require('./anims/curse'); const Curse = require('./anims/curse');
const Debuff = require('./anims/debuff'); const Debuff = require('./anims/debuff');
@ -147,7 +147,7 @@ function animations(props) {
// Block Base // Block Base
case 'Block': return <Block />; case 'Block': return <Block />;
case 'Clutch': return <Clutch team={player} />; case 'Sustain': return <Sustain team={player} />;
case 'Electrify': return <Electrify />; case 'Electrify': return <Electrify />;
case 'Electrocute': return <Electrocute />; case 'Electrocute': return <Electrocute />;
case 'ElectrocuteTick': return <Electrocute />; case 'ElectrocuteTick': return <Electrocute />;

74
client/src/components/anims/absorb.jsx Normal file
View File

@ -0,0 +1,74 @@
const preact = require('preact');
const { Component } = require('preact');
const anime = require('animejs').default;
const { TIMES } = require('../../constants');
// shamelessly lifted from teh anime docs
// https://animejs.com/documentation/#svgAttr
class Absorb extends Component {
constructor() {
super();
this.animations = [];
}
render() {
return (
<svg
class='skill-animation blue'
version="1.1"
id="absorb"
xmlns="http://www.w3.org/2000/svg"
viewBox="0 0 128 128">
<defs>
<filter id="absorbFilter">
<feGaussianBlur in="SourceGraphic" stdDeviation="5" />
<feMerge>
<feMergeNode />
<feMergeNode in="SourceGraphic" />
</feMerge>
</filter>
</defs>
<g class='blue' filter='url(#absorbFilter)'>
<path d= "
M 64 4
L 64 96
"/>
</g>
</svg>
);
}
componentDidMount() {
this.animations.push(anime({
targets: ['#absorb'],
opacity: [
{ value: 1, delay: TIMES.TARGET_DELAY_MS, duration: TIMES.TARGET_DURATION_MS * 0.2 },
{ value: 0, delay: TIMES.TARGET_DURATION_MS * 0.6, duration: TIMES.TARGET_DURATION_MS * 0.2 },
],
easing: 'easeInOutSine',
}));
anime({
targets: ['#absorb path'],
strokeDashoffset: [anime.setDashoffset, 0],
duration: 2000,
easing: 'linear',
loop: true,
});
}
// 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 = Absorb;

24
client/src/components/anims/clutch.jsx
View File

@ -4,7 +4,7 @@ const anime = require('animejs').default;
const { TIMES, COLOURS } = require('../../constants'); const { TIMES, COLOURS } = require('../../constants');
class Clutch extends Component { class Sustain extends Component {
constructor() { constructor() {
super(); super();
this.animations = []; this.animations = [];
@ -15,28 +15,28 @@ class Clutch extends Component {
<svg <svg
class='skill-animation green' class='skill-animation green'
version="1.1" version="1.1"
id="clutch" id="sustain"
xmlns="http://www.w3.org/2000/svg" xmlns="http://www.w3.org/2000/svg"
style={{ transform: team ? 'rotate3d(1, 0, 0, 180deg)' : '' }} style={{ transform: team ? 'rotate3d(1, 0, 0, 180deg)' : '' }}
viewBox="0 0 300 300"> viewBox="0 0 300 300">
<filter id='clutchFilter'> <filter id='sustainFilter'>
<feTurbulence type="turbulence" baseFrequency="0" numOctaves="1" result="turbulence"></feTurbulence> <feTurbulence type="turbulence" baseFrequency="0" numOctaves="1" result="turbulence"></feTurbulence>
<feDisplacementMap in2="turbulence" in="SourceGraphic" scale="1" xChannelSelector="R" yChannelSelector="G"></feDisplacementMap> <feDisplacementMap in2="turbulence" in="SourceGraphic" scale="1" xChannelSelector="R" yChannelSelector="G"></feDisplacementMap>
</filter> </filter>
<polyline <polyline
id="stageOne" id="stageOne"
points='0 0' points='0 0'
style={{ filter: 'url("#clutchFilter")' }} style={{ filter: 'url("#sustainFilter")' }}
/> />
<polyline <polyline
id="stageTwo" id="stageTwo"
points='0 0' points='0 0'
style={{ filter: 'url("#clutchFilter")' }} style={{ filter: 'url("#sustainFilter")' }}
/> />
<polyline <polyline
id="stageThree" id="stageThree"
points='0 0' points='0 0'
style={{ filter: 'url("#clutchFilter")' }} style={{ filter: 'url("#sustainFilter")' }}
/> />
</svg> </svg>
); );
@ -44,7 +44,7 @@ class Clutch extends Component {
componentDidMount() { componentDidMount() {
this.animations.push(anime({ this.animations.push(anime({
targets: ['#clutch'], targets: ['#sustain'],
opacity: [ opacity: [
{ value: 1, delay: TIMES.TARGET_DELAY_MS, duration: TIMES.TARGET_DURATION_MS * 0.2 }, { value: 1, delay: TIMES.TARGET_DELAY_MS, duration: TIMES.TARGET_DURATION_MS * 0.2 },
{ value: 0, delay: TIMES.TARGET_DURATION_MS * 0.8, duration: TIMES.TARGET_DURATION_MS * 0.2 }, { value: 0, delay: TIMES.TARGET_DURATION_MS * 0.8, duration: TIMES.TARGET_DURATION_MS * 0.2 },
@ -101,7 +101,7 @@ class Clutch extends Component {
})); }));
this.animations.push(anime({ this.animations.push(anime({
targets: ['#clutchFilter feTurbulence', '#clutchFilter feDisplacementMap'], targets: ['#sustainFilter feTurbulence', '#sustainFilter feDisplacementMap'],
baseFrequency: 2, baseFrequency: 2,
scale: 10, scale: 10,
numOctaves: 5, numOctaves: 5,
@ -122,19 +122,19 @@ class Clutch extends Component {
} }
} }
module.exports = Clutch; module.exports = Sustain;
/* <polyline /* <polyline
points='128,168 80,240 176,240 128,168' points='128,168 80,240 176,240 128,168'
style={{ filter: 'url("#clutchFilter")' }} style={{ filter: 'url("#sustainFilter")' }}
/> />
<polyline <polyline
points='176,240 212,216 128,96 44,216 80,240' points='176,240 212,216 128,96 44,216 80,240'
style={{ filter: 'url("#clutchFilter")' }} style={{ filter: 'url("#sustainFilter")' }}
/> />
<polyline <polyline
points='212,216 248,192 128,24 8,192 44,216' points='212,216 248,192 128,24 8,192 44,216'
style={{ filter: 'url("#clutchFilter")' }} style={{ filter: 'url("#sustainFilter")' }}
/> />
*/ */

10
client/src/test.instance.js
View File

@ -93,7 +93,7 @@ function testInstance(uuid) {
"cd": null "cd": null
}, },
{ {
"skill": "Clutch", "skill": "Sustain",
"self_targeting": true, "self_targeting": true,
"cd": 2 "cd": 2
}, },
@ -1334,7 +1334,7 @@ function testInstance(uuid) {
"cd": 1 "cd": 1
}, },
{ {
"skill": "Clutch", "skill": "Sustain",
"self_targeting": true, "self_targeting": true,
"cd": 2 "cd": 2
} }
@ -2201,7 +2201,7 @@ function testInstance(uuid) {
"cd": 2 "cd": 2
}, },
{ {
"skill": "Clutch", "skill": "Sustain",
"self_targeting": true, "self_targeting": true,
"cd": 2 "cd": 2
} }
@ -3441,7 +3441,7 @@ function testInstance(uuid) {
"cd": 2 "cd": 2
}, },
{ {
"skill": "Clutch", "skill": "Sustain",
"self_targeting": true, "self_targeting": true,
"cd": 2 "cd": 2
} }
@ -4132,7 +4132,7 @@ function testInstance(uuid) {
"cd": null "cd": null
}, },
{ {
"skill": "Clutch", "skill": "Sustain",
"self_targeting": true, "self_targeting": true,
"cd": 2 "cd": 2
} }

2
client/src/utils.jsx
View File

@ -362,7 +362,7 @@ const removeTier = skill => {
if (skill.includes('Purify')) return 'Purify'; if (skill.includes('Purify')) return 'Purify';
if (skill.includes('Electrify')) return 'Electrify'; if (skill.includes('Electrify')) return 'Electrify';
if (skill.includes('Electrocute')) return 'Electrocute'; if (skill.includes('Electrocute')) return 'Electrocute';
if (skill.includes('Clutch')) return 'Clutch'; if (skill.includes('Sustain')) return 'Sustain';
if (skill.includes('Reflect')) return 'Reflect'; if (skill.includes('Reflect')) return 'Reflect';
if (skill.includes('Recharge')) return 'Recharge'; if (skill.includes('Recharge')) return 'Recharge';

2
server/src/construct.rs
View File

@ -511,7 +511,7 @@ impl Construct {
fn reduce_green_life(&mut self, amount: u64) { fn reduce_green_life(&mut self, amount: u64) {
self.green_life.reduce(amount); self.green_life.reduce(amount);
if self.affected(Effect::Clutch) && self.green_life() == 0 { if self.affected(Effect::Sustain) && self.green_life() == 0 {
self.green_life.value = 1; self.green_life.value = 1;
} }
} }

24
server/src/effect.rs
View File

@ -10,7 +10,7 @@ pub enum Effect {
Banish, Banish,
Block, Block,
Buff, Buff,
Clutch, Sustain,
Curse, Curse,
Haste, Haste,
Hex, Hex,
@ -32,10 +32,10 @@ pub enum Effect {
Electric, Electric,
Electrocute, Electrocute,
// hostility is the buff // absorbtion is the buff
// hatred is the increased damage // absorb is the increased damage
Hostility, Absorbtion,
Hatred, Absorb,
// magic immunity // magic immunity
Scatter, Scatter,
@ -72,7 +72,7 @@ impl Effect {
_ => skill.colours().contains(&Colour::Red) _ => skill.colours().contains(&Colour::Red)
}, },
Effect::Banish => true, Effect::Banish => true,
Effect::Clutch => [ Effect::Sustain => [
Skill::Stun, Skill::Stun,
Skill::HexI, Skill::HexI,
Skill::HexII, Skill::HexII,
@ -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::Hatred => vec![Stat::RedPower, Stat::BluePower], Effect::Absorb => 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,9 +148,9 @@ impl Effect {
Effect::Scatter => value >> 1, Effect::Scatter => value >> 1,
Effect::Hatred => value + match meta { Effect::Absorb => value + match meta {
Some(EffectMeta::AddedDamage(d)) => d, Some(EffectMeta::AddedDamage(d)) => d,
_ => panic!("hatred meta not damage"), _ => panic!("absorb meta not damage"),
}, },
_ => { _ => {
@ -169,7 +169,7 @@ impl Effect {
Effect::Counter => Some(Colour::Green), Effect::Counter => Some(Colour::Green),
Effect::Vulnerable => Some(Colour::Red), Effect::Vulnerable => Some(Colour::Red),
Effect::Restrict => Some(Colour::Red), Effect::Restrict => Some(Colour::Red),
Effect::Clutch => Some(Colour::Green), Effect::Sustain => Some(Colour::Green),
Effect::Intercept => Some(Colour::Green), Effect::Intercept => Some(Colour::Green),
// magic // magic
@ -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::Hatred => Some(Colour::Green), Effect::Absorb => 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::Hostility => Some(Colour::Green), Effect::Absorbtion => Some(Colour::Green),
// magic // magic
Effect::Hybrid => Some(Colour::Green), Effect::Hybrid => Some(Colour::Green),

12
server/src/game.rs
View File

@ -1188,7 +1188,7 @@ mod tests {
} }
// #[test] // #[test]
// fn hatred_test() { // fn absorb_test() {
// let mut game = create_test_game(); // let mut game = create_test_game();
// let x_player = game.players[0].clone(); // let x_player = game.players[0].clone();
@ -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::Hostility); // game.construct_by_id(x_construct.id).unwrap().learn_mut(Skill::Absorbtion);
// while game.construct_by_id(x_construct.id).unwrap().skill_on_cd(Skill::Hostility).is_some() { // while game.construct_by_id(x_construct.id).unwrap().skill_on_cd(Skill::Absorbtion).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::Hostility).unwrap(); // game.add_skill(x_player.id, x_construct.id, Some(x_construct.id), Skill::Absorbtion).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::Hostility)); // assert!(game.construct_by_id(x_construct.id).unwrap().affected(Effect::Absorbtion));
// // 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::Hatred)); // assert!(game.construct_by_id(y_construct.id).unwrap().affected(Effect::Absorb));
// } // }
#[test] #[test]

76
server/src/item.rs
View File

@ -100,9 +100,9 @@ pub enum Item {
ChaosI, ChaosI,
ChaosII, ChaosII,
ChaosIII, ChaosIII,
ClutchI, SustainI,
ClutchII, SustainII,
ClutchIII, SustainIII,
ElectrifyI, ElectrifyI,
ElectrifyII, ElectrifyII,
ElectrifyIII, ElectrifyIII,
@ -112,9 +112,9 @@ pub enum Item {
DecayI, DecayI,
DecayII, DecayII,
DecayIII, DecayIII,
HostilityI, AbsorbtionI,
HostilityII, AbsorbtionII,
HostilityIII, AbsorbtionIII,
HasteI, HasteI,
HasteII, HasteII,
HasteIII, HasteIII,
@ -326,9 +326,9 @@ impl Item {
Item::HexI => Some(Skill::HexI), Item::HexI => Some(Skill::HexI),
Item::HexII => Some(Skill::HexII), Item::HexII => Some(Skill::HexII),
Item::HexIII => Some(Skill::HexIII), Item::HexIII => Some(Skill::HexIII),
Item::HostilityI => Some(Skill::HostilityI), Item::AbsorbtionI => Some(Skill::AbsorbtionI),
Item::HostilityII => Some(Skill::HostilityII), Item::AbsorbtionII => Some(Skill::AbsorbtionII),
Item::HostilityIII=> Some(Skill::HostilityIII), Item::AbsorbtionIII=> Some(Skill::AbsorbtionIII),
Item::HybridI => Some(Skill::HybridI), Item::HybridI => Some(Skill::HybridI),
Item::HybridII => Some(Skill::HybridII), Item::HybridII => Some(Skill::HybridII),
Item::HybridIII => Some(Skill::HybridIII), Item::HybridIII => Some(Skill::HybridIII),
@ -378,9 +378,9 @@ impl Item {
Item::StrikeI => Some(Skill::StrikeI), Item::StrikeI => Some(Skill::StrikeI),
Item::StrikeII => Some(Skill::StrikeII), Item::StrikeII => Some(Skill::StrikeII),
Item::StrikeIII => Some(Skill::StrikeIII), Item::StrikeIII => Some(Skill::StrikeIII),
Item::ClutchI => Some(Skill::ClutchI), Item::SustainI => Some(Skill::SustainI),
Item::ClutchII => Some(Skill::ClutchII), Item::SustainII => Some(Skill::SustainII),
Item::ClutchIII => Some(Skill::ClutchIII), Item::SustainIII => Some(Skill::SustainIII),
Item::InterceptI => Some(Skill::InterceptI), Item::InterceptI => Some(Skill::InterceptI),
Item::InterceptII => Some(Skill::InterceptII), Item::InterceptII => Some(Skill::InterceptII),
Item::InterceptIII => Some(Skill::InterceptIII), Item::InterceptIII => Some(Skill::InterceptIII),
@ -595,9 +595,9 @@ impl Item {
"Hits twice for red and blue damage. Damage {:?}% red and blue power. Randomly deals 0 to 30% more damage", "Hits twice for red and blue damage. Damage {:?}% red and blue power. Randomly deals 0 to 30% more damage",
self.into_skill().unwrap().multiplier()), self.into_skill().unwrap().multiplier()),
Item::ClutchI | Item::SustainI |
Item::ClutchII | Item::SustainII |
Item::ClutchIII => format!("Construct cannot be KO'd while active. Additionally provides immunity to disables. \ Item::SustainIII => format!("Construct cannot be KO'd while active. Additionally provides immunity to disables. \
Lasts {:?}T", Lasts {:?}T",
self.into_skill().unwrap().effect()[0].get_duration()), self.into_skill().unwrap().effect()[0].get_duration()),
@ -626,12 +626,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::HostilityI | Item::AbsorbtionI |
Item::HostilityII | Item::AbsorbtionII |
Item::HostilityIII => format!( Item::AbsorbtionIII => format!(
"Gain Hostility for {:?}T. {} Hatred lasts {:?}T", "Gain Absorbtion for {:?}T. {} Absorb lasts {:?}T",
self.into_skill().unwrap().effect()[0].get_duration(), self.into_skill().unwrap().effect()[0].get_duration(),
"When attacked by Hostility you gain Hatred which increased red and blue power based on Damage taken.", "When attacked by Absorbtion you gain Absorb 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 |
@ -834,9 +834,9 @@ impl Item {
Item::ElectrifyI => vec![Item::Block, Item::Blue, Item::Blue], Item::ElectrifyI => vec![Item::Block, Item::Blue, Item::Blue],
Item::ElectrifyII => vec![Item::ElectrifyI, Item::ElectrifyI, Item::ElectrifyI], Item::ElectrifyII => vec![Item::ElectrifyI, Item::ElectrifyI, Item::ElectrifyI],
Item::ElectrifyIII => vec![Item::ElectrifyII, Item::ElectrifyII, Item::ElectrifyII], Item::ElectrifyIII => vec![Item::ElectrifyII, Item::ElectrifyII, Item::ElectrifyII],
Item::ClutchI => vec![Item::Block, Item::Red, Item::Green], Item::SustainI => vec![Item::Block, Item::Red, Item::Green],
Item::ClutchII => vec![Item::ClutchI, Item::ClutchI, Item::ClutchI], Item::SustainII => vec![Item::SustainI, Item::SustainI, Item::SustainI],
Item::ClutchIII => vec![Item::ClutchII, Item::ClutchII, Item::ClutchII], Item::SustainIII => vec![Item::SustainII, Item::SustainII, Item::SustainII],
Item::ReflectI => vec![Item::Block, Item::Green, Item::Blue], Item::ReflectI => vec![Item::Block, Item::Green, Item::Blue],
Item::ReflectII => vec![Item::ReflectI, Item::ReflectI, Item::ReflectI], Item::ReflectII => vec![Item::ReflectI, Item::ReflectI, Item::ReflectI],
Item::ReflectIII => vec![Item::ReflectII, Item::ReflectII, Item::ReflectII], Item::ReflectIII => vec![Item::ReflectII, Item::ReflectII, Item::ReflectII],
@ -969,9 +969,9 @@ impl From<Skill> for Item {
Skill::ElectrifyI => Item::ElectrifyI, Skill::ElectrifyI => Item::ElectrifyI,
Skill::ElectrifyII => Item::ElectrifyII, Skill::ElectrifyII => Item::ElectrifyII,
Skill::ElectrifyIII => Item::ElectrifyIII, Skill::ElectrifyIII => Item::ElectrifyIII,
Skill::ClutchI => Item::ClutchI, Skill::SustainI => Item::SustainI,
Skill::ClutchII => Item::ClutchII, Skill::SustainII => Item::SustainII,
Skill::ClutchIII => Item::ClutchIII, Skill::SustainIII => Item::SustainIII,
Skill::CurseI => Item::CurseI, Skill::CurseI => Item::CurseI,
Skill::CurseII => Item::CurseII, Skill::CurseII => Item::CurseII,
Skill::CurseIII => Item::CurseIII, Skill::CurseIII => Item::CurseIII,
@ -982,9 +982,9 @@ impl From<Skill> for Item {
Skill::HasteI => Item::HasteI, Skill::HasteI => Item::HasteI,
Skill::HasteII => Item::HasteII, Skill::HasteII => Item::HasteII,
Skill::HasteIII => Item::HasteIII, Skill::HasteIII => Item::HasteIII,
Skill::HostilityI => Item::HostilityI, Skill::AbsorbtionI => Item::AbsorbtionI,
Skill::HostilityII => Item::HostilityII, Skill::AbsorbtionII => Item::AbsorbtionII,
Skill::HostilityIII => Item::HostilityIII, Skill::AbsorbtionIII => Item::AbsorbtionIII,
Skill::HealI => Item::HealI, Skill::HealI => Item::HealI,
Skill::HealII => Item::HealII, Skill::HealII => Item::HealII,
Skill::HealIII => Item::HealIII, Skill::HealIII => Item::HealIII,
@ -1060,9 +1060,9 @@ impl From<Skill> for Item {
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::HatredI => Item::HostilityI, Skill::AbsorbI => Item::AbsorbtionI,
Skill::HatredII => Item::HostilityII, Skill::AbsorbII => Item::AbsorbtionII,
Skill::HatredIII => Item::HostilityIII, Skill::AbsorbIII => Item::AbsorbtionIII,
Skill::HasteStrike => Item::HasteI, Skill::HasteStrike => Item::HasteI,
Skill::HybridBlast => Item::HybridI, Skill::HybridBlast => Item::HybridI,
Skill::CounterAttackI => Item::CounterI, Skill::CounterAttackI => Item::CounterI,
@ -1172,9 +1172,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::HostilityI.combo(), item: Item::HostilityI }, Combo { components: Item::AbsorbtionI.combo(), item: Item::AbsorbtionI },
Combo { components: Item::HostilityII.combo(), item: Item::HostilityII }, Combo { components: Item::AbsorbtionII.combo(), item: Item::AbsorbtionII },
Combo { components: Item::HostilityIII.combo(), item: Item::HostilityIII }, Combo { components: Item::AbsorbtionIII.combo(), item: Item::AbsorbtionIII },
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 },
@ -1216,9 +1216,9 @@ pub fn get_combos() -> Vec<Combo> {
Combo { components: Item::ElectrifyII.combo(), item: Item::ElectrifyII }, Combo { components: Item::ElectrifyII.combo(), item: Item::ElectrifyII },
Combo { components: Item::ElectrifyIII.combo(), item: Item::ElectrifyIII }, Combo { components: Item::ElectrifyIII.combo(), item: Item::ElectrifyIII },
Combo { components: Item::ClutchI.combo(), item: Item::ClutchI }, Combo { components: Item::SustainI.combo(), item: Item::SustainI },
Combo { components: Item::ClutchII.combo(), item: Item::ClutchII }, Combo { components: Item::SustainII.combo(), item: Item::SustainII },
Combo { components: Item::ClutchIII.combo(), item: Item::ClutchIII }, Combo { components: Item::SustainIII.combo(), item: Item::SustainIII },
Combo { components: Item::ReflectI.combo(), item: Item::ReflectI }, Combo { components: Item::ReflectI.combo(), item: Item::ReflectI },
Combo { components: Item::ReflectII.combo(), item: Item::ReflectII }, Combo { components: Item::ReflectII.combo(), item: Item::ReflectII },
Combo { components: Item::ReflectIII.combo(), item: Item::ReflectIII }, Combo { components: Item::ReflectIII.combo(), item: Item::ReflectIII },

122
server/src/skill.rs
View File

@ -142,9 +142,9 @@ pub fn resolve(skill: Skill, source: &mut Construct, target: &mut Construct, mut
Skill::ChaosII | Skill::ChaosII |
Skill::ChaosIII => chaos(source, target, resolutions, skill), Skill::ChaosIII => chaos(source, target, resolutions, skill),
Skill::ClutchI | Skill::SustainI |
Skill::ClutchII | Skill::SustainII |
Skill::ClutchIII => clutch(source, target, resolutions, skill), Skill::SustainIII => sustain(source, target, resolutions, skill),
Skill::ElectrifyI | Skill::ElectrifyI |
Skill::ElectrifyII | Skill::ElectrifyII |
@ -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::HostilityI | Skill::AbsorbtionI |
Skill::HostilityII | Skill::AbsorbtionII |
Skill::HostilityIII => hostility(source, target, resolutions, skill), Skill::AbsorbtionIII => 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::HatredI | Skill::AbsorbI |
Skill::HatredII | Skill::AbsorbII |
Skill::HatredIII => panic!("should only trigger from hatred"), Skill::AbsorbIII => 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,14 +304,14 @@ fn post_resolve(_skill: Skill, game: &mut Game, mut resolutions: Resolutions) ->
}; };
} }
if target.affected(Effect::Hostility) { if target.affected(Effect::Absorbtion) {
let ConstructEffect { effect: _, duration: _, meta, tick: _ } = target.effects.iter() let ConstructEffect { effect: _, duration: _, meta, tick: _ } = target.effects.iter()
.find(|e| e.effect == Effect::Hostility).unwrap().clone(); .find(|e| e.effect == Effect::Absorbtion).unwrap().clone();
match meta { match meta {
Some(EffectMeta::Skill(s)) => { Some(EffectMeta::Skill(s)) => {
resolutions = hatred(&mut target, &mut source, resolutions, skill, amount, s); resolutions = absorb(&mut target, &mut source, resolutions, skill, amount, s);
}, },
_ => panic!("no hatred skill"), _ => panic!("no absorb skill"),
}; };
} }
@ -506,9 +506,9 @@ pub enum Skill {
ChaosII, ChaosII,
ChaosIII, ChaosIII,
ClutchI, SustainI,
ClutchII, SustainII,
ClutchIII, SustainIII,
ElectrifyI, ElectrifyI,
ElectrifyII, ElectrifyII,
@ -544,12 +544,12 @@ pub enum Skill {
HexII, HexII,
HexIII, HexIII,
HatredI, AbsorbI,
HatredII, AbsorbII,
HatredIII, AbsorbIII,
HostilityI, AbsorbtionI,
HostilityII, AbsorbtionII,
HostilityIII, AbsorbtionIII,
HybridBlast, HybridBlast,
HybridI, HybridI,
@ -756,9 +756,9 @@ impl Skill {
Skill::ElectrocuteIII => vec![ConstructEffect {effect: Effect::Electrocute, duration: 5, Skill::ElectrocuteIII => vec![ConstructEffect {effect: Effect::Electrocute, duration: 5,
meta: Some(EffectMeta::Skill(Skill::ElectrocuteTickIII)), tick: None}], meta: Some(EffectMeta::Skill(Skill::ElectrocuteTickIII)), tick: None}],
Skill::ClutchI => vec![ConstructEffect {effect: Effect::Clutch, duration: 1, meta: None, tick: None }], Skill::SustainI => vec![ConstructEffect {effect: Effect::Sustain, duration: 1, meta: None, tick: None }],
Skill::ClutchII => vec![ConstructEffect {effect: Effect::Clutch, duration: 2, meta: None, tick: None }], Skill::SustainII => vec![ConstructEffect {effect: Effect::Sustain, duration: 2, meta: None, tick: None }],
Skill::ClutchIII => vec![ConstructEffect {effect: Effect::Clutch, duration: 3, meta: None, tick: None }], Skill::SustainIII => vec![ConstructEffect {effect: Effect::Sustain, duration: 3, meta: None, tick: None }],
Skill::CurseI => vec![ConstructEffect {effect: Effect::Curse, duration: 2, Skill::CurseI => vec![ConstructEffect {effect: Effect::Curse, duration: 2,
meta: Some(EffectMeta::Multiplier(150)), tick: None}], meta: Some(EffectMeta::Multiplier(150)), tick: None}],
@ -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::HostilityI => vec![ConstructEffect {effect: Effect::Hostility, duration: 2, Skill::AbsorbtionI => vec![ConstructEffect {effect: Effect::Absorbtion, duration: 2,
meta: Some(EffectMeta::Skill(Skill::HatredI)), tick: None}], meta: Some(EffectMeta::Skill(Skill::AbsorbI)), tick: None}],
Skill::HostilityII => vec![ConstructEffect {effect: Effect::Hostility, duration: 3, Skill::AbsorbtionII => vec![ConstructEffect {effect: Effect::Absorbtion, duration: 3,
meta: Some(EffectMeta::Skill(Skill::HatredII)), tick: None}], meta: Some(EffectMeta::Skill(Skill::AbsorbII)), tick: None}],
Skill::HostilityIII => vec![ConstructEffect {effect: Effect::Hostility, duration: 4, Skill::AbsorbtionIII => vec![ConstructEffect {effect: Effect::Absorbtion, duration: 4,
meta: Some(EffectMeta::Skill(Skill::HatredIII)), tick: None}], meta: Some(EffectMeta::Skill(Skill::AbsorbIII)), tick: None}],
Skill::HatredI => vec![ConstructEffect {effect: Effect::Hatred, duration: 5, meta: None, tick: None}], Skill::AbsorbI => vec![ConstructEffect {effect: Effect::Absorb, duration: 5, meta: None, tick: None}],
Skill::HatredII => vec![ConstructEffect {effect: Effect::Hatred, duration: 7, meta: None, tick: None}], Skill::AbsorbII => vec![ConstructEffect {effect: Effect::Absorb, duration: 7, meta: None, tick: None}],
Skill::HatredIII => vec![ConstructEffect {effect: Effect::Hatred, duration: 9, meta: None, tick: None}], Skill::AbsorbIII => vec![ConstructEffect {effect: Effect::Absorb, 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 }],
@ -997,9 +997,9 @@ impl Skill {
Skill::SleepII => Some(3), Skill::SleepII => Some(3),
Skill::SleepIII => Some(3), Skill::SleepIII => Some(3),
Skill::ClutchI => Some(1), Skill::SustainI => Some(1),
Skill::ClutchII => Some(2), Skill::SustainII => Some(2),
Skill::ClutchIII => Some(3), Skill::SustainIII => Some(3),
Skill::InterceptI => Some(2), Skill::InterceptI => Some(2),
Skill::InterceptII => Some(2), Skill::InterceptII => Some(2),
@ -1010,9 +1010,9 @@ impl Skill {
Skill::ElectrifyIII =>Some(1), Skill::ElectrifyIII =>Some(1),
Skill::HostilityI | Skill::AbsorbtionI |
Skill::HostilityII | Skill::AbsorbtionII |
Skill::HostilityIII => Some(1), Skill::AbsorbtionIII => 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::HatredI | Skill::AbsorbI |
Skill::HatredII | Skill::AbsorbII |
Skill::HatredIII | Skill::AbsorbIII |
// Ticks // Ticks
Skill::ElectrocuteTickI | Skill::ElectrocuteTickI |
Skill::ElectrocuteTickII | Skill::ElectrocuteTickII |
@ -1122,9 +1122,9 @@ impl Skill {
pub fn self_targeting(&self) -> bool { pub fn self_targeting(&self) -> bool {
match self { match self {
Skill::Block | Skill::Block |
Skill::ClutchI | Skill::SustainI |
Skill::ClutchII | Skill::SustainII |
Skill::ClutchIII | Skill::SustainIII |
Skill::CounterI | Skill::CounterI |
Skill::CounterII | Skill::CounterII |
Skill::CounterIII => true, Skill::CounterIII => true,
@ -1141,9 +1141,9 @@ impl Skill {
Skill::AmplifyII | Skill::AmplifyII |
Skill::AmplifyIII | Skill::AmplifyIII |
Skill::Block | Skill::Block |
Skill::ClutchI | Skill::SustainI |
Skill::ClutchII | Skill::SustainII |
Skill::ClutchIII | Skill::SustainIII |
Skill::ElectrifyI | Skill::ElectrifyI |
Skill::ElectrifyII | Skill::ElectrifyII |
Skill::ElectrifyIII | Skill::ElectrifyIII |
@ -1153,9 +1153,9 @@ impl Skill {
Skill::HealI | Skill::HealI |
Skill::HealII | Skill::HealII |
Skill::HealIII | Skill::HealIII |
Skill::HostilityI | Skill::AbsorbtionI |
Skill::HostilityII | Skill::AbsorbtionII |
Skill::HostilityIII | Skill::AbsorbtionIII |
Skill::InvertI | Skill::InvertI |
Skill::InvertII | Skill::InvertII |
Skill::InvertIII | Skill::InvertIII |
@ -1281,7 +1281,7 @@ fn sleep(source: &mut Construct, target: &mut Construct, mut results: Resolution
return results; return results;
} }
fn clutch(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions { fn sustain(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions {
skill.effect().into_iter() skill.effect().into_iter()
.for_each(|e| (results.push(Resolution::new(source, target).event(target.add_effect(skill, e))))); .for_each(|e| (results.push(Resolution::new(source, target).event(target.add_effect(skill, e)))));
return results; return results;
@ -1514,15 +1514,15 @@ fn hex(source: &mut Construct, target: &mut Construct, mut results: Resolutions,
return results;; return results;;
} }
fn hostility(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions { fn absorbtion(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions {
results.push(Resolution::new(source, target).event(target.add_effect(skill, skill.effect()[0]))); results.push(Resolution::new(source, target).event(target.add_effect(skill, skill.effect()[0])));
return results;; return results;;
} }
fn hatred(source: &mut Construct, target: &mut Construct, mut results: Resolutions, reflect_skill: Skill, amount: u64, skill: Skill) -> Resolutions { fn absorb(source: &mut Construct, target: &mut Construct, mut results: Resolutions, reflect_skill: Skill, amount: u64, skill: Skill) -> Resolutions {
let hatred = skill.effect()[0].set_meta(EffectMeta::AddedDamage(amount)); let absorb = skill.effect()[0].set_meta(EffectMeta::AddedDamage(amount));
results.push(Resolution::new(source, target) results.push(Resolution::new(source, target)
.event(target.add_effect(reflect_skill, hatred)) .event(target.add_effect(reflect_skill, absorb))
.stages(LogStages::PostOnly)); .stages(LogStages::PostOnly));
return results;; return results;;
} }
@ -1769,7 +1769,7 @@ mod tests {
} }
#[test] #[test]
fn clutch_test() { fn sustain_test() {
let mut x = Construct::new() let mut x = Construct::new()
.named(&"muji".to_string()); .named(&"muji".to_string());
@ -1778,13 +1778,13 @@ mod tests {
x.red_power.force(10000000000000); // multiplication of int max will cause overflow x.red_power.force(10000000000000); // multiplication of int max will cause overflow
clutch(&mut y.clone(), &mut y, vec![], Skill::ClutchI); sustain(&mut y.clone(), &mut y, vec![], Skill::SustainI);
assert!(y.affected(Effect::Clutch)); assert!(y.affected(Effect::Sustain));
let mut results = hex(&mut x, &mut y, vec![], Skill::HexI); let mut results = hex(&mut x, &mut y, vec![], Skill::HexI);
let Resolution { source: _, target: _, event, stages: _ } = results.remove(0); let Resolution { source: _, target: _, event, stages: _ } = results.remove(0);
match event { match event {
Event::Immunity { skill: _, immunity } => assert!(immunity.contains(&Effect::Clutch)), Event::Immunity { skill: _, immunity } => assert!(immunity.contains(&Effect::Sustain)),
_ => panic!("not immune cluthc"), _ => panic!("not immune cluthc"),
}; };