diff --git a/CHANGELOG.md b/CHANGELOG.md
index d90c5863..0f026d90 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -18,7 +18,7 @@ Added `Buff` as a skill
### Changed
-`Clutch` now grants immunity to disables.
+`Sustain` now grants immunity to disables.
*BALANCE*
- purify
@@ -170,8 +170,8 @@ New skill `Hybrid`
Debuff duration increased 2T -> 3T
- Switch clutch with intercept
- Clutch now GR + Block (was GR + Buff)
+ Switch sustain with intercept
+ Sustain now GR + Block (was GR + Buff)
Intercept now GR + Buff
No longer self-target only
diff --git a/COMBOS.md b/COMBOS.md
index 9f6cb7b1..3b2ec596 100644
--- a/COMBOS.md
+++ b/COMBOS.md
@@ -80,8 +80,8 @@ RB - Hex
RR - Empower
GR - Triage
-BB - Hostility
-RG - Clutch
+BB - Absorbtion
+RG - Sustain
GB - Amplify
RB - Haste
diff --git a/WORKLOG.md b/WORKLOG.md
index 2cb61c55..6bb67000 100644
--- a/WORKLOG.md
+++ b/WORKLOG.md
@@ -69,7 +69,7 @@
mobile info page
rework scatter
-hatred maybe
+absorb maybe
reconnect based on time delta
diff --git a/client/src/animations.test.jsx b/client/src/animations.test.jsx
index cfbcb45c..467fa351 100644
--- a/client/src/animations.test.jsx
+++ b/client/src/animations.test.jsx
@@ -79,7 +79,7 @@ const SKILLS = [
'BashI',
'BlastI',
'ChaosI',
- 'ClutchI',
+ 'SustainI',
'CounterAttackI',
'CounterI',
'CurseI',
@@ -90,10 +90,10 @@ const SKILLS = [
'ElectrocuteTickI',
'HasteI',
'HasteStrike',
- 'HatredI',
+ 'AbsorbI',
'HealI',
'HexI',
- 'HostilityI',
+ 'AbsorbtionI',
'HybridBlast',
'HybridI',
'InterceptI',
diff --git a/client/src/components/animations.jsx b/client/src/components/animations.jsx
index 3cf3b2c7..de1096a6 100644
--- a/client/src/components/animations.jsx
+++ b/client/src/components/animations.jsx
@@ -10,7 +10,7 @@ const Blast = require('./anims/blast');
const Block = require('./anims/block');
const Buff = require('./anims/buff');
const Chaos = require('./anims/chaos');
-const Clutch = require('./anims/clutch');
+const Sustain = require('./anims/sustain');
const Counter = require('./anims/counter');
const Curse = require('./anims/curse');
const Debuff = require('./anims/debuff');
@@ -147,7 +147,7 @@ function animations(props) {
// Block Base
case 'Block': return ;
- case 'Clutch': return ;
+ case 'Sustain': return ;
case 'Electrify': return ;
case 'Electrocute': return ;
case 'ElectrocuteTick': return ;
diff --git a/client/src/components/anims/absorb.jsx b/client/src/components/anims/absorb.jsx
new file mode 100644
index 00000000..4b9eec13
--- /dev/null
+++ b/client/src/components/anims/absorb.jsx
@@ -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 (
+
+ );
+ }
+
+ 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;
diff --git a/client/src/components/anims/clutch.jsx b/client/src/components/anims/clutch.jsx
index c23a3947..035f282e 100644
--- a/client/src/components/anims/clutch.jsx
+++ b/client/src/components/anims/clutch.jsx
@@ -4,7 +4,7 @@ const anime = require('animejs').default;
const { TIMES, COLOURS } = require('../../constants');
-class Clutch extends Component {
+class Sustain extends Component {
constructor() {
super();
this.animations = [];
@@ -15,28 +15,28 @@ class Clutch extends Component {
);
@@ -44,7 +44,7 @@ class Clutch extends Component {
componentDidMount() {
this.animations.push(anime({
- targets: ['#clutch'],
+ targets: ['#sustain'],
opacity: [
{ 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 },
@@ -101,7 +101,7 @@ class Clutch extends Component {
}));
this.animations.push(anime({
- targets: ['#clutchFilter feTurbulence', '#clutchFilter feDisplacementMap'],
+ targets: ['#sustainFilter feTurbulence', '#sustainFilter feDisplacementMap'],
baseFrequency: 2,
scale: 10,
numOctaves: 5,
@@ -122,19 +122,19 @@ class Clutch extends Component {
}
}
-module.exports = Clutch;
+module.exports = Sustain;
/*
*/
\ No newline at end of file
diff --git a/client/src/test.instance.js b/client/src/test.instance.js
index 1eab66ea..fd7a9a24 100644
--- a/client/src/test.instance.js
+++ b/client/src/test.instance.js
@@ -93,7 +93,7 @@ function testInstance(uuid) {
"cd": null
},
{
- "skill": "Clutch",
+ "skill": "Sustain",
"self_targeting": true,
"cd": 2
},
@@ -1334,7 +1334,7 @@ function testInstance(uuid) {
"cd": 1
},
{
- "skill": "Clutch",
+ "skill": "Sustain",
"self_targeting": true,
"cd": 2
}
@@ -2201,7 +2201,7 @@ function testInstance(uuid) {
"cd": 2
},
{
- "skill": "Clutch",
+ "skill": "Sustain",
"self_targeting": true,
"cd": 2
}
@@ -3441,7 +3441,7 @@ function testInstance(uuid) {
"cd": 2
},
{
- "skill": "Clutch",
+ "skill": "Sustain",
"self_targeting": true,
"cd": 2
}
@@ -4132,7 +4132,7 @@ function testInstance(uuid) {
"cd": null
},
{
- "skill": "Clutch",
+ "skill": "Sustain",
"self_targeting": true,
"cd": 2
}
diff --git a/client/src/utils.jsx b/client/src/utils.jsx
index 69014022..02234713 100644
--- a/client/src/utils.jsx
+++ b/client/src/utils.jsx
@@ -362,7 +362,7 @@ const removeTier = skill => {
if (skill.includes('Purify')) return 'Purify';
if (skill.includes('Electrify')) return 'Electrify';
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('Recharge')) return 'Recharge';
diff --git a/server/src/construct.rs b/server/src/construct.rs
index d7c7dbf3..51cfe733 100644
--- a/server/src/construct.rs
+++ b/server/src/construct.rs
@@ -511,7 +511,7 @@ impl Construct {
fn reduce_green_life(&mut self, amount: u64) {
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;
}
}
diff --git a/server/src/effect.rs b/server/src/effect.rs
index 17147274..36b92390 100644
--- a/server/src/effect.rs
+++ b/server/src/effect.rs
@@ -10,7 +10,7 @@ pub enum Effect {
Banish,
Block,
Buff,
- Clutch,
+ Sustain,
Curse,
Haste,
Hex,
@@ -32,10 +32,10 @@ pub enum Effect {
Electric,
Electrocute,
- // hostility is the buff
- // hatred is the increased damage
- Hostility,
- Hatred,
+ // absorbtion is the buff
+ // absorb is the increased damage
+ Absorbtion,
+ Absorb,
// magic immunity
Scatter,
@@ -72,7 +72,7 @@ impl Effect {
_ => skill.colours().contains(&Colour::Red)
},
Effect::Banish => true,
- Effect::Clutch => [
+ Effect::Sustain => [
Skill::Stun,
Skill::HexI,
Skill::HexII,
@@ -114,7 +114,7 @@ impl Effect {
Effect::Block => vec![Stat::RedDamageTaken],
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::Curse => vec![Stat::BlueDamageTaken],
@@ -148,9 +148,9 @@ impl Effect {
Effect::Scatter => value >> 1,
- Effect::Hatred => value + match meta {
+ Effect::Absorb => value + match meta {
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::Vulnerable => Some(Colour::Red),
Effect::Restrict => Some(Colour::Red),
- Effect::Clutch => Some(Colour::Green),
+ Effect::Sustain => Some(Colour::Green),
Effect::Intercept => Some(Colour::Green),
// magic
@@ -180,7 +180,7 @@ impl Effect {
Effect::Slow => Some(Colour::Blue),
Effect::Haste => Some(Colour::Green),
- Effect::Hatred => Some(Colour::Green),
+ Effect::Absorb => 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::Hostility => Some(Colour::Green),
+ Effect::Absorbtion => Some(Colour::Green),
// magic
Effect::Hybrid => Some(Colour::Green),
diff --git a/server/src/game.rs b/server/src/game.rs
index 786a60a7..329a685e 100644
--- a/server/src/game.rs
+++ b/server/src/game.rs
@@ -1188,7 +1188,7 @@ mod tests {
}
// #[test]
- // fn hatred_test() {
+ // fn absorb_test() {
// let mut game = create_test_game();
// let x_player = game.players[0].clone();
@@ -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::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();
// }
// // 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(y_player.id).unwrap();
// 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
// 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::Hatred));
+ // assert!(game.construct_by_id(y_construct.id).unwrap().affected(Effect::Absorb));
// }
#[test]
diff --git a/server/src/item.rs b/server/src/item.rs
index 9e48a508..ee59ecce 100644
--- a/server/src/item.rs
+++ b/server/src/item.rs
@@ -100,9 +100,9 @@ pub enum Item {
ChaosI,
ChaosII,
ChaosIII,
- ClutchI,
- ClutchII,
- ClutchIII,
+ SustainI,
+ SustainII,
+ SustainIII,
ElectrifyI,
ElectrifyII,
ElectrifyIII,
@@ -112,9 +112,9 @@ pub enum Item {
DecayI,
DecayII,
DecayIII,
- HostilityI,
- HostilityII,
- HostilityIII,
+ AbsorbtionI,
+ AbsorbtionII,
+ AbsorbtionIII,
HasteI,
HasteII,
HasteIII,
@@ -326,9 +326,9 @@ impl Item {
Item::HexI => Some(Skill::HexI),
Item::HexII => Some(Skill::HexII),
Item::HexIII => Some(Skill::HexIII),
- Item::HostilityI => Some(Skill::HostilityI),
- Item::HostilityII => Some(Skill::HostilityII),
- Item::HostilityIII=> Some(Skill::HostilityIII),
+ 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),
@@ -378,9 +378,9 @@ impl Item {
Item::StrikeI => Some(Skill::StrikeI),
Item::StrikeII => Some(Skill::StrikeII),
Item::StrikeIII => Some(Skill::StrikeIII),
- Item::ClutchI => Some(Skill::ClutchI),
- Item::ClutchII => Some(Skill::ClutchII),
- Item::ClutchIII => Some(Skill::ClutchIII),
+ 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),
@@ -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",
self.into_skill().unwrap().multiplier()),
- Item::ClutchI |
- Item::ClutchII |
- Item::ClutchIII => format!("Construct cannot be KO'd while active. Additionally provides immunity to disables. \
+ Item::SustainI |
+ Item::SustainII |
+ Item::SustainIII => format!("Construct cannot be KO'd while active. Additionally provides immunity to disables. \
Lasts {:?}T",
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_duration()),
- Item::HostilityI |
- Item::HostilityII |
- Item::HostilityIII => format!(
- "Gain Hostility for {:?}T. {} Hatred lasts {:?}T",
+ Item::AbsorbtionI |
+ Item::AbsorbtionII |
+ Item::AbsorbtionIII => format!(
+ "Gain Absorbtion for {:?}T. {} Absorb lasts {:?}T",
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()),
Item::HasteI |
@@ -834,9 +834,9 @@ impl Item {
Item::ElectrifyI => vec![Item::Block, Item::Blue, Item::Blue],
Item::ElectrifyII => vec![Item::ElectrifyI, Item::ElectrifyI, Item::ElectrifyI],
Item::ElectrifyIII => vec![Item::ElectrifyII, Item::ElectrifyII, Item::ElectrifyII],
- Item::ClutchI => vec![Item::Block, Item::Red, Item::Green],
- Item::ClutchII => vec![Item::ClutchI, Item::ClutchI, Item::ClutchI],
- Item::ClutchIII => vec![Item::ClutchII, Item::ClutchII, Item::ClutchII],
+ Item::SustainI => vec![Item::Block, Item::Red, Item::Green],
+ Item::SustainII => vec![Item::SustainI, Item::SustainI, Item::SustainI],
+ Item::SustainIII => vec![Item::SustainII, Item::SustainII, Item::SustainII],
Item::ReflectI => vec![Item::Block, Item::Green, Item::Blue],
Item::ReflectII => vec![Item::ReflectI, Item::ReflectI, Item::ReflectI],
Item::ReflectIII => vec![Item::ReflectII, Item::ReflectII, Item::ReflectII],
@@ -969,9 +969,9 @@ impl From for Item {
Skill::ElectrifyI => Item::ElectrifyI,
Skill::ElectrifyII => Item::ElectrifyII,
Skill::ElectrifyIII => Item::ElectrifyIII,
- Skill::ClutchI => Item::ClutchI,
- Skill::ClutchII => Item::ClutchII,
- Skill::ClutchIII => Item::ClutchIII,
+ Skill::SustainI => Item::SustainI,
+ Skill::SustainII => Item::SustainII,
+ Skill::SustainIII => Item::SustainIII,
Skill::CurseI => Item::CurseI,
Skill::CurseII => Item::CurseII,
Skill::CurseIII => Item::CurseIII,
@@ -982,9 +982,9 @@ impl From for Item {
Skill::HasteI => Item::HasteI,
Skill::HasteII => Item::HasteII,
Skill::HasteIII => Item::HasteIII,
- Skill::HostilityI => Item::HostilityI,
- Skill::HostilityII => Item::HostilityII,
- Skill::HostilityIII => Item::HostilityIII,
+ Skill::AbsorbtionI => Item::AbsorbtionI,
+ Skill::AbsorbtionII => Item::AbsorbtionII,
+ Skill::AbsorbtionIII => Item::AbsorbtionIII,
Skill::HealI => Item::HealI,
Skill::HealII => Item::HealII,
Skill::HealIII => Item::HealIII,
@@ -1060,9 +1060,9 @@ impl From for Item {
Skill::DecayTickI => Item::DecayI,
Skill::DecayTickII => Item::DecayII,
Skill::DecayTickIII => Item::DecayIII,
- Skill::HatredI => Item::HostilityI,
- Skill::HatredII => Item::HostilityII,
- Skill::HatredIII => Item::HostilityIII,
+ Skill::AbsorbI => Item::AbsorbtionI,
+ Skill::AbsorbII => Item::AbsorbtionII,
+ Skill::AbsorbIII => Item::AbsorbtionIII,
Skill::HasteStrike => Item::HasteI,
Skill::HybridBlast => Item::HybridI,
Skill::CounterAttackI => Item::CounterI,
@@ -1172,9 +1172,9 @@ pub fn get_combos() -> Vec {
Combo { components: Item::HasteI.combo(), item: Item::HasteI },
Combo { components: Item::HasteII.combo(), item: Item::HasteII },
Combo { components: Item::HasteIII.combo(), item: Item::HasteIII },
- Combo { components: Item::HostilityI.combo(), item: Item::HostilityI },
- Combo { components: Item::HostilityII.combo(), item: Item::HostilityII },
- Combo { components: Item::HostilityIII.combo(), item: Item::HostilityIII },
+ 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::HybridI.combo(), item: Item::HybridI },
Combo { components: Item::HybridII.combo(), item: Item::HybridII },
Combo { components: Item::HybridIII.combo(), item: Item::HybridIII },
@@ -1216,9 +1216,9 @@ pub fn get_combos() -> Vec {
Combo { components: Item::ElectrifyII.combo(), item: Item::ElectrifyII },
Combo { components: Item::ElectrifyIII.combo(), item: Item::ElectrifyIII },
- Combo { components: Item::ClutchI.combo(), item: Item::ClutchI },
- Combo { components: Item::ClutchII.combo(), item: Item::ClutchII },
- Combo { components: Item::ClutchIII.combo(), item: Item::ClutchIII },
+ Combo { components: Item::SustainI.combo(), item: Item::SustainI },
+ Combo { components: Item::SustainII.combo(), item: Item::SustainII },
+ Combo { components: Item::SustainIII.combo(), item: Item::SustainIII },
Combo { components: Item::ReflectI.combo(), item: Item::ReflectI },
Combo { components: Item::ReflectII.combo(), item: Item::ReflectII },
Combo { components: Item::ReflectIII.combo(), item: Item::ReflectIII },
diff --git a/server/src/skill.rs b/server/src/skill.rs
index 69c015e9..97477a6b 100644
--- a/server/src/skill.rs
+++ b/server/src/skill.rs
@@ -142,9 +142,9 @@ pub fn resolve(skill: Skill, source: &mut Construct, target: &mut Construct, mut
Skill::ChaosII |
Skill::ChaosIII => chaos(source, target, resolutions, skill),
- Skill::ClutchI |
- Skill::ClutchII |
- Skill::ClutchIII => clutch(source, target, resolutions, skill),
+ Skill::SustainI |
+ Skill::SustainII |
+ Skill::SustainIII => sustain(source, target, resolutions, skill),
Skill::ElectrifyI |
Skill::ElectrifyII |
@@ -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::HostilityI |
- Skill::HostilityII |
- Skill::HostilityIII => hostility(source, target, resolutions, skill),
+ Skill::AbsorbtionI |
+ Skill::AbsorbtionII |
+ Skill::AbsorbtionIII => 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::HatredI |
- Skill::HatredII |
- Skill::HatredIII => panic!("should only trigger from hatred"),
+ Skill::AbsorbI |
+ Skill::AbsorbII |
+ Skill::AbsorbIII => panic!("should only trigger from absorb"),
Skill::HybridBlast => panic!("should only trigger from hybrid"),
Skill::CounterAttackI |
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()
- .find(|e| e.effect == Effect::Hostility).unwrap().clone();
+ .find(|e| e.effect == Effect::Absorbtion).unwrap().clone();
match meta {
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,
ChaosIII,
- ClutchI,
- ClutchII,
- ClutchIII,
+ SustainI,
+ SustainII,
+ SustainIII,
ElectrifyI,
ElectrifyII,
@@ -544,12 +544,12 @@ pub enum Skill {
HexII,
HexIII,
- HatredI,
- HatredII,
- HatredIII,
- HostilityI,
- HostilityII,
- HostilityIII,
+ AbsorbI,
+ AbsorbII,
+ AbsorbIII,
+ AbsorbtionI,
+ AbsorbtionII,
+ AbsorbtionIII,
HybridBlast,
HybridI,
@@ -756,9 +756,9 @@ impl Skill {
Skill::ElectrocuteIII => vec![ConstructEffect {effect: Effect::Electrocute, duration: 5,
meta: Some(EffectMeta::Skill(Skill::ElectrocuteTickIII)), tick: None}],
- Skill::ClutchI => vec![ConstructEffect {effect: Effect::Clutch, duration: 1, meta: None, tick: None }],
- Skill::ClutchII => vec![ConstructEffect {effect: Effect::Clutch, duration: 2, meta: None, tick: None }],
- Skill::ClutchIII => vec![ConstructEffect {effect: Effect::Clutch, duration: 3, meta: None, tick: None }],
+ Skill::SustainI => vec![ConstructEffect {effect: Effect::Sustain, duration: 1, meta: None, tick: None }],
+ Skill::SustainII => vec![ConstructEffect {effect: Effect::Sustain, duration: 2, 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,
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::HexIII => vec![ConstructEffect {effect: Effect::Hex, duration: 4, meta: None, tick: None}],
- Skill::HostilityI => vec![ConstructEffect {effect: Effect::Hostility, duration: 2,
- meta: Some(EffectMeta::Skill(Skill::HatredI)), tick: None}],
- Skill::HostilityII => vec![ConstructEffect {effect: Effect::Hostility, duration: 3,
- meta: Some(EffectMeta::Skill(Skill::HatredII)), tick: None}],
- Skill::HostilityIII => vec![ConstructEffect {effect: Effect::Hostility, duration: 4,
- meta: Some(EffectMeta::Skill(Skill::HatredIII)), 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::HatredI => vec![ConstructEffect {effect: Effect::Hatred, duration: 5, meta: None, tick: None}],
- Skill::HatredII => vec![ConstructEffect {effect: Effect::Hatred, duration: 7, meta: None, tick: None}],
- Skill::HatredIII => vec![ConstructEffect {effect: Effect::Hatred, duration: 9, meta: None, 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::HybridI => vec![ConstructEffect {effect: Effect::Hybrid, duration: 2,
meta: Some(EffectMeta::Multiplier(150)), tick: None }],
@@ -997,9 +997,9 @@ impl Skill {
Skill::SleepII => Some(3),
Skill::SleepIII => Some(3),
- Skill::ClutchI => Some(1),
- Skill::ClutchII => Some(2),
- Skill::ClutchIII => Some(3),
+ Skill::SustainI => Some(1),
+ Skill::SustainII => Some(2),
+ Skill::SustainIII => Some(3),
Skill::InterceptI => Some(2),
Skill::InterceptII => Some(2),
@@ -1010,9 +1010,9 @@ impl Skill {
Skill::ElectrifyIII =>Some(1),
- Skill::HostilityI |
- Skill::HostilityII |
- Skill::HostilityIII => Some(1),
+ Skill::AbsorbtionI |
+ Skill::AbsorbtionII |
+ Skill::AbsorbtionIII => Some(1),
//-----------
// Never cast directly
@@ -1026,9 +1026,9 @@ impl Skill {
Skill::ElectrocuteI |
Skill::ElectrocuteII |
Skill::ElectrocuteIII |
- Skill::HatredI |
- Skill::HatredII |
- Skill::HatredIII |
+ Skill::AbsorbI |
+ Skill::AbsorbII |
+ Skill::AbsorbIII |
// Ticks
Skill::ElectrocuteTickI |
Skill::ElectrocuteTickII |
@@ -1122,9 +1122,9 @@ impl Skill {
pub fn self_targeting(&self) -> bool {
match self {
Skill::Block |
- Skill::ClutchI |
- Skill::ClutchII |
- Skill::ClutchIII |
+ Skill::SustainI |
+ Skill::SustainII |
+ Skill::SustainIII |
Skill::CounterI |
Skill::CounterII |
Skill::CounterIII => true,
@@ -1141,9 +1141,9 @@ impl Skill {
Skill::AmplifyII |
Skill::AmplifyIII |
Skill::Block |
- Skill::ClutchI |
- Skill::ClutchII |
- Skill::ClutchIII |
+ Skill::SustainI |
+ Skill::SustainII |
+ Skill::SustainIII |
Skill::ElectrifyI |
Skill::ElectrifyII |
Skill::ElectrifyIII |
@@ -1153,9 +1153,9 @@ impl Skill {
Skill::HealI |
Skill::HealII |
Skill::HealIII |
- Skill::HostilityI |
- Skill::HostilityII |
- Skill::HostilityIII |
+ Skill::AbsorbtionI |
+ Skill::AbsorbtionII |
+ Skill::AbsorbtionIII |
Skill::InvertI |
Skill::InvertII |
Skill::InvertIII |
@@ -1281,7 +1281,7 @@ fn sleep(source: &mut Construct, target: &mut Construct, mut results: Resolution
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()
.for_each(|e| (results.push(Resolution::new(source, target).event(target.add_effect(skill, e)))));
return results;
@@ -1514,15 +1514,15 @@ fn hex(source: &mut Construct, target: &mut Construct, mut results: Resolutions,
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])));
return results;;
}
-fn hatred(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));
+fn absorb(source: &mut Construct, target: &mut Construct, mut results: Resolutions, reflect_skill: Skill, amount: u64, skill: Skill) -> Resolutions {
+ let absorb = skill.effect()[0].set_meta(EffectMeta::AddedDamage(amount));
results.push(Resolution::new(source, target)
- .event(target.add_effect(reflect_skill, hatred))
+ .event(target.add_effect(reflect_skill, absorb))
.stages(LogStages::PostOnly));
return results;;
}
@@ -1769,7 +1769,7 @@ mod tests {
}
#[test]
- fn clutch_test() {
+ fn sustain_test() {
let mut x = Construct::new()
.named(&"muji".to_string());
@@ -1778,13 +1778,13 @@ mod tests {
x.red_power.force(10000000000000); // multiplication of int max will cause overflow
- clutch(&mut y.clone(), &mut y, vec![], Skill::ClutchI);
- assert!(y.affected(Effect::Clutch));
+ sustain(&mut y.clone(), &mut y, vec![], Skill::SustainI);
+ assert!(y.affected(Effect::Sustain));
let mut results = hex(&mut x, &mut y, vec![], Skill::HexI);
let Resolution { source: _, target: _, event, stages: _ } = results.remove(0);
match event {
- Event::Immunity { skill: _, immunity } => assert!(immunity.contains(&Effect::Clutch)),
+ Event::Immunity { skill: _, immunity } => assert!(immunity.contains(&Effect::Sustain)),
_ => panic!("not immune cluthc"),
};