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

more tier 2/3 wip

Browse Source
This commit is contained in:
Mashy 2019-05-25 18:53:10 +10:00
parent 2da21ca5bc
commit 6bbf8d0e34
3 changed files with 386 additions and 178 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
server/src/game.rs
View File

@ -1211,14 +1211,14 @@ mod tests {
let x_cryp = x_player.cryps[0].clone(); let x_cryp = x_player.cryps[0].clone();
let y_cryp = y_player.cryps[0].clone(); let y_cryp = y_player.cryps[0].clone();
game.cryp_by_id(x_cryp.id).unwrap().learn_mut(Skill::Scatter); game.cryp_by_id(x_cryp.id).unwrap().learn_mut(Skill::ScatterI);
while game.cryp_by_id(x_cryp.id).unwrap().skill_on_cd(Skill::Scatter).is_some() { while game.cryp_by_id(x_cryp.id).unwrap().skill_on_cd(Skill::ScatterI).is_some() {
game.cryp_by_id(x_cryp.id).unwrap().reduce_cooldowns(); game.cryp_by_id(x_cryp.id).unwrap().reduce_cooldowns();
} }
// apply buff // apply buff
game.add_skill(x_player.id, x_cryp.id, Some(y_cryp.id), Skill::Scatter).unwrap(); game.add_skill(x_player.id, x_cryp.id, Some(y_cryp.id), Skill::ScatterI).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();
@ -1296,15 +1296,15 @@ mod tests {
let x_cryp = x_player.cryps[0].clone(); let x_cryp = x_player.cryps[0].clone();
let y_cryp = x_player.cryps[1].clone(); let y_cryp = x_player.cryps[1].clone();
game.cryp_by_id(x_cryp.id).unwrap().learn_mut(Skill::Ruin); game.cryp_by_id(x_cryp.id).unwrap().learn_mut(Skill::RuinI);
while game.cryp_by_id(x_cryp.id).unwrap().skill_on_cd(Skill::Ruin).is_some() { while game.cryp_by_id(x_cryp.id).unwrap().skill_on_cd(Skill::RuinI).is_some() {
game.cryp_by_id(x_cryp.id).unwrap().reduce_cooldowns(); game.cryp_by_id(x_cryp.id).unwrap().reduce_cooldowns();
} }
game.add_skill(i_player.id, i_cryp.id, Some(x_cryp.id), Skill::TestTouch).unwrap(); game.add_skill(i_player.id, i_cryp.id, Some(x_cryp.id), Skill::TestTouch).unwrap();
game.add_skill(i_player.id, j_cryp.id, Some(x_cryp.id), Skill::TestTouch).unwrap(); game.add_skill(i_player.id, j_cryp.id, Some(x_cryp.id), Skill::TestTouch).unwrap();
game.add_skill(x_player.id, x_cryp.id, Some(i_cryp.id), Skill::Ruin).unwrap(); game.add_skill(x_player.id, x_cryp.id, Some(i_cryp.id), Skill::RuinI).unwrap();
game.add_skill(x_player.id, y_cryp.id, Some(i_cryp.id), Skill::TestTouch).unwrap(); game.add_skill(x_player.id, y_cryp.id, Some(i_cryp.id), Skill::TestTouch).unwrap();
game.player_ready(i_player.id).unwrap(); game.player_ready(i_player.id).unwrap();
@ -1442,8 +1442,8 @@ mod tests {
game.cryp_by_id(x_cryp.id).unwrap().reduce_cooldowns(); game.cryp_by_id(x_cryp.id).unwrap().reduce_cooldowns();
} }
game.cryp_by_id(y_cryp.id).unwrap().learn_mut(Skill::Purify); game.cryp_by_id(y_cryp.id).unwrap().learn_mut(Skill::PurifyI);
while game.cryp_by_id(y_cryp.id).unwrap().skill_on_cd(Skill::Purify).is_some() { while game.cryp_by_id(y_cryp.id).unwrap().skill_on_cd(Skill::PurifyI).is_some() {
game.cryp_by_id(y_cryp.id).unwrap().reduce_cooldowns(); game.cryp_by_id(y_cryp.id).unwrap().reduce_cooldowns();
} }
@ -1463,7 +1463,7 @@ mod tests {
game.resolved.clear(); game.resolved.clear();
// remove // remove
game.add_skill(y_player.id, y_cryp.id, Some(y_cryp.id), Skill::Purify).unwrap(); game.add_skill(y_player.id, y_cryp.id, Some(y_cryp.id), Skill::PurifyI).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();
@ -1483,7 +1483,7 @@ mod tests {
game.resolved.clear(); game.resolved.clear();
game.add_skill(y_player.id, y_cryp.id, Some(y_cryp.id), Skill::Purify).unwrap(); game.add_skill(y_player.id, y_cryp.id, Some(y_cryp.id), Skill::PurifyI).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();

202
server/src/item.rs
View File

@ -1,4 +1,4 @@
use skill::{Skill, Effect, Colour}; use skill::{Skill, Colour};
use spec::{Spec}; use spec::{Spec};
use cryp::{Colours}; use cryp::{Colours};
@ -73,15 +73,31 @@ pub enum Item {
HexII, HexII,
HexIII, HexIII,
Impurity, Impurity,
Invert, InvertI,
InvertII,
InvertIII,
Parry, Parry,
Purge, PurgeI,
Purify, PurgeII,
Reflect, PurgeIII,
Recharge, PurifyI,
Ruin, PurifyII,
Scatter, PurifyIII,
Silence, ReflectI,
ReflectII,
ReflectIII,
RechargeI,
RechargeII,
RechargeIII,
RuinI,
RuinII,
RuinIII,
ScatterI,
ScatterII,
ScatterIII,
SilenceI,
SilenceII,
SilenceIII,
Slay, Slay,
Sleep, Sleep,
Snare, Snare,
@ -223,15 +239,31 @@ impl Item {
Item::HexIII => Some(Skill::HexIII), Item::HexIII => Some(Skill::HexIII),
Item::Hostility => Some(Skill::Hostility), Item::Hostility => Some(Skill::Hostility),
Item::Impurity => Some(Skill::Impurity), Item::Impurity => Some(Skill::Impurity),
Item::Invert => Some(Skill::Invert), Item::InvertI => Some(Skill::InvertI),
Item::InvertII => Some(Skill::InvertII),
Item::InvertIII => Some(Skill::InvertIII),
Item::Parry => Some(Skill::Parry), Item::Parry => Some(Skill::Parry),
Item::Purge => Some(Skill::Purge), Item::PurgeI => Some(Skill::PurgeI),
Item::Purify => Some(Skill::Purify), Item::PurgeII => Some(Skill::PurgeII),
Item::Recharge => Some(Skill::Recharge), Item::PurgeIII => Some(Skill::PurgeIII),
Item::Reflect => Some(Skill::Reflect), Item::PurifyI => Some(Skill::PurifyI),
Item::Ruin => Some(Skill::Ruin), Item::PurifyII => Some(Skill::PurifyII),
Item::Scatter => Some(Skill::Scatter), Item::PurifyIII => Some(Skill::PurifyIII),
Item::Silence => Some(Skill::Silence), 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::Slay => Some(Skill::Slay), Item::Slay => Some(Skill::Slay),
Item::Sleep => Some(Skill::Sleep), Item::Sleep => Some(Skill::Sleep),
Item::Siphon => Some(Skill::Siphon), Item::Siphon => Some(Skill::Siphon),
@ -423,7 +455,9 @@ impl Item {
"% Green Power as Blue Damage", "% Green Power as Blue Damage",
self.into_skill().unwrap().effect().first().unwrap().get_duration()), self.into_skill().unwrap().effect().first().unwrap().get_duration()),
Item::Invert => format!( Item::InvertI |
Item::InvertII |
Item::InvertIII => format!(
"Reverse healing into damage and damage into healing. "Reverse healing into damage and damage into healing.
Any excess red or blue damage is converted into shield recharge."), Any excess red or blue damage is converted into shield recharge."),
@ -434,28 +468,42 @@ impl Item {
"If a red skill is parried the cryp will riposte the source dealing red damage", "If a red skill is parried the cryp will riposte the source dealing red damage",
Skill::Riposte.multiplier()), Skill::Riposte.multiplier()),
Item::Purge => format!("Remove buffs from target cryp"), Item::PurgeI |
Item::PurgeII |
Item::PurgeIII => format!("Remove buffs from target cryp"),
Item::Purify => format!( Item::PurifyI |
Item::PurifyII |
Item::PurifyIII => format!(
"Remove debuffs and heals for {:?}% green power per debuff removed.", "Remove debuffs and heals for {:?}% green power per debuff removed.",
self.into_skill().unwrap().multiplier()), self.into_skill().unwrap().multiplier()),
Item::Reflect => format!( Item::ReflectI |
Item::ReflectII |
Item::ReflectIII => format!(
"Reflect incoming skills to source. Lasts {:?}T", "Reflect incoming skills to source. Lasts {:?}T",
self.into_skill().unwrap().effect().first().unwrap().get_duration()), self.into_skill().unwrap().effect().first().unwrap().get_duration()),
Item::Recharge => format!( Item::RechargeI |
Item::RechargeII |
Item::RechargeIII => format!(
"Recharge red and blue shield based on {:?} red and blue power", "Recharge red and blue shield based on {:?} red and blue power",
self.into_skill().unwrap().multiplier()), self.into_skill().unwrap().multiplier()),
Item::Ruin => format!( Item::RuinI |
Item::RuinII |
Item::RuinIII => format!(
"Team wide Stun for {:?}T. Stunned cryps are unable to cast skills.", "Team wide Stun for {:?}T. Stunned cryps are unable to cast skills.",
self.into_skill().unwrap().effect().first().unwrap().get_duration()), self.into_skill().unwrap().effect().first().unwrap().get_duration()),
Item::Scatter => format!( Item::ScatterI |
Item::ScatterII |
Item::ScatterIII => format!(
"Caster links with target. Linked cryps split incoming damage evenly. Recharges target blue shield {:?}% of blue power", "Caster links with target. Linked cryps split incoming damage evenly. Recharges target blue shield {:?}% of blue power",
self.into_skill().unwrap().multiplier()), self.into_skill().unwrap().multiplier()),
Item::Silence => format!( Item::SilenceI |
Item::SilenceII |
Item::SilenceIII => format!(
"Block the target from using blue skills for {:?}T and deals blue damage {:?}% blue power. {}", "Block the target from using blue skills for {:?}T and deals blue damage {:?}% blue power. {}",
self.into_skill().unwrap().effect().first().unwrap().get_duration(), self.into_skill().unwrap().effect().first().unwrap().get_duration(),
self.into_skill().unwrap().multiplier(), self.into_skill().unwrap().multiplier(),
@ -519,7 +567,9 @@ impl Item {
match self { match self {
Item::Taunt => vec![Item::Buff, Item::Red, Item::Red], Item::Taunt => vec![Item::Buff, Item::Red, Item::Red],
Item::Triage => vec![Item::Buff, Item::Green, Item::Green], Item::Triage => vec![Item::Buff, Item::Green, Item::Green],
Item::Scatter => vec![Item::Buff, Item::Blue, Item::Blue], Item::ScatterI => vec![Item::Buff, Item::Blue, Item::Blue],
Item::ScatterII => vec![Item::ScatterI, Item::ScatterI, Item::ScatterI],
Item::ScatterIII => vec![Item::ScatterIII, Item::ScatterIII, Item::ScatterIII],
Item::Haste => vec![Item::Buff, Item::Red, Item::Green], Item::Haste => vec![Item::Buff, Item::Red, Item::Green],
Item::Impurity => vec![Item::Buff, Item::Green, Item::Blue], Item::Impurity => vec![Item::Buff, Item::Green, Item::Blue],
Item::AmplifyI => vec![Item::Buff, Item::Red, Item::Blue], Item::AmplifyI => vec![Item::Buff, Item::Red, Item::Blue],
@ -527,26 +577,41 @@ impl Item {
Item::AmplifyIII => vec![Item::AmplifyII, Item::AmplifyII, Item::AmplifyII], Item::AmplifyIII => vec![Item::AmplifyII, Item::AmplifyII, Item::AmplifyII],
Item::Snare => vec![Item::Debuff, Item::Red, Item::Red], Item::Snare => vec![Item::Debuff, Item::Red, Item::Red],
Item::Purge => vec![Item::Debuff, Item::Green, Item::Green], // Needs flavour Item::PurgeI => vec![Item::Debuff, Item::Green, Item::Green], // Needs flavour
Item::Silence => vec![Item::Debuff, Item::Blue, Item::Blue], Item::PurgeII => vec![Item::PurgeI, Item::PurgeI, Item::PurgeI], // Needs flavour
Item::PurgeIII => vec![Item::PurgeII, Item::PurgeII, Item::PurgeII], // Needs flavour
Item::SilenceI => vec![Item::Debuff, Item::Blue, Item::Blue],
Item::SilenceII => vec![Item::SilenceI, Item::SilenceI, Item::SilenceI],
Item::SilenceIII => vec![Item::SilenceII, Item::SilenceII, Item::SilenceII],
Item::CurseI => vec![Item::Debuff, Item::Red, Item::Green], Item::CurseI => vec![Item::Debuff, Item::Red, Item::Green],
Item::CurseII => vec![Item::CurseI, Item::CurseI, Item::CurseI], Item::CurseII => vec![Item::CurseI, Item::CurseI, Item::CurseI],
Item::CurseIII => vec![Item::CurseII, Item::CurseII, Item::CurseII], Item::CurseIII => vec![Item::CurseII, Item::CurseII, Item::CurseII],
Item::Decay => vec![Item::Debuff, Item::Green, Item::Blue], Item::Decay => vec![Item::Debuff, Item::Green, Item::Blue],
Item::Invert => vec![Item::Debuff, Item::Red, Item::Blue], Item::InvertI => vec![Item::Debuff, Item::Red, Item::Blue],
Item::InvertII => vec![Item::InvertI, Item::InvertI, Item::InvertI],
Item::InvertIII => vec![Item::InvertII, Item::InvertII, Item::InvertII],
Item::Parry => vec![Item::Block, Item::Red, Item::Red], // Add red recharge Item::Parry => vec![Item::Block, Item::Red, Item::Red], // Add red recharge
Item::Purify => vec![Item::Block, Item::Green, Item::Green], Item::PurifyI => vec![Item::Block, Item::Green, Item::Green],
Item::PurifyII => vec![Item::PurifyI, Item::PurifyI, Item::PurifyI],
Item::PurifyIII => vec![Item::PurifyII, Item::PurifyII, Item::PurifyII],
Item::Corrupt => vec![Item::Block, Item::Blue, Item::Blue], Item::Corrupt => vec![Item::Block, Item::Blue, Item::Blue],
Item::ClutchI => vec![Item::Block, Item::Red, Item::Green], Item::ClutchI => vec![Item::Block, Item::Red, Item::Green],
Item::ClutchII => vec![Item::ClutchI, Item::ClutchI, Item::ClutchI], Item::ClutchII => vec![Item::ClutchI, Item::ClutchI, Item::ClutchI],
Item::ClutchIII => vec![Item::ClutchII, Item::ClutchII, Item::ClutchII], Item::ClutchIII => vec![Item::ClutchII, Item::ClutchII, Item::ClutchII],
Item::Reflect => vec![Item::Block, Item::Green, Item::Blue], Item::ReflectI => vec![Item::Block, Item::Green, Item::Blue],
Item::Recharge => vec![Item::Block, Item::Red, Item::Blue], Item::ReflectII => vec![Item::ReflectI, Item::ReflectI, Item::ReflectI],
Item::ReflectIII => vec![Item::ReflectII, Item::ReflectII, Item::ReflectII],
Item::RechargeI => vec![Item::Block, Item::Red, Item::Blue],
Item::RechargeII => vec![Item::RechargeI, Item::RechargeI, Item::RechargeI],
Item::RechargeIII => vec![Item::RechargeII, Item::RechargeII, Item::RechargeII],
Item::Strangle => vec![Item::Stun, Item::Red, Item::Red], Item::Strangle => vec![Item::Stun, Item::Red, Item::Red],
Item::Sleep => vec![Item::Stun, Item::Green, Item::Green], Item::Sleep => vec![Item::Stun, Item::Green, Item::Green],
Item::Ruin => vec![Item::Stun, Item::Blue, Item::Blue], Item::RuinI => vec![Item::Stun, Item::Blue, Item::Blue],
Item::RuinII => vec![Item::RuinI, Item::RuinI, Item::RuinI],
Item::RuinIII => vec![Item::RuinII, Item::RuinII, Item::RuinII],
Item::Throw => vec![Item::Stun, Item::Red, Item::Green], Item::Throw => vec![Item::Stun, Item::Red, Item::Green],
Item::HexI => vec![Item::Stun, Item::Green, Item::Blue], Item::HexI => vec![Item::Stun, Item::Green, Item::Blue],
Item::HexII => vec![Item::HexI, Item::HexI, Item::HexI], Item::HexII => vec![Item::HexI, Item::HexI, Item::HexI],
@ -627,15 +692,31 @@ impl From<Skill> for Item {
Skill::HexII => Item::HexII, Skill::HexII => Item::HexII,
Skill::HexIII => Item::HexIII, Skill::HexIII => Item::HexIII,
Skill::Impurity => Item::Impurity, Skill::Impurity => Item::Impurity,
Skill::Invert => Item::Invert, Skill::InvertI => Item::InvertI,
Skill::InvertII => Item::InvertII,
Skill::InvertIII => Item::InvertIII,
Skill::Parry => Item::Parry, Skill::Parry => Item::Parry,
Skill::Purge => Item::Purge, Skill::PurgeI => Item::PurgeI,
Skill::Purify => Item::Purify, Skill::PurgeII => Item::PurgeII,
Skill::Recharge => Item::Recharge, Skill::PurgeIII => Item::PurgeIII,
Skill::Reflect => Item::Reflect, Skill::PurifyI => Item::PurifyI,
Skill::Ruin => Item::Ruin, Skill::PurifyII => Item::PurifyII,
Skill::Scatter => Item::Scatter, Skill::PurifyIII => Item::PurifyIII,
Skill::Silence => Item::Silence, 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::Siphon => Item::Siphon, Skill::Siphon => Item::Siphon,
Skill::Slay => Item::Slay, Skill::Slay => Item::Slay,
Skill::Sleep => Item::Sleep, Skill::Sleep => Item::Sleep,
@ -708,7 +789,9 @@ pub fn get_combos() -> Vec<Combo> {
let mut combinations = vec![ let mut combinations = vec![
Combo { components: Item::Taunt.combo(), item: Item::Taunt }, Combo { components: Item::Taunt.combo(), item: Item::Taunt },
Combo { components: Item::Triage.combo(), item: Item::Triage }, Combo { components: Item::Triage.combo(), item: Item::Triage },
Combo { components: Item::Scatter.combo(), item: Item::Scatter }, Combo { components: Item::ScatterI.combo(), item: Item::ScatterI },
Combo { components: Item::ScatterII.combo(), item: Item::ScatterII },
Combo { components: Item::ScatterIII.combo(), item: Item::ScatterIII },
Combo { components: Item::Haste.combo(), item: Item::Haste }, Combo { components: Item::Haste.combo(), item: Item::Haste },
Combo { components: Item::Impurity.combo(), item: Item::Impurity }, Combo { components: Item::Impurity.combo(), item: Item::Impurity },
Combo { components: Item::AmplifyI.combo(), item: Item::AmplifyI }, Combo { components: Item::AmplifyI.combo(), item: Item::AmplifyI },
@ -716,26 +799,47 @@ pub fn get_combos() -> Vec<Combo> {
Combo { components: Item::AmplifyIII.combo(), item: Item::AmplifyIII }, Combo { components: Item::AmplifyIII.combo(), item: Item::AmplifyIII },
Combo { components: Item::Snare.combo(), item: Item::Snare }, Combo { components: Item::Snare.combo(), item: Item::Snare },
Combo { components: Item::Purge.combo(), item: Item::Purge }, // Needs flavour Combo { components: Item::PurgeI.combo(), item: Item::PurgeI }, // Needs flavour
Combo { components: Item::Silence.combo(), item: Item::Silence }, Combo { components: Item::PurgeII.combo(), item: Item::PurgeII },
Combo { components: Item::PurgeIII.combo(), item: Item::PurgeIII },
Combo { components: Item::SilenceI.combo(), item: Item::SilenceI },
Combo { components: Item::SilenceII.combo(), item: Item::SilenceII },
Combo { components: Item::SilenceIII.combo(), item: Item::SilenceIII },
Combo { components: Item::CurseI.combo(), item: Item::CurseI }, Combo { components: Item::CurseI.combo(), item: Item::CurseI },
Combo { components: Item::CurseII.combo(), item: Item::CurseII }, Combo { components: Item::CurseII.combo(), item: Item::CurseII },
Combo { components: Item::CurseIII.combo(), item: Item::CurseIII }, Combo { components: Item::CurseIII.combo(), item: Item::CurseIII },
Combo { components: Item::Decay.combo(), item: Item::Decay }, Combo { components: Item::Decay.combo(), item: Item::Decay },
Combo { components: Item::Invert.combo(), item: Item::Invert }, Combo { components: Item::InvertI.combo(), item: Item::InvertI },
Combo { components: Item::InvertII.combo(), item: Item::InvertII },
Combo { components: Item::InvertIII.combo(), item: Item::InvertIII },
Combo { components: Item::Parry.combo(), item: Item::Parry }, // Add red recharge Combo { components: Item::Parry.combo(), item: Item::Parry }, // Add red recharge
Combo { components: Item::Purify.combo(), item: Item::Purify }, Combo { components: Item::PurifyI.combo(), item: Item::PurifyI },
Combo { components: Item::PurifyII.combo(), item: Item::PurifyII },
Combo { components: Item::PurifyIII.combo(), item: Item::PurifyIII },
Combo { components: Item::Corrupt.combo(), item: Item::Corrupt }, Combo { components: Item::Corrupt.combo(), item: Item::Corrupt },
Combo { components: Item::ClutchI.combo(), item: Item::ClutchI }, Combo { components: Item::ClutchI.combo(), item: Item::ClutchI },
Combo { components: Item::ClutchII.combo(), item: Item::ClutchII }, Combo { components: Item::ClutchII.combo(), item: Item::ClutchII },
Combo { components: Item::ClutchIII.combo(), item: Item::ClutchIII }, Combo { components: Item::ClutchIII.combo(), item: Item::ClutchIII },
Combo { components: Item::Reflect.combo(), item: Item::Reflect }, Combo { components: Item::ReflectI.combo(), item: Item::ReflectI },
Combo { components: Item::Recharge.combo(), item: Item::Recharge }, Combo { components: Item::ReflectII.combo(), item: Item::ReflectII },
Combo { components: Item::ReflectIII.combo(), item: Item::ReflectIII },
Combo { components: Item::RechargeI.combo(), item: Item::RechargeI },
Combo { components: Item::RechargeII.combo(), item: Item::RechargeII },
Combo { components: Item::RechargeIII.combo(), item: Item::RechargeIII },
Combo { components: Item::Strangle.combo(), item: Item::Strangle }, Combo { components: Item::Strangle.combo(), item: Item::Strangle },
Combo { components: Item::Sleep.combo(), item: Item::Sleep }, Combo { components: Item::Sleep.combo(), item: Item::Sleep },
Combo { components: Item::Ruin.combo(), item: Item::Ruin }, Combo { components: Item::RuinI.combo(), item: Item::RuinI },
Combo { components: Item::RuinII.combo(), item: Item::RuinII },
Combo { components: Item::RuinIII.combo(), item: Item::RuinIII },
Combo { components: Item::Throw.combo(), item: Item::Throw }, Combo { components: Item::Throw.combo(), item: Item::Throw },
Combo { components: Item::HexI.combo(), item: Item::HexI }, Combo { components: Item::HexI.combo(), item: Item::HexI },
Combo { components: Item::HexII.combo(), item: Item::HexII }, Combo { components: Item::HexII.combo(), item: Item::HexII },

248
server/src/skill.rs
View File

@ -112,52 +112,87 @@ pub fn resolve(skill: Skill, source: &mut Cryp, target: &mut Cryp, mut resolutio
// } // }
resolutions = match skill { resolutions = match skill {
Skill::AmplifyI => amplify(source, target, resolutions, skill), Skill::AmplifyI |
Skill::AmplifyII => amplify(source, target, resolutions, skill), Skill::AmplifyII |
Skill::AmplifyIII => amplify(source, target, resolutions, skill), Skill::AmplifyIII => amplify(source, target, resolutions, skill),
Skill::Attack => attack(source, target, resolutions, skill), Skill::Attack => attack(source, target, resolutions, skill),
Skill::Banish => banish(source, target, resolutions, skill), // TODO prevent all actions Skill::Banish => banish(source, target, resolutions, skill), // TODO prevent all actions
Skill::BlastI => blast(source, target, resolutions, skill),
Skill::BlastII => blast(source, target, resolutions, skill), Skill::BlastI |
Skill::BlastII |
Skill::BlastIII => blast(source, target, resolutions, skill), Skill::BlastIII => blast(source, target, resolutions, skill),
Skill::Block => block(source, target, resolutions, skill), Skill::Block => block(source, target, resolutions, skill),
Skill::Buff => buff(source, target, resolutions, skill), Skill::Buff => buff(source, target, resolutions, skill),
Skill::ChaosI => chaos(source, target, resolutions, skill),
Skill::ChaosII => chaos(source, target, resolutions, skill), Skill::ChaosI |
Skill::ChaosII |
Skill::ChaosIII => chaos(source, target, resolutions, skill), Skill::ChaosIII => chaos(source, target, resolutions, skill),
Skill::ClutchI => clutch(source, target, resolutions, skill),
Skill::ClutchII => clutch(source, target, resolutions, skill), Skill::ClutchI |
Skill::ClutchII |
Skill::ClutchIII => clutch(source, target, resolutions, skill), Skill::ClutchIII => clutch(source, target, resolutions, skill),
Skill::Corrupt => corrupt(source, target, resolutions, skill), Skill::Corrupt => corrupt(source, target, resolutions, skill),
Skill::CorruptionTick => corruption_tick(source, target, resolutions, skill), Skill::CorruptionTick => corruption_tick(source, target, resolutions, skill),
Skill::CurseI => curse(source, target, resolutions, skill),
Skill::CurseII => curse(source, target, resolutions, skill), Skill::CurseI |
Skill::CurseII |
Skill::CurseIII => curse(source, target, resolutions, skill), Skill::CurseIII => curse(source, target, resolutions, skill),
Skill::Debuff => debuff(source, target, resolutions, skill), // speed slow Skill::Debuff => debuff(source, target, resolutions, skill), // speed slow
Skill::Decay => decay(source, target, resolutions, skill), // dot Skill::Decay => decay(source, target, resolutions, skill), // dot
Skill::DecayTick => decay_tick(source, target, resolutions, skill), // dot Skill::DecayTick => decay_tick(source, target, resolutions, skill), // dot
Skill::Haste => haste(source, target, resolutions, skill), // speed slow Skill::Haste => haste(source, target, resolutions, skill), // speed slow
Skill::HasteStrike => panic!("haste strike should not be caste"),
Skill::HealI => heal(source, target, resolutions, skill), Skill::HealI |
Skill::HealII => heal(source, target, resolutions, skill), Skill::HealII |
Skill::HealIII => heal(source, target, resolutions, skill), Skill::HealIII => heal(source, target, resolutions, skill),
Skill::HexI => hex(source, target, resolutions, skill),
Skill::HexII => hex(source, target, resolutions, skill), Skill::HexI |
Skill::HexII |
Skill::HexIII => hex(source, target, resolutions, skill), Skill::HexIII => hex(source, target, resolutions, skill),
Skill::Hostility => hostility(source, target, resolutions, skill), Skill::Hostility => hostility(source, target, resolutions, skill),
Skill::Impurity => impurity(source, target, resolutions, skill), Skill::Impurity => impurity(source, target, resolutions, skill),
Skill::ImpureBlast => panic!("impure blast should not be caste"),
Skill::Invert => invert(source, target, resolutions, skill), Skill::InvertI |
Skill::Injure => injure(source, target, resolutions, skill), Skill::InvertII |
Skill::InvertIII => invert(source, target, resolutions, skill),
Skill::Parry => parry(source, target, resolutions, skill), Skill::Parry => parry(source, target, resolutions, skill),
Skill::Purge => purge(source, target, resolutions, skill), // dispel all buffs
Skill::Purify => purify(source, target, resolutions, skill), // dispel all debuffs Skill::PurgeI |
Skill::Recharge => recharge(source, target, resolutions, skill), // target is immune to magic damage and fx Skill::PurgeII |
Skill::Reflect => reflect(source, target, resolutions, skill), Skill::PurgeIII => purge(source, target, resolutions, skill), // dispel all buffs
Skill::Riposte => panic!("riposte should not be caste"),
Skill::Ruin => ruin(source, target, resolutions, skill), Skill::PurifyI |
Skill::Scatter => scatter(source, target, resolutions, skill), // target is immune to magic damage and fx Skill::PurifyII |
Skill::Silence => silence(source, target, resolutions, skill), // target cannot cast spells Skill::PurifyIII => purify(source, target, resolutions, skill),
Skill::RechargeI |
Skill::RechargeII |
Skill::RechargeIII => recharge(source, target, resolutions, skill),
Skill::ReflectI |
Skill::ReflectII |
Skill::ReflectIII => reflect(source, target, resolutions, skill),
Skill::RuinI |
Skill::RuinII |
Skill::RuinIII => ruin(source, target, resolutions, skill),
Skill::ScatterI |
Skill::ScatterII |
Skill::ScatterIII => scatter(source, target, resolutions, skill), // target is immune to magic damage and fx
Skill::SilenceI |
Skill::SilenceII |
Skill::SilenceIII => silence(source, target, resolutions, skill), // target cannot cast spells
// Recharge -> Silence
Skill::Siphon => siphon(source, target, resolutions, skill), Skill::Siphon => siphon(source, target, resolutions, skill),
Skill::SiphonTick => siphon_tick(source, target, resolutions, skill), // hot Skill::SiphonTick => siphon_tick(source, target, resolutions, skill), // hot
Skill::Slay => slay(source, target, resolutions, skill), // hybrid dmg self heal Skill::Slay => slay(source, target, resolutions, skill), // hybrid dmg self heal
@ -174,6 +209,13 @@ pub fn resolve(skill: Skill, source: &mut Cryp, target: &mut Cryp, mut resolutio
Skill::Triage => triage(source, target, resolutions, skill), // hot Skill::Triage => triage(source, target, resolutions, skill), // hot
Skill::TriageTick => triage_tick(source, target, resolutions, skill), // hot Skill::TriageTick => triage_tick(source, target, resolutions, skill), // hot
Skill::HasteStrike => panic!("should only trigger from haste"),
Skill::ImpureBlast => panic!("should only trigger from impurity"),
Skill::Riposte => panic!("should only trigger from parry"),
// Not used
Skill::Injure => injure(source, target, resolutions, skill),
// ----------------- // -----------------
// Test // Test
// ----------------- // -----------------
@ -345,7 +387,6 @@ pub enum Effect {
Invert, Invert,
Parry, Parry,
Reflect, Reflect,
Ruin,
Slow, Slow,
Snare, Snare,
Strangle, Strangle,
@ -405,8 +446,10 @@ impl Effect {
Skill::HexI, Skill::HexI,
Skill::HexII, Skill::HexII,
Skill::HexIII, Skill::HexIII,
Skill::Silence, Skill::SilenceI,
Skill::Ruin, Skill::RuinI,
Skill::RuinII,
Skill::RuinIII,
Skill::Strangle, Skill::Strangle,
Skill::Snare Skill::Snare
].contains(&skill), ].contains(&skill),
@ -423,7 +466,6 @@ impl Effect {
match self { match self {
Effect::Stun => true, Effect::Stun => true,
Effect::Hex => true, Effect::Hex => true,
Effect::Ruin => true,
Effect::Banish => true, Effect::Banish => true,
Effect::Strangle => true, Effect::Strangle => true,
Effect::Strangling => skill != Skill::StrangleTick, Effect::Strangling => skill != Skill::StrangleTick,
@ -502,7 +544,6 @@ impl Effect {
// magic // magic
Effect::Hex => EffectCategory::Debuff, Effect::Hex => EffectCategory::Debuff,
Effect::Ruin => EffectCategory::Debuff,
Effect::Curse => EffectCategory::Debuff, Effect::Curse => EffectCategory::Debuff,
Effect::Banish => EffectCategory::Debuff, // todo randomise Effect::Banish => EffectCategory::Debuff, // todo randomise
// Effect::Banish => rng.gen_bool(0.5), // Effect::Banish => rng.gen_bool(0.5),
@ -590,16 +631,32 @@ pub enum Skill {
ImpureBlast, ImpureBlast,
Impurity, Impurity,
Injure, Injure,
Invert, InvertI,
InvertII,
InvertIII,
Parry, // avoid all damage Parry, // avoid all damage
Purge, PurgeI,
Purify, PurgeII,
Recharge, PurgeIII,
Reflect, PurifyI,
PurifyII,
PurifyIII,
RechargeI,
RechargeII,
RechargeIII,
ReflectI,
ReflectII,
ReflectIII,
Riposte, Riposte,
Ruin, RuinI,
Scatter, RuinII,
Silence, RuinIII,
ScatterI,
ScatterII,
ScatterIII,
SilenceI,
SilenceII,
SilenceIII,
Siphon, Siphon,
SiphonTick, SiphonTick,
Slay, Slay,
@ -650,9 +707,15 @@ impl Skill {
Skill::CorruptionTick => 80, Skill::CorruptionTick => 80,
Skill::Parry => 110, Skill::Parry => 110,
Skill::Riposte => 70, Skill::Riposte => 70,
Skill::Purify => 45, //Green dmg (heal) Skill::PurifyI => 45, //Green dmg (heal)
Skill::Reflect => 45, //restore blue life (heal) Skill::PurifyII => 70,
Skill::Recharge => 85, //restore red and blue life (heal) Skill::PurifyIII => 105,
Skill::ReflectI => 45, //restore blue life (heal)
Skill::ReflectII => 70,
Skill::ReflectIII => 100,
Skill::RechargeI => 85, //restore red and blue life (heal)
Skill::RechargeII => 130,
Skill::RechargeIII => 200,
// Stun Base // Stun Base
Skill::Sleep => 240, //Green dmg (heal) Skill::Sleep => 240, //Green dmg (heal)
@ -660,13 +723,17 @@ impl Skill {
// Debuff Base // Debuff Base
Skill::DecayTick => 25, Skill::DecayTick => 25,
Skill::Silence => 55, // Deals more per blue skill on target Skill::SilenceI => 55, // Deals more per blue skill on target
Skill::SilenceII => 80, // Deals more per blue skill on target
Skill::SilenceIII => 110, // Deals more per blue skill on target
Skill::Snare => 40, // Deals more per red skill on target Skill::Snare => 40, // Deals more per red skill on target
// Buff base // Buff base
Skill::ImpureBlast => 25, Skill::ImpureBlast => 25,
Skill::HasteStrike => 30, Skill::HasteStrike => 30,
Skill::Scatter => 140, Skill::ScatterI => 140,
Skill::ScatterII => 200,
Skill::ScatterIII => 300,
Skill::Taunt => 80, Skill::Taunt => 80,
Skill::TriageTick => 75, Skill::TriageTick => 75,
@ -694,6 +761,7 @@ impl Skill {
Skill::CurseII => vec![CrypEffect {effect: Effect::Curse, duration: 2, meta: Some(EffectMeta::Multiplier(200)), tick: None}], Skill::CurseII => vec![CrypEffect {effect: Effect::Curse, duration: 2, meta: Some(EffectMeta::Multiplier(200)), tick: None}],
Skill::CurseIII => vec![CrypEffect {effect: Effect::Curse, duration: 3, meta: Some(EffectMeta::Multiplier(250)), tick: None}], Skill::CurseIII => vec![CrypEffect {effect: Effect::Curse, duration: 3, meta: Some(EffectMeta::Multiplier(250)), tick: None}],
Skill::Debuff => vec![CrypEffect {effect: Effect::Slow, duration: 3, meta: Some(EffectMeta::Multiplier(50)), tick: None }], Skill::Debuff => vec![CrypEffect {effect: Effect::Slow, duration: 3, meta: Some(EffectMeta::Multiplier(50)), tick: None }],
Skill::Decay => vec![CrypEffect {effect: Effect::Wither, duration: 3, meta: Some(EffectMeta::Multiplier(50)), tick: None }, Skill::Decay => vec![CrypEffect {effect: Effect::Wither, duration: 3, meta: Some(EffectMeta::Multiplier(50)), tick: None },
CrypEffect {effect: Effect::Decay, duration: 3, meta: None, tick: None }], CrypEffect {effect: Effect::Decay, duration: 3, meta: None, tick: None }],
Skill::Haste => vec![CrypEffect {effect: Effect::Haste, duration: 2, meta: Some(EffectMeta::Multiplier(150)), tick: None }], Skill::Haste => vec![CrypEffect {effect: Effect::Haste, duration: 2, meta: Some(EffectMeta::Multiplier(150)), tick: None }],
@ -703,18 +771,26 @@ impl Skill {
Skill::Hostility => vec![CrypEffect {effect: Effect::Hostility, duration: 2, meta: None, tick: None}, Skill::Hostility => vec![CrypEffect {effect: Effect::Hostility, duration: 2, meta: None, tick: None},
CrypEffect {effect: Effect::Hatred, duration: 5, meta: None, tick: None}], CrypEffect {effect: Effect::Hatred, duration: 5, meta: None, tick: None}],
Skill::Impurity => vec![CrypEffect {effect: Effect::Impurity, duration: 3, meta: Some(EffectMeta::Multiplier(150)), tick: None }], Skill::Impurity => vec![CrypEffect {effect: Effect::Impurity, duration: 3, meta: Some(EffectMeta::Multiplier(150)), tick: None }],
Skill::Invert => vec![CrypEffect {effect: Effect::Invert, duration: 2, meta: None, tick: None}], Skill::InvertI => vec![CrypEffect {effect: Effect::Invert, duration: 2, meta: None, tick: None}],
Skill::InvertII => vec![CrypEffect {effect: Effect::Invert, duration: 3, meta: None, tick: None}],
Skill::InvertIII => vec![CrypEffect {effect: Effect::Invert, duration: 4, meta: None, tick: None}],
Skill::Parry => vec![CrypEffect {effect: Effect::Parry, duration: 2, meta: None, tick: None }], Skill::Parry => vec![CrypEffect {effect: Effect::Parry, duration: 2, meta: None, tick: None }],
Skill::Reflect => vec![CrypEffect {effect: Effect::Reflect, duration: 1, meta: None, tick: None }], Skill::ReflectI => vec![CrypEffect {effect: Effect::Reflect, duration: 1, meta: None, tick: None }],
Skill::ReflectII => vec![CrypEffect {effect: Effect::Reflect, duration: 2, meta: None, tick: None }],
Skill::ReflectIII => vec![CrypEffect {effect: Effect::Reflect, duration: 3, meta: None, tick: None }],
Skill::Throw => vec![CrypEffect {effect: Effect::Stun, duration: 1, meta: None, tick: None}, Skill::Throw => vec![CrypEffect {effect: Effect::Stun, duration: 1, meta: None, tick: None},
CrypEffect {effect: Effect::Vulnerable, duration: 3, meta: Some(EffectMeta::Multiplier(150)), tick: None}], CrypEffect {effect: Effect::Vulnerable, duration: 3, meta: Some(EffectMeta::Multiplier(150)), tick: None}],
Skill::Ruin => vec![CrypEffect {effect: Effect::Stun, duration: 1, meta: None, tick: None}], Skill::RuinI => vec![CrypEffect {effect: Effect::Stun, duration: 1, meta: None, tick: None}],
Skill::RuinII => vec![CrypEffect {effect: Effect::Stun, duration: 1, meta: None, tick: None}],
Skill::RuinIII => vec![CrypEffect {effect: Effect::Stun, duration: 2, meta: None, tick: None}],
Skill::Scatter => vec![CrypEffect {effect: Effect::Scatter, duration: 2, meta: None, tick: None}], Skill::ScatterI => vec![CrypEffect {effect: Effect::Scatter, duration: 2, meta: None, tick: None}],
Skill::Silence => vec![CrypEffect {effect: Effect::Silence, duration: 2, meta: None, tick: None}], Skill::ScatterII => vec![CrypEffect {effect: Effect::Scatter, duration: 3, meta: None, tick: None}],
Skill::ScatterIII => vec![CrypEffect {effect: Effect::Scatter, duration: 4, meta: None, tick: None}],
Skill::SilenceI => vec![CrypEffect {effect: Effect::Silence, duration: 2, meta: None, tick: None}],
Skill::SilenceII => vec![CrypEffect {effect: Effect::Silence, duration: 2, meta: None, tick: None}],
Skill::SilenceIII => vec![CrypEffect {effect: Effect::Silence, duration: 3, meta: None, tick: None}],
Skill::Siphon => vec![CrypEffect {effect: Effect::Siphon, duration: 2, meta: None, tick: None}], Skill::Siphon => vec![CrypEffect {effect: Effect::Siphon, duration: 2, meta: None, tick: None}],
Skill::Sleep => vec![CrypEffect {effect: Effect::Stun, duration: 2, meta: None, tick: None}], Skill::Sleep => vec![CrypEffect {effect: Effect::Stun, duration: 2, meta: None, tick: None}],
Skill::Snare => vec![CrypEffect {effect: Effect::Snare, duration: 2, meta: None, tick: None}], Skill::Snare => vec![CrypEffect {effect: Effect::Snare, duration: 2, meta: None, tick: None}],
@ -762,7 +838,9 @@ impl Skill {
Skill::AmplifyIII => Some(1), Skill::AmplifyIII => Some(1),
Skill::Impurity => Some(3), Skill::Impurity => Some(3),
Skill::ImpureBlast => None, Skill::ImpureBlast => None,
Skill::Invert => Some(2), Skill::InvertI => Some(2),
Skill::InvertII => Some(2),
Skill::InvertIII => Some(2),
Skill::Decay => Some(1), // dot Skill::Decay => Some(1), // dot
Skill::DecayTick => None, Skill::DecayTick => None,
Skill::Siphon => None, Skill::Siphon => None,
@ -770,10 +848,18 @@ impl Skill {
Skill::CurseI => Some(1), Skill::CurseI => Some(1),
Skill::CurseII => Some(1), Skill::CurseII => Some(1),
Skill::CurseIII => Some(1), Skill::CurseIII => Some(1),
Skill::Scatter => Some(2), Skill::ScatterI => Some(2),
Skill::Silence => Some(2), Skill::ScatterII => Some(2),
Skill::Purify => None, Skill::ScatterIII => Some(2),
Skill::Purge => None, Skill::SilenceI => Some(3),
Skill::SilenceII => Some(2),
Skill::SilenceIII => Some(2),
Skill::PurifyI => None,
Skill::PurifyII => None,
Skill::PurifyIII => None,
Skill::PurgeI => None,
Skill::PurgeII => None,
Skill::PurgeIII => None,
Skill::Banish => Some(1), Skill::Banish => Some(1),
Skill::HexI => Some(1), Skill::HexI => Some(1),
Skill::HexII => Some(2), Skill::HexII => Some(2),
@ -781,9 +867,15 @@ impl Skill {
Skill::Haste => Some(2), Skill::Haste => Some(2),
Skill::HasteStrike => None, // Used in haste Skill::HasteStrike => None, // Used in haste
Skill::Reflect => Some(2), Skill::ReflectI => Some(2),
Skill::Recharge => Some(2), Skill::ReflectII => Some(2),
Skill::Ruin => Some(3), Skill::ReflectIII => Some(2),
Skill::RechargeI => Some(2),
Skill::RechargeII => Some(2),
Skill::RechargeIII => Some(2),
Skill::RuinI => Some(3),
Skill::RuinII => Some(2),
Skill::RuinIII => Some(2),
Skill::Slay => None, Skill::Slay => None,
Skill::Sleep => Some(3), Skill::Sleep => Some(3),
@ -861,7 +953,9 @@ impl Skill {
pub fn aoe(&self) -> bool { pub fn aoe(&self) -> bool {
match self { match self {
Skill::Ruin => true, Skill::RuinI |
Skill::RuinII |
Skill::RuinIII => true,
_ => false, _ => false,
} }
} }
@ -889,16 +983,26 @@ impl Skill {
Skill::HealII | Skill::HealII |
Skill::HealIII | Skill::HealIII |
Skill::Triage | Skill::Triage |
Skill::Purify | Skill::PurifyI |
Skill::PurifyII |
Skill::PurifyIII |
Skill::Parry | Skill::Parry |
Skill::ClutchI | Skill::ClutchI |
Skill::ClutchII | Skill::ClutchII |
Skill::ClutchIII | Skill::ClutchIII |
Skill::Scatter | Skill::ScatterI |
Skill::Recharge | Skill::ScatterII |
Skill::Reflect | Skill::ScatterIII |
Skill::RechargeI |
Skill::RechargeII |
Skill::RechargeIII |
Skill::ReflectI |
Skill::ReflectII |
Skill::ReflectIII |
Skill::Haste | Skill::Haste |
Skill::Invert | Skill::InvertI |
Skill::InvertII |
Skill::InvertIII |
Skill::AmplifyI | Skill::AmplifyI |
Skill::AmplifyII | Skill::AmplifyII |
Skill::AmplifyIII | Skill::AmplifyIII |
@ -1351,7 +1455,7 @@ fn scatter_hit(source: &Cryp, target: &Cryp, mut results: Resolutions, game: &mu
Colour::Green => scatter_target.deal_green_damage(skill, amount), Colour::Green => scatter_target.deal_green_damage(skill, amount),
}; };
results.push(Resolution::new(target, scatter_target).event(Event::Skill { skill: Skill::Scatter })); results.push(Resolution::new(target, scatter_target).event(Event::Skill { skill: Skill::ScatterI }));
res.into_iter().for_each(|e| results.push(Resolution::new(&source, &scatter_target).event(e))); res.into_iter().for_each(|e| results.push(Resolution::new(&source, &scatter_target).event(e)));
} else { } else {
panic!("not a scatter target {:?}", scatter); panic!("not a scatter target {:?}", scatter);
@ -1530,7 +1634,7 @@ mod tests {
y.red_life.force(64); y.red_life.force(64);
y.red_life.reduce(64); y.red_life.reduce(64);
x.red_damage.force(256 + 64); x.red_damage.force(256 + 64);
invert(&mut y.clone(), &mut y, vec![], Skill::Invert); invert(&mut y.clone(), &mut y, vec![], Skill::InvertI);
assert!(y.affected(Effect::Invert)); assert!(y.affected(Effect::Invert));
// heal should deal green damage // heal should deal green damage
@ -1565,7 +1669,7 @@ mod tests {
let mut y = Cryp::new() let mut y = Cryp::new()
.named(&"camel".to_string()); .named(&"camel".to_string());
reflect(&mut y.clone(), &mut y, vec![], Skill::Reflect); reflect(&mut y.clone(), &mut y, vec![], Skill::ReflectI);
assert!(y.affected(Effect::Reflect)); assert!(y.affected(Effect::Reflect));
let mut results = vec![]; let mut results = vec![];
@ -1661,7 +1765,7 @@ mod tests {
y.deal_red_damage(Skill::Attack, 5); y.deal_red_damage(Skill::Attack, 5);
y.deal_blue_damage(Skill::BlastI, 5); y.deal_blue_damage(Skill::BlastI, 5);
let mut results = recharge(&mut x, &mut y, vec![], Skill::Recharge); let mut results = recharge(&mut x, &mut y, vec![], Skill::RechargeI);
let Resolution { source: _, target: _, event } = results.remove(0); let Resolution { source: _, target: _, event } = results.remove(0);
match event { match event {
@ -1679,9 +1783,9 @@ mod tests {
let mut x = Cryp::new() let mut x = Cryp::new()
.named(&"muji".to_string()); .named(&"muji".to_string());
silence(&mut x.clone(), &mut x, vec![], Skill::Silence); silence(&mut x.clone(), &mut x, vec![], Skill::SilenceI);
assert!(x.effects.iter().any(|e| e.effect == Effect::Silence)); assert!(x.effects.iter().any(|e| e.effect == Effect::Silence));
assert!(x.disabled(Skill::Silence).is_some()); assert!(x.disabled(Skill::SilenceI).is_some());
} }
#[test] #[test]
@ -1704,7 +1808,7 @@ mod tests {
decay(&mut x.clone(), &mut x, vec![], Skill::Decay); decay(&mut x.clone(), &mut x, vec![], Skill::Decay);
assert!(x.effects.iter().any(|e| e.effect == Effect::Decay)); assert!(x.effects.iter().any(|e| e.effect == Effect::Decay));
purify(&mut x.clone(), &mut x, vec![], Skill::Purify); purify(&mut x.clone(), &mut x, vec![], Skill::PurifyI);
assert!(!x.effects.iter().any(|e| e.effect == Effect::Decay)); assert!(!x.effects.iter().any(|e| e.effect == Effect::Decay));
} }
} }