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();

216
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::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::ClutchI.combo(), item: Item::ClutchI },
Combo { components: Item::ClutchII.combo(), item: Item::ClutchII },
Combo { components: Item::ClutchIII.combo(), item: Item::ClutchIII },
Combo { components: Item::ReflectI.combo(), item: Item::ReflectI },
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::Sleep.combo(), item: Item::Sleep },
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::Parry.combo(), item: Item::Parry }, // Add red recharge
Combo { components: Item::Purify.combo(), item: Item::Purify },
Combo { components: Item::Corrupt.combo(), item: Item::Corrupt },
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::Reflect.combo(), item: Item::Reflect },
Combo { components: Item::Recharge.combo(), item: Item::Recharge },
Combo { components: Item::Strangle.combo(), item: Item::Strangle },
Combo { components: Item::Sleep.combo(), item: Item::Sleep },
Combo { components: Item::Ruin.combo(), item: Item::Ruin },
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 },

328
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::BlastIII => blast(source, target, resolutions, skill), Skill::BlastII |
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::ChaosIII => chaos(source, target, resolutions, skill), Skill::ChaosII |
Skill::ClutchI => clutch(source, target, resolutions, skill), Skill::ChaosIII => chaos(source, target, resolutions, skill),
Skill::ClutchII => clutch(source, target, resolutions, skill),
Skill::ClutchIII => clutch(source, target, resolutions, skill), Skill::ClutchI |
Skill::ClutchII |
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::CurseIII => curse(source, target, resolutions, skill), Skill::CurseII |
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::HexIII => hex(source, target, resolutions, skill), Skill::HexII |
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,
@ -677,51 +744,60 @@ impl Skill {
pub fn effect(&self) -> Vec<CrypEffect> { pub fn effect(&self) -> Vec<CrypEffect> {
match self { match self {
// Modifiers // Modifiers
Skill::AmplifyI => vec![CrypEffect {effect: Effect::Amplify, duration: 2, meta: Some(EffectMeta::Multiplier(150)), tick: None}], Skill::AmplifyI => vec![CrypEffect {effect: Effect::Amplify, duration: 2, meta: Some(EffectMeta::Multiplier(150)), tick: None}],
Skill::AmplifyII => vec![CrypEffect {effect: Effect::Amplify, duration: 3, meta: Some(EffectMeta::Multiplier(175)), tick: None}], Skill::AmplifyII => vec![CrypEffect {effect: Effect::Amplify, duration: 3, meta: Some(EffectMeta::Multiplier(175)), tick: None}],
Skill::AmplifyIII => vec![CrypEffect {effect: Effect::Amplify, duration: 4, meta: Some(EffectMeta::Multiplier(200)), tick: None}], Skill::AmplifyIII => vec![CrypEffect {effect: Effect::Amplify, duration: 4, meta: Some(EffectMeta::Multiplier(200)), tick: None}],
Skill::Banish => vec![CrypEffect {effect: Effect::Banish, duration: 1, meta: None, tick: None}], Skill::Banish => vec![CrypEffect {effect: Effect::Banish, duration: 1, meta: None, tick: None}],
Skill::Block => vec![CrypEffect {effect: Effect::Block, duration: 1, meta: Some(EffectMeta::Multiplier(50)), tick: None}], Skill::Block => vec![CrypEffect {effect: Effect::Block, duration: 1, meta: Some(EffectMeta::Multiplier(50)), tick: None}],
Skill::Buff => vec![CrypEffect {effect: Effect::Buff, duration: 2, meta: Some(EffectMeta::Multiplier(125)), tick: None }], Skill::Buff => vec![CrypEffect {effect: Effect::Buff, duration: 2, meta: Some(EffectMeta::Multiplier(125)), tick: None }],
Skill::Corrupt => vec![CrypEffect {effect: Effect::Corrupt, duration: 2, meta: None, tick: None}, Skill::Corrupt => vec![CrypEffect {effect: Effect::Corrupt, duration: 2, meta: None, tick: None},
CrypEffect {effect: Effect::Corruption, duration: 3, meta: None, tick: None}], CrypEffect {effect: Effect::Corruption, duration: 3, meta: None, tick: None}],
Skill::ClutchI => vec![CrypEffect {effect: Effect::Clutch, duration: 1, meta: None, tick: None }], Skill::ClutchI => vec![CrypEffect {effect: Effect::Clutch, duration: 1, meta: None, tick: None }],
Skill::ClutchII => vec![CrypEffect {effect: Effect::Clutch, duration: 2, meta: None, tick: None }], Skill::ClutchII => vec![CrypEffect {effect: Effect::Clutch, duration: 2, meta: None, tick: None }],
Skill::ClutchIII => vec![CrypEffect {effect: Effect::Clutch, duration: 3, meta: None, tick: None }], Skill::ClutchIII => vec![CrypEffect {effect: Effect::Clutch, duration: 3, meta: None, tick: None }],
Skill::CurseI => vec![CrypEffect {effect: Effect::Curse, duration: 2, meta: Some(EffectMeta::Multiplier(150)), tick: None}], Skill::CurseI => vec![CrypEffect {effect: Effect::Curse, duration: 2, meta: Some(EffectMeta::Multiplier(150)), tick: None}],
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 },
CrypEffect {effect: Effect::Decay, duration: 3, meta: None, tick: None }], Skill::Decay => vec![CrypEffect {effect: Effect::Wither, duration: 3, meta: Some(EffectMeta::Multiplier(50)), tick: None },
Skill::Haste => vec![CrypEffect {effect: Effect::Haste, duration: 2, meta: Some(EffectMeta::Multiplier(150)), tick: None }], CrypEffect {effect: Effect::Decay, duration: 3, meta: None, tick: None }],
Skill::HexI => vec![CrypEffect {effect: Effect::Hex, duration: 2, meta: None, tick: None}], Skill::Haste => vec![CrypEffect {effect: Effect::Haste, duration: 2, meta: Some(EffectMeta::Multiplier(150)), tick: None }],
Skill::HexII => vec![CrypEffect {effect: Effect::Hex, duration: 3, meta: None, tick: None}], Skill::HexI => vec![CrypEffect {effect: Effect::Hex, duration: 2, meta: None, tick: None}],
Skill::HexIII => vec![CrypEffect {effect: Effect::Hex, duration: 4, meta: None, tick: None}], Skill::HexII => vec![CrypEffect {effect: Effect::Hex, duration: 3, meta: None, tick: None}],
Skill::Hostility => vec![CrypEffect {effect: Effect::Hostility, duration: 2, meta: None, tick: None}, Skill::HexIII => vec![CrypEffect {effect: Effect::Hex, duration: 4, meta: None, tick: None}],
CrypEffect {effect: Effect::Hatred, duration: 5, meta: None, tick: None}], Skill::Hostility => vec![CrypEffect {effect: Effect::Hostility, duration: 2, meta: None, tick: None},
Skill::Impurity => vec![CrypEffect {effect: Effect::Impurity, duration: 3, meta: Some(EffectMeta::Multiplier(150)), tick: None }], CrypEffect {effect: Effect::Hatred, duration: 5, meta: None, tick: None}],
Skill::Invert => vec![CrypEffect {effect: Effect::Invert, duration: 2, meta: None, tick: None}], Skill::Impurity => vec![CrypEffect {effect: Effect::Impurity, duration: 3, meta: Some(EffectMeta::Multiplier(150)), 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::Throw => vec![CrypEffect {effect: Effect::Stun, duration: 1, meta: None, tick: None}, Skill::ReflectII => vec![CrypEffect {effect: Effect::Reflect, duration: 2, meta: None, tick: None }],
CrypEffect {effect: Effect::Vulnerable, duration: 3, meta: Some(EffectMeta::Multiplier(150)), 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},
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::Siphon => vec![CrypEffect {effect: Effect::Siphon, duration: 2, meta: None, tick: None}], Skill::ScatterIII => vec![CrypEffect {effect: Effect::Scatter, duration: 4, meta: None, tick: None}],
Skill::Sleep => vec![CrypEffect {effect: Effect::Stun, duration: 2, meta: None, tick: None}], Skill::SilenceI => vec![CrypEffect {effect: Effect::Silence, duration: 2, meta: None, tick: None}],
Skill::Snare => vec![CrypEffect {effect: Effect::Snare, duration: 2, meta: None, tick: None}], Skill::SilenceII => vec![CrypEffect {effect: Effect::Silence, duration: 2, meta: None, tick: None}],
Skill::Strangle => vec![CrypEffect {effect: Effect::Strangle, duration: 2, meta: None, tick: None}], Skill::SilenceIII => vec![CrypEffect {effect: Effect::Silence, duration: 3, meta: None, tick: None}],
Skill::Stun => vec![CrypEffect {effect: Effect::Stun, duration: 2, meta: None, tick: None}], Skill::Siphon => vec![CrypEffect {effect: Effect::Siphon, duration: 2, meta: None, tick: None}],
Skill::Taunt => vec![CrypEffect {effect: Effect::Taunt, duration: 2, meta: None, tick: None}], Skill::Sleep => vec![CrypEffect {effect: Effect::Stun, duration: 2, meta: None, tick: None}],
Skill::Triage => vec![CrypEffect {effect: Effect::Triage, duration: 2, meta: None, tick: None}], Skill::Snare => vec![CrypEffect {effect: Effect::Snare, duration: 2, meta: None, tick: None}],
Skill::Strangle => vec![CrypEffect {effect: Effect::Strangle, duration: 2, meta: None, tick: None}],
Skill::Stun => vec![CrypEffect {effect: Effect::Stun, duration: 2, meta: None, tick: None}],
Skill::Taunt => vec![CrypEffect {effect: Effect::Taunt, duration: 2, meta: None, tick: None}],
Skill::Triage => vec![CrypEffect {effect: Effect::Triage, duration: 2, meta: None, tick: None}],
//Unused //Unused
Skill::Injure => vec![CrypEffect {effect: Effect::Injured, duration: 2, meta: None, tick: None }], Skill::Injure => vec![CrypEffect {effect: Effect::Injured, 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));
} }
} }