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
Download Patch File Download Diff File Expand all files Collapse all files
server/src/construct.rs
+1 -1
View File
@@ -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;
}
}
server/src/effect.rs
+12 -12
View File
@@ -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),
server/src/game.rs
+6 -6
View File
@@ -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]
server/src/item.rs
+38 -38
View File
@@ -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<Skill> 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<Skill> 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<Skill> 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> {
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> {
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 },
server/src/skill.rs
+61 -61
View File
@@ -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"),
};