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

wip

Browse Source
This commit is contained in:
Mashy 2019-05-24 15:06:29 +10:00
parent a20eaf12bc
commit 4ac0146b39
5 changed files with 293 additions and 166 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
server/src/cryp.rs
View File

@ -870,7 +870,7 @@ mod tests {
let mut cryp = Cryp::new() let mut cryp = Cryp::new()
.named(&"redboi".to_string()); .named(&"redboi".to_string());
cryp.learn_mut(Skill::Strike); cryp.learn_mut(Skill::StrikeI);
cryp.spec_add(Spec::GreenLifeI).unwrap(); cryp.spec_add(Spec::GreenLifeI).unwrap();
cryp.spec_add(Spec::RedDamageI).unwrap(); cryp.spec_add(Spec::RedDamageI).unwrap();
cryp.spec_add(Spec::RedDamageI).unwrap(); cryp.spec_add(Spec::RedDamageI).unwrap();

4
server/src/game.rs
View File

@ -936,7 +936,7 @@ mod tests {
.learn(Skill::TestBlock) .learn(Skill::TestBlock)
.learn(Skill::TestParry) .learn(Skill::TestParry)
.learn(Skill::TestSiphon) .learn(Skill::TestSiphon)
.learn(Skill::Amplify) .learn(Skill::AmplifyI)
.learn(Skill::Stun) .learn(Skill::Stun)
.learn(Skill::Block); .learn(Skill::Block);
@ -948,7 +948,7 @@ mod tests {
.learn(Skill::TestBlock) .learn(Skill::TestBlock)
.learn(Skill::TestParry) .learn(Skill::TestParry)
.learn(Skill::TestSiphon) .learn(Skill::TestSiphon)
.learn(Skill::Amplify) .learn(Skill::AmplifyI)
.learn(Skill::Stun) .learn(Skill::Stun)
.learn(Skill::Block); .learn(Skill::Block);

253
server/src/item.rs
View File

@ -46,17 +46,29 @@ pub enum Item {
GBSpeedI, GBSpeedI,
RBSpeedI, RBSpeedI,
Amplify, AmplifyI,
AmplifyII,
AmplifyIII,
Banish, Banish,
Blast, BlastI,
Chaos, BlastII,
Clutch, BlastIII,
ChaosI,
ChaosII,
ChaosIII,
ClutchI,
ClutchII,
ClutchIII,
Corrupt, Corrupt,
Curse, CurseI,
CurseII,
CurseIII,
Decay, Decay,
Hostility, Hostility,
Haste, Haste,
Heal, HealI,
HealII,
HealIII,
Hex, Hex,
Impurity, Impurity,
Invert, Invert,
@ -72,7 +84,7 @@ pub enum Item {
Sleep, Sleep,
Snare, Snare,
Strangle, Strangle,
Strike, StrikeI,
StrikeII, StrikeII,
StrikeIII, StrikeIII,
Siphon, Siphon,
@ -183,17 +195,27 @@ impl Item {
pub fn into_skill(&self) -> Option<Skill> { pub fn into_skill(&self) -> Option<Skill> {
match self { match self {
Item::Attack => Some(Skill::Attack), Item::Attack => Some(Skill::Attack),
Item::Amplify => Some(Skill::Amplify), Item::AmplifyI => Some(Skill::AmplifyI),
Item::AmplifyII => Some(Skill::AmplifyII),
Item::AmplifyIII => Some(Skill::AmplifyIII),
Item::Banish => Some(Skill::Banish), Item::Banish => Some(Skill::Banish),
Item::Blast => Some(Skill::Blast), Item::BlastI => Some(Skill::BlastI),
Item::BlastII => Some(Skill::BlastII),
Item::BlastIII => Some(Skill::BlastIII),
Item::Block => Some(Skill::Block), Item::Block => Some(Skill::Block),
Item::Buff => Some(Skill::Buff), Item::Buff => Some(Skill::Buff),
Item::Chaos => Some(Skill::Chaos), Item::ChaosI => Some(Skill::ChaosI),
Item::Curse => Some(Skill::Curse), Item::ChaosII => Some(Skill::ChaosII),
Item::ChaosIII => Some(Skill::ChaosIII),
Item::CurseI => Some(Skill::CurseI),
Item::CurseII => Some(Skill::CurseII),
Item::CurseIII => Some(Skill::CurseIII),
Item::Debuff => Some(Skill::Debuff), Item::Debuff => Some(Skill::Debuff),
Item::Decay => Some(Skill::Decay), Item::Decay => Some(Skill::Decay),
Item::Haste => Some(Skill::Haste), Item::Haste => Some(Skill::Haste),
Item::Heal => Some(Skill::Heal), Item::HealI => Some(Skill::HealI),
Item::HealII => Some(Skill::HealII),
Item::HealIII => Some(Skill::HealIII),
Item::Hex => Some(Skill::Hex), Item::Hex => Some(Skill::Hex),
Item::Hostility => Some(Skill::Hostility), Item::Hostility => Some(Skill::Hostility),
Item::Impurity => Some(Skill::Impurity), Item::Impurity => Some(Skill::Impurity),
@ -212,10 +234,12 @@ impl Item {
Item::Snare => Some(Skill::Snare), Item::Snare => Some(Skill::Snare),
Item::Strangle => Some(Skill::Strangle), Item::Strangle => Some(Skill::Strangle),
Item::Stun => Some(Skill::Stun), Item::Stun => Some(Skill::Stun),
Item::Strike => Some(Skill::Strike), Item::StrikeI => Some(Skill::StrikeI),
Item::StrikeII => Some(Skill::StrikeII), Item::StrikeII => Some(Skill::StrikeII),
Item::StrikeIII => Some(Skill::StrikeIII), Item::StrikeIII => Some(Skill::StrikeIII),
Item::Clutch => Some(Skill::Clutch), Item::ClutchI => Some(Skill::ClutchI),
Item::ClutchII => Some(Skill::ClutchII),
Item::ClutchIII => Some(Skill::ClutchIII),
Item::Taunt => Some(Skill::Taunt), Item::Taunt => Some(Skill::Taunt),
Item::Throw => Some(Skill::Throw), Item::Throw => Some(Skill::Throw),
Item::Corrupt => Some(Skill::Corrupt), Item::Corrupt => Some(Skill::Corrupt),
@ -319,7 +343,9 @@ impl Item {
Item::RBSpeedI => format!("Increases CRYP SPEED and provides COLOUR BONUSES"), Item::RBSpeedI => format!("Increases CRYP SPEED and provides COLOUR BONUSES"),
// Skills <- need to move effect mulltipliers into skills // Skills <- need to move effect mulltipliers into skills
Item::Amplify => format!("Increase red and blue power by {:?}%. Lasts {:?}T", Item::AmplifyI |
Item::AmplifyII |
Item::AmplifyIII => format!("Increase red and blue power by {:?}%. Lasts {:?}T",
self.into_skill().unwrap().effect().first().unwrap().get_multiplier() - 100, self.into_skill().unwrap().effect().first().unwrap().get_multiplier() - 100,
self.into_skill().unwrap().effect().first().unwrap().get_duration()), self.into_skill().unwrap().effect().first().unwrap().get_duration()),
@ -327,13 +353,19 @@ impl Item {
Banished cryps are immune to all skills and effects.", Banished cryps are immune to all skills and effects.",
self.into_skill().unwrap().effect().first().unwrap().get_duration()), self.into_skill().unwrap().effect().first().unwrap().get_duration()),
Item::Blast => format!("Deals blue damage {:?}% blue power.", self.into_skill().unwrap().multiplier()), Item::BlastI |
Item::BlastII |
Item::BlastIII => format!("Deals blue damage {:?}% blue power.", self.into_skill().unwrap().multiplier()),
Item::Chaos => format!( Item::ChaosI |
Item::ChaosII |
Item::ChaosIII => format!(
"Hits twice for red and blue damage. Damage is random 0 to 30% + {:?}% red and blue power.", "Hits twice for red and blue damage. Damage is random 0 to 30% + {:?}% red and blue power.",
self.into_skill().unwrap().multiplier()), self.into_skill().unwrap().multiplier()),
Item::Clutch => format!("Cryp cannot be KO'd while active. Item::ClutchI |
Item::ClutchII |
Item::ClutchIII => format!("Cryp cannot be KO'd while active.
Additionally provides immunity to disables."), Additionally provides immunity to disables."),
Item::Corrupt => format!( Item::Corrupt => format!(
@ -343,7 +375,9 @@ impl Item {
self.into_skill().unwrap().effect().last().unwrap().get_duration()), self.into_skill().unwrap().effect().last().unwrap().get_duration()),
Item::Curse => format!( Item::CurseI |
Item::CurseII |
Item::CurseIII => format!(
"Increases red and blue damage taken by {:?}%. Lasts {:?}T", "Increases red and blue damage taken by {:?}%. Lasts {:?}T",
self.into_skill().unwrap().effect().first().unwrap().get_multiplier() - 100, self.into_skill().unwrap().effect().first().unwrap().get_multiplier() - 100,
self.into_skill().unwrap().effect().first().unwrap().get_duration()), self.into_skill().unwrap().effect().first().unwrap().get_duration()),
@ -367,7 +401,9 @@ impl Item {
"% Speed as Red Damage", "% Speed as Red Damage",
self.into_skill().unwrap().effect().first().unwrap().get_duration()), self.into_skill().unwrap().effect().first().unwrap().get_duration()),
Item::Heal => format!("Heals for {:?}% green power.", self.into_skill().unwrap().multiplier()), Item::HealI |
Item::HealII |
Item::HealIII => format!("Heals for {:?}% green power.", self.into_skill().unwrap().multiplier()),
Item::Hex => format!("Blue based skill that applies Hex for {:?}T. \ Item::Hex => format!("Blue based skill that applies Hex for {:?}T. \
Hexed targets cannot cast any skills.", Hexed targets cannot cast any skills.",
@ -440,12 +476,8 @@ impl Item {
self.into_skill().unwrap().multiplier(), self.into_skill().unwrap().multiplier(),
self.into_skill().unwrap().effect().first().unwrap().get_duration()), self.into_skill().unwrap().effect().first().unwrap().get_duration()),
Item::Strike => format!( Item::StrikeI |
"Hits at maximum speed dealing red damage {:?}% red power", Item::StrikeII |
self.into_skill().unwrap().multiplier()),
Item::StrikeII => format!(
"Hits at maximum speed dealing red damage {:?}% red power",
self.into_skill().unwrap().multiplier()),
Item::StrikeIII => format!( Item::StrikeIII => format!(
"Hits at maximum speed dealing red damage {:?}% red power", "Hits at maximum speed dealing red damage {:?}% red power",
self.into_skill().unwrap().multiplier()), self.into_skill().unwrap().multiplier()),
@ -481,22 +513,28 @@ 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], //To be impl Item::Scatter => vec![Item::Buff, Item::Blue, Item::Blue],
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::Amplify => vec![Item::Buff, Item::Red, Item::Blue], // Some flavour Item::AmplifyI => vec![Item::Buff, Item::Red, Item::Blue],
Item::AmplifyII => vec![Item::AmplifyI, Item::AmplifyI, Item::AmplifyI],
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::Purge => vec![Item::Debuff, Item::Green, Item::Green], // Needs flavour
Item::Silence => vec![Item::Debuff, Item::Blue, Item::Blue], Item::Silence => vec![Item::Debuff, Item::Blue, Item::Blue],
Item::Curse => vec![Item::Debuff, Item::Red, Item::Green], // To be reworked Item::CurseI => vec![Item::Debuff, Item::Red, Item::Green],
Item::CurseII => vec![Item::CurseI, Item::CurseI, Item::CurseI],
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::Invert => vec![Item::Debuff, Item::Red, Item::Blue],
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::Purify => vec![Item::Block, Item::Green, Item::Green],
Item::Corrupt => vec![Item::Block, Item::Blue, Item::Blue], Item::Corrupt => vec![Item::Block, Item::Blue, Item::Blue],
Item::Clutch => 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::ClutchIII => vec![Item::ClutchII, Item::ClutchII, Item::ClutchII],
Item::Reflect => vec![Item::Block, Item::Green, Item::Blue], Item::Reflect => vec![Item::Block, Item::Green, Item::Blue],
Item::Recharge => vec![Item::Block, Item::Red, Item::Blue], Item::Recharge => vec![Item::Block, Item::Red, Item::Blue],
@ -507,15 +545,20 @@ impl Item {
Item::Hex => vec![Item::Stun, Item::Green, Item::Blue], Item::Hex => vec![Item::Stun, Item::Green, Item::Blue],
Item::Banish => vec![Item::Stun, Item::Red, Item::Blue], Item::Banish => vec![Item::Stun, Item::Red, Item::Blue],
Item::Strike => vec![Item::Attack, Item::Red, Item::Red], Item::StrikeI => vec![Item::Attack, Item::Red, Item::Red],
Item::StrikeII => vec![Item::Strike, Item::Strike, Item::Strike], Item::StrikeII => vec![Item::StrikeI, Item::StrikeI, Item::StrikeI],
Item::StrikeIII => vec![Item::StrikeII, Item::StrikeII, Item::StrikeII], Item::StrikeIII => vec![Item::StrikeII, Item::StrikeII, Item::StrikeII],
Item::HealI => vec![Item::Attack, Item::Green, Item::Green],
Item::Heal => vec![Item::Attack, Item::Green, Item::Green], Item::HealII => vec![Item::HealI, Item::HealI, Item::HealI],
Item::Blast => vec![Item::Attack, Item::Blue, Item::Blue], Item::HealIII => vec![Item::HealII, Item::HealII, Item::HealII],
Item::BlastI => vec![Item::Attack, Item::Blue, Item::Blue],
Item::BlastII => vec![Item::BlastI, Item::BlastI, Item::BlastI],
Item::BlastIII => vec![Item::BlastII, Item::BlastII, Item::BlastII],
Item::Slay => vec![Item::Attack, Item::Red, Item::Green], Item::Slay => vec![Item::Attack, Item::Red, Item::Green],
Item::Siphon => vec![Item::Attack, Item::Green, Item::Blue], Item::Siphon => vec![Item::Attack, Item::Green, Item::Blue],
Item::Chaos => vec![Item::Attack, Item::Red, Item::Blue], Item::ChaosI => vec![Item::Attack, Item::Red, Item::Blue],
Item::ChaosII => vec![Item::ChaosI, Item::ChaosI, Item::ChaosI],
Item::ChaosIII => vec![Item::ChaosII, Item::ChaosII, Item::ChaosII],
Item::RedDamageI => vec![Item::Damage, Item::Red, Item::Red], Item::RedDamageI => vec![Item::Damage, Item::Red, Item::Red],
Item::GreenDamageI => vec![Item::Damage, Item::Green, Item::Green], Item::GreenDamageI => vec![Item::Damage, Item::Green, Item::Green],
@ -546,20 +589,32 @@ impl Item {
impl From<Skill> for Item { impl From<Skill> for Item {
fn from(skill: Skill) -> Item { fn from(skill: Skill) -> Item {
match skill { match skill {
Skill::Amplify => Item::Amplify, Skill::AmplifyI => Item::AmplifyI,
Skill::AmplifyII => Item::AmplifyII,
Skill::AmplifyIII => Item::AmplifyIII,
Skill::Attack => Item::Attack, Skill::Attack => Item::Attack,
Skill::Banish => Item::Banish, Skill::Banish => Item::Banish,
Skill::Blast => Item::Blast, Skill::BlastI => Item::BlastI,
Skill::BlastII => Item::BlastII,
Skill::BlastIII => Item::BlastIII,
Skill::Block => Item::Block, Skill::Block => Item::Block,
Skill::Buff => Item::Buff, Skill::Buff => Item::Buff,
Skill::Chaos => Item::Chaos, Skill::ChaosI => Item::ChaosI,
Skill::Curse => Item::Curse, Skill::ChaosII => Item::ChaosII,
Skill::Clutch => Item::Clutch, Skill::ChaosIII => Item::ChaosIII,
Skill::ClutchI => Item::ClutchI,
Skill::ClutchII => Item::ClutchII,
Skill::ClutchIII => Item::ClutchIII,
Skill::CurseI => Item::CurseI,
Skill::CurseII => Item::CurseII,
Skill::CurseIII => Item::CurseIII,
Skill::Decay => Item::Decay, Skill::Decay => Item::Decay,
Skill::Debuff => Item::Debuff, Skill::Debuff => Item::Debuff,
Skill::Haste => Item::Haste, Skill::Haste => Item::Haste,
Skill::Hostility => Item::Hostility, Skill::Hostility => Item::Hostility,
Skill::Heal => Item::Heal, Skill::HealI => Item::HealI,
Skill::HealII => Item::HealII,
Skill::HealIII => Item::HealIII,
Skill::Hex => Item::Hex, Skill::Hex => Item::Hex,
Skill::Impurity => Item::Impurity, Skill::Impurity => Item::Impurity,
Skill::Invert => Item::Invert, Skill::Invert => Item::Invert,
@ -576,7 +631,7 @@ impl From<Skill> for Item {
Skill::Sleep => Item::Sleep, Skill::Sleep => Item::Sleep,
Skill::Snare => Item::Snare, Skill::Snare => Item::Snare,
Skill::Strangle => Item::Strangle, Skill::Strangle => Item::Strangle,
Skill::Strike => Item::Strike, Skill::StrikeI => Item::StrikeI,
Skill::StrikeII => Item::StrikeII, Skill::StrikeII => Item::StrikeII,
Skill::StrikeIII => Item::StrikeIII, Skill::StrikeIII => Item::StrikeIII,
Skill::Stun => Item::Stun, Skill::Stun => Item::Stun,
@ -641,64 +696,76 @@ pub struct Combo {
pub fn get_combos() -> Vec<Combo> { 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 }, //To be impl Combo { components: Item::Scatter.combo(), item: Item::Scatter },
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::Amplify.combo(), item: Item::Amplify }, // Some flavour Combo { components: Item::AmplifyI.combo(), item: Item::AmplifyI },
Combo { components: Item::AmplifyII.combo(), item: Item::AmplifyII },
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::Purge.combo(), item: Item::Purge }, // Needs flavour
Combo { components: Item::Silence.combo(), item: Item::Silence }, Combo { components: Item::Silence.combo(), item: Item::Silence },
Combo { components: Item::Curse.combo(), item: Item::Curse }, // To be reworked Combo { components: Item::CurseI.combo(), item: Item::CurseI },
Combo { components: Item::Decay.combo(), item: Item::Decay }, Combo { components: Item::CurseII.combo(), item: Item::CurseII },
Combo { components: Item::Invert.combo(), item: Item::Invert }, Combo { components: Item::CurseIII.combo(), item: Item::CurseIII },
Combo { components: Item::Decay.combo(), item: Item::Decay },
Combo { components: Item::Invert.combo(), item: Item::Invert },
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::Purify.combo(), item: Item::Purify },
Combo { components: Item::Corrupt.combo(), item: Item::Corrupt }, Combo { components: Item::Corrupt.combo(), item: Item::Corrupt },
Combo { components: Item::Clutch.combo(), item: Item::Clutch }, Combo { components: Item::ClutchI.combo(), item: Item::ClutchI },
Combo { components: Item::Reflect.combo(), item: Item::Reflect }, Combo { components: Item::ClutchII.combo(), item: Item::ClutchII },
Combo { components: Item::Recharge.combo(), item: Item::Recharge }, 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::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::Ruin.combo(), item: Item::Ruin },
Combo { components: Item::Throw.combo(), item: Item::Throw }, Combo { components: Item::Throw.combo(), item: Item::Throw },
Combo { components: Item::Hex.combo(), item: Item::Hex }, Combo { components: Item::Hex.combo(), item: Item::Hex },
Combo { components: Item::Banish.combo(), item: Item::Banish }, Combo { components: Item::Banish.combo(), item: Item::Banish },
Combo { components: Item::Strike.combo(), item: Item::Strike }, Combo { components: Item::StrikeI.combo(), item: Item::StrikeI },
Combo { components: Item::StrikeII.combo(), item: Item::StrikeII }, Combo { components: Item::StrikeII.combo(), item: Item::StrikeII },
Combo { components: Item::StrikeIII.combo(), item: Item::StrikeIII }, Combo { components: Item::StrikeIII.combo(), item: Item::StrikeIII },
Combo { components: Item::Heal.combo(), item: Item::Heal }, Combo { components: Item::HealI.combo(), item: Item::HealI },
Combo { components: Item::Blast.combo(), item: Item::Blast }, Combo { components: Item::HealII.combo(), item: Item::HealII },
Combo { components: Item::Slay.combo(), item: Item::Slay }, Combo { components: Item::HealIII.combo(), item: Item::HealIII },
Combo { components: Item::Siphon.combo(), item: Item::Siphon }, Combo { components: Item::BlastI.combo(), item: Item::BlastI },
Combo { components: Item::Chaos.combo(), item: Item::Chaos }, Combo { components: Item::BlastII.combo(), item: Item::BlastII },
Combo { components: Item::BlastIII.combo(), item: Item::BlastIII },
Combo { components: Item::Slay.combo(), item: Item::Slay },
Combo { components: Item::Siphon.combo(), item: Item::Siphon },
Combo { components: Item::ChaosI.combo(), item: Item::ChaosI },
Combo { components: Item::ChaosII.combo(), item: Item::ChaosII },
Combo { components: Item::ChaosIII.combo(), item: Item::ChaosIII },
Combo { components: Item::RedDamageI.combo(), item: Item::RedDamageI }, Combo { components: Item::RedDamageI.combo(), item: Item::RedDamageI },
Combo { components: Item::GreenDamageI.combo(), item: Item::GreenDamageI }, Combo { components: Item::GreenDamageI.combo(), item: Item::GreenDamageI },
Combo { components: Item::BlueDamageI.combo(), item: Item::BlueDamageI }, Combo { components: Item::BlueDamageI.combo(), item: Item::BlueDamageI },
Combo { components: Item::GRDI.combo(), item: Item::GRDI }, Combo { components: Item::GRDI.combo(), item: Item::GRDI },
Combo { components: Item::GBDI.combo(), item: Item::GBDI }, Combo { components: Item::GBDI.combo(), item: Item::GBDI },
Combo { components: Item::RBDI.combo(), item: Item::RBDI }, Combo { components: Item::RBDI.combo(), item: Item::RBDI },
Combo { components: Item::RedLifeI.combo(), item: Item::RedLifeI }, Combo { components: Item::RedLifeI.combo(), item: Item::RedLifeI },
Combo { components: Item::GreenLifeI.combo(), item: Item::GreenLifeI }, Combo { components: Item::GreenLifeI.combo(), item: Item::GreenLifeI },
Combo { components: Item::BlueLifeI.combo(), item: Item::BlueLifeI }, Combo { components: Item::BlueLifeI.combo(), item: Item::BlueLifeI },
Combo { components: Item::GRLI.combo(), item: Item::GRLI }, Combo { components: Item::GRLI.combo(), item: Item::GRLI },
Combo { components: Item::GBLI.combo(), item: Item::GBLI }, Combo { components: Item::GBLI.combo(), item: Item::GBLI },
Combo { components: Item::RBLI.combo(), item: Item::RBLI }, Combo { components: Item::RBLI.combo(), item: Item::RBLI },
Combo { components: Item::RedSpeedI.combo(), item: Item::RedSpeedI }, Combo { components: Item::RedSpeedI.combo(), item: Item::RedSpeedI },
Combo { components: Item::GreenSpeedI.combo(), item: Item::GreenSpeedI }, Combo { components: Item::GreenSpeedI.combo(), item: Item::GreenSpeedI },
Combo { components: Item::BlueSpeedI.combo(), item: Item::BlueSpeedI }, Combo { components: Item::BlueSpeedI.combo(), item: Item::BlueSpeedI },
Combo { components: Item::GRSpeedI.combo(), item: Item::GRSpeedI }, Combo { components: Item::GRSpeedI.combo(), item: Item::GRSpeedI },
Combo { components: Item::GBSpeedI.combo(), item: Item::GBSpeedI }, Combo { components: Item::GBSpeedI.combo(), item: Item::GBSpeedI },
Combo { components: Item::RBSpeedI.combo(), item: Item::RBSpeedI }, Combo { components: Item::RBSpeedI.combo(), item: Item::RBSpeedI },
]; ];
@ -759,7 +826,7 @@ mod tests {
#[test] #[test]
fn item_components_test() { fn item_components_test() {
assert_eq!(Item::Strike.components(), vec![Item::Red, Item::Red, Item::Attack]); assert_eq!(Item::StrikeI.components(), vec![Item::Red, Item::Red, Item::Attack]);
assert_eq!(Item::StrikeII.components(), vec![ assert_eq!(Item::StrikeII.components(), vec![
Item::Red, Item::Red, Item::Attack, Item::Red, Item::Red, Item::Attack,
Item::Red, Item::Red, Item::Attack, Item::Red, Item::Red, Item::Attack,

192
server/src/skill.rs
View File

@ -76,8 +76,8 @@ pub fn resolve(skill: Skill, source: &mut Cryp, target: &mut Cryp, mut resolutio
match skill { match skill {
Skill::Attack | Skill::Attack |
Skill::Slay | Skill::Slay |
Skill::Chaos | Skill::ChaosI |
Skill::Strike => { Skill::StrikeI => {
let amount = source.speed().pct(Skill::HasteStrike.multiplier()); let amount = source.speed().pct(Skill::HasteStrike.multiplier());
target.deal_red_damage(Skill::HasteStrike, amount) target.deal_red_damage(Skill::HasteStrike, amount)
.into_iter() .into_iter()
@ -89,8 +89,8 @@ pub fn resolve(skill: Skill, source: &mut Cryp, target: &mut Cryp, mut resolutio
if source.affected(Effect::Impurity) { if source.affected(Effect::Impurity) {
match skill { match skill {
Skill::Blast | Skill::BlastI |
Skill::Chaos | Skill::ChaosI |
Skill::Siphon => { Skill::Siphon => {
let amount = source.green_damage().pct(Skill::ImpureBlast.multiplier()); let amount = source.green_damage().pct(Skill::ImpureBlast.multiplier());
target.deal_blue_damage(Skill::ImpureBlast, amount) target.deal_blue_damage(Skill::ImpureBlast, amount)
@ -112,24 +112,38 @@ pub fn resolve(skill: Skill, source: &mut Cryp, target: &mut Cryp, mut resolutio
// } // }
resolutions = match skill { resolutions = match skill {
Skill::Amplify => amplify(source, target, resolutions, skill), // increase magic damage Skill::AmplifyI => amplify(source, target, resolutions, skill),
Skill::AmplifyII => 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::Blast => blast(source, target, resolutions, skill), Skill::BlastI => blast(source, target, resolutions, skill),
Skill::BlastII => 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::Chaos => chaos(source, target, resolutions, skill), Skill::ChaosI => chaos(source, target, resolutions, skill),
Skill::Clutch => clutch(source, target, resolutions, skill), Skill::ChaosII => 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::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::Curse => curse(source, target, resolutions, skill), Skill::CurseI => curse(source, target, resolutions, skill),
Skill::CurseII => 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::HasteStrike => panic!("haste strike should not be caste"),
Skill::Heal => heal(source, target, resolutions, skill), Skill::HealI => heal(source, target, resolutions, skill),
Skill::Hex => hex(source, target, resolutions, skill), Skill::HealII => 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::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::ImpureBlast => panic!("impure blast should not be caste"),
@ -151,11 +165,9 @@ pub fn resolve(skill: Skill, source: &mut Cryp, target: &mut Cryp, mut resolutio
Skill::Snare => snare(source, target, resolutions, skill), Skill::Snare => snare(source, target, resolutions, skill),
Skill::Strangle => strangle(source, target, resolutions, skill), Skill::Strangle => strangle(source, target, resolutions, skill),
Skill::StrangleTick => strangle_tick(source, target, resolutions, skill), Skill::StrangleTick => strangle_tick(source, target, resolutions, skill),
Skill::StrikeI => strike(source, target, resolutions, skill),
Skill::Strike => strike(source, target, resolutions, skill), Skill::StrikeII => strike(source, target, resolutions, skill),
Skill::StrikeII => strike(source, target, resolutions, skill), Skill::StrikeIII => strike(source, target, resolutions, skill),
Skill::StrikeIII => strike(source, target, resolutions, skill),
Skill::Stun => stun(source, target, resolutions, skill), Skill::Stun => stun(source, target, resolutions, skill),
Skill::Taunt => taunt(source, target, resolutions, skill), Skill::Taunt => taunt(source, target, resolutions, skill),
Skill::Throw => throw(source, target, resolutions, skill), // no damage stun, adds vulnerable Skill::Throw => throw(source, target, resolutions, skill), // no damage stun, adds vulnerable
@ -390,7 +402,9 @@ impl Effect {
Effect::Banish => true, Effect::Banish => true,
Effect::Clutch => [ Effect::Clutch => [
Skill::Stun, Skill::Stun,
Skill::Hex, Skill::HexI,
Skill::HexII,
Skill::HexIII,
Skill::Silence, Skill::Silence,
Skill::Ruin, Skill::Ruin,
Skill::Strangle, Skill::Strangle,
@ -544,19 +558,31 @@ pub enum Skill {
// Evade, // actively evade // Evade, // actively evade
// Nightmare, // Nightmare,
// Sleep, // Sleep,
Amplify, AmplifyI,
AmplifyII,
AmplifyIII,
Banish, Banish,
Blast, BlastI,
Chaos, BlastII,
Clutch, BlastIII,
ChaosI,
ChaosII,
ChaosIII,
ClutchI,
ClutchII,
ClutchIII,
Corrupt, Corrupt,
CorruptionTick, CorruptionTick,
Curse, CurseI,
CurseII,
CurseIII,
Decay, // dot Decay, // dot
DecayTick, // dot DecayTick, // dot
Haste, Haste,
HasteStrike, HasteStrike,
Heal, HealI,
HealII,
HealIII,
Hex, Hex,
Hostility, Hostility,
ImpureBlast, ImpureBlast,
@ -579,7 +605,7 @@ pub enum Skill {
Snare, Snare,
Strangle, Strangle,
StrangleTick, StrangleTick,
Strike, StrikeI,
StrikeII, StrikeII,
StrikeIII, StrikeIII,
Taunt, Taunt,
@ -603,39 +629,44 @@ impl Skill {
// Attack Base // Attack Base
Skill::Attack => 80, // Base Skill::Attack => 80, // Base
Skill::Blast => 110, // BB Skill::BlastI => 110, // BB
Skill::Chaos => 40, // BR Skill::BlastII => 130, // BB
Skill::Heal => 130, //GG Skill::BlastIII => 150, // BB
Skill::ChaosI => 40, // BR
Skill::ChaosII => 50, // BR
Skill::ChaosIII => 60, // BR
Skill::HealI => 130, //GG
Skill::HealII => 160, //GG
Skill::HealIII => 200, //GG
Skill::SiphonTick => 40, // GB Skill::SiphonTick => 40, // GB
Skill::Slay => 70, // RG Skill::Slay => 70, // RG
Skill::Strike => 90, //RR Skill::StrikeI => 90, //RR
Skill::StrikeII => 110, Skill::StrikeII => 110,
Skill::StrikeIII => 130, Skill::StrikeIII => 130,
// Block Base // Block Base
Skill::CorruptionTick => 80, Skill::CorruptionTick => 80,
Skill::Purify => 45, //Green dmg (heal)
Skill::Recharge => 85, //restore red and blue life (heal)
Skill::Reflect => 45, //restore blue life (heal)
Skill::Parry => 110, Skill::Parry => 110,
Skill::Riposte => 70, Skill::Riposte => 70,
Skill::Purify => 45, //Green dmg (heal)
Skill::Reflect => 45, //restore blue life (heal)
Skill::Recharge => 85, //restore red and blue life (heal)
// Stun Base // Stun Base
Skill::Sleep => 240, //Green dmg (heal) Skill::Sleep => 240, //Green dmg (heal)
Skill::StrangleTick => 65, Skill::StrangleTick => 65,
// Debuff Base // Debuff Base
Skill::DecayTick => 25,
Skill::Silence => 55, // Deals more per blue skill on target Skill::Silence => 55, // 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
Skill::DecayTick => 25,
// Buff base // Buff base
Skill::ImpureBlast => 25, Skill::ImpureBlast => 25,
Skill::HasteStrike => 30, Skill::HasteStrike => 30,
Skill::Scatter => 140,
Skill::Taunt => 80, Skill::Taunt => 80,
Skill::TriageTick => 75, Skill::TriageTick => 75,
Skill::Scatter => 140,
_ => 100, _ => 100,
} }
@ -644,7 +675,9 @@ impl Skill {
pub fn effect(&self) -> Vec<CrypEffect> { pub fn effect(&self) -> Vec<CrypEffect> {
match self { match self {
// Modifiers // Modifiers
Skill::Amplify => 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::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 }],
@ -652,13 +685,19 @@ impl Skill {
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::Clutch => 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::Curse => vec![CrypEffect {effect: Effect::Curse, duration: 2, meta: Some(EffectMeta::Multiplier(150)), 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::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::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 }],
Skill::Hex => vec![CrypEffect {effect: Effect::Hex, duration: 2, meta: None, tick: None}], Skill::HexI => vec![CrypEffect {effect: Effect::Hex, duration: 2, meta: None, tick: None}],
Skill::HexII => vec![CrypEffect {effect: Effect::Hex, duration: 3, meta: None, tick: None}],
Skill::HexIII => vec![CrypEffect {effect: Effect::Hex, duration: 4, meta: None, tick: None}],
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 }],
@ -696,7 +735,7 @@ impl Skill {
Skill::Attack => None, Skill::Attack => None,
Skill::Debuff => Some(1), Skill::Debuff => Some(1),
Skill::Buff => None, Skill::Buff => None,
Skill::Strike => None, Skill::StrikeI => None,
Skill::StrikeII => None, Skill::StrikeII => None,
Skill::StrikeIII => None, Skill::StrikeIII => None,
Skill::Block => None, // reduce damage Skill::Block => None, // reduce damage
@ -704,13 +743,21 @@ impl Skill {
Skill::Riposte => None, // used on parry Skill::Riposte => None, // used on parry
Skill::Snare => Some(2), Skill::Snare => Some(2),
Skill::Stun => Some(2), Skill::Stun => Some(2),
Skill::Heal => None, Skill::HealI => None,
Skill::HealII => None,
Skill::HealIII => None,
Skill::Triage => None, // hot Skill::Triage => None, // hot
Skill::TriageTick => None, Skill::TriageTick => None,
Skill::Throw => Some(1), // no damage stun, adds vulnerable Skill::Throw => Some(1), // no damage stun, adds vulnerable
Skill::Blast => None, Skill::BlastI => None,
Skill::Chaos => None, Skill::BlastII => None,
Skill::Amplify => Some(1), Skill::BlastIII => None,
Skill::ChaosI => None,
Skill::ChaosII => None,
Skill::ChaosIII => None,
Skill::AmplifyI => Some(1),
Skill::AmplifyII => 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::Invert => Some(2),
@ -718,13 +765,16 @@ impl Skill {
Skill::DecayTick => None, Skill::DecayTick => None,
Skill::Siphon => None, Skill::Siphon => None,
Skill::SiphonTick => None, Skill::SiphonTick => None,
Skill::Curse => Some(1), Skill::CurseI => Some(1),
Skill::CurseII => Some(1),
Skill::CurseIII => Some(1),
Skill::Scatter => Some(2), Skill::Scatter => Some(2),
Skill::Silence => Some(2), Skill::Silence => Some(2),
Skill::Purify => None, Skill::Purify => None,
Skill::Purge => None, Skill::Purge => None,
Skill::Banish => Some(1), Skill::Banish => Some(1),
Skill::Hex => Some(1), Skill::HexI => Some(1),
Skill::HexII => Some(1),
Skill::Haste => Some(2), Skill::Haste => Some(2),
Skill::HasteStrike => None, // Used in haste Skill::HasteStrike => None, // Used in haste
@ -736,7 +786,9 @@ impl Skill {
Skill::Strangle => Some(2), Skill::Strangle => Some(2),
Skill::StrangleTick => None, Skill::StrangleTick => None,
Skill::Clutch => Some(2), Skill::ClutchI => Some(1),
Skill::ClutchII => Some(2),
Skill::ClutchIII => Some(3),
Skill::Taunt => Some(2), Skill::Taunt => Some(2),
Skill::Injure => Some(2), Skill::Injure => Some(2),
@ -790,9 +842,9 @@ impl Skill {
Skill::TestParry => 10, Skill::TestParry => 10,
Skill::TestSiphon => 10, Skill::TestSiphon => 10,
Skill::Strike => u8::max_value(), Skill::StrikeI => u8::max_value(),
Skill::StrikeII => Skill::Strike.speed(), Skill::StrikeII => Skill::StrikeI.speed(),
Skill::StrikeIII => Skill::Strike.speed(), Skill::StrikeIII => Skill::StrikeI.speed(),
Skill::SiphonTick => Skill::Siphon.speed(), Skill::SiphonTick => Skill::Siphon.speed(),
Skill::DecayTick => Skill::Decay.speed(), Skill::DecayTick => Skill::Decay.speed(),
@ -813,13 +865,15 @@ impl Skill {
pub fn self_targeting(&self) -> bool { pub fn self_targeting(&self) -> bool {
match self { match self {
Skill::Block => true, Skill::Block |
Skill::Parry => true, Skill::Parry |
Skill::Clutch => true, Skill::ClutchI |
Skill::Corrupt => true, Skill::ClutchII |
Skill::ClutchIII |
Skill::TestBlock => true, Skill::Corrupt |
Skill::TestBlock |
Skill::TestParry => true, Skill::TestParry => true,
_ => false, _ => false,
} }
} }
@ -828,17 +882,23 @@ impl Skill {
let mut rng = thread_rng(); let mut rng = thread_rng();
match self { match self {
Skill::Heal | Skill::HealI |
Skill::HealII |
Skill::HealIII |
Skill::Triage | Skill::Triage |
Skill::Purify | Skill::Purify |
Skill::Parry | Skill::Parry |
Skill::Clutch | Skill::ClutchI |
Skill::ClutchII |
Skill::ClutchIII |
Skill::Scatter | Skill::Scatter |
Skill::Recharge | Skill::Recharge |
Skill::Reflect | Skill::Reflect |
Skill::Haste | Skill::Haste |
Skill::Invert | Skill::Invert |
Skill::Amplify | Skill::AmplifyI |
Skill::AmplifyII |
Skill::AmplifyIII |
Skill::Hostility | Skill::Hostility |
Skill::Corrupt | Skill::Corrupt |
Skill::Block => true, Skill::Block => true,
@ -1360,15 +1420,15 @@ mod tests {
fn heal_test() { fn heal_test() {
let mut x = Cryp::new() let mut x = Cryp::new()
.named(&"muji".to_string()) .named(&"muji".to_string())
.learn(Skill::Heal); .learn(Skill::HealI);
let mut y = Cryp::new() let mut y = Cryp::new()
.named(&"camel".to_string()) .named(&"camel".to_string())
.learn(Skill::Heal); .learn(Skill::HealI);
x.deal_red_damage(Skill::Attack, 5); x.deal_red_damage(Skill::Attack, 5);
heal(&mut y, &mut x, vec![], Skill::Heal); heal(&mut y, &mut x, vec![], Skill::HealI);
} }
#[test] #[test]
@ -1422,7 +1482,7 @@ mod tests {
x.red_damage.force(10000000000000); // multiplication of int max will cause overflow x.red_damage.force(10000000000000); // multiplication of int max will cause overflow
clutch(&mut y.clone(), &mut y, vec![], Skill::Clutch); clutch(&mut y.clone(), &mut y, vec![], Skill::ClutchI);
assert!(y.affected(Effect::Clutch)); assert!(y.affected(Effect::Clutch));
let mut results = hex(&mut x, &mut y, vec![], Skill::Hex); let mut results = hex(&mut x, &mut y, vec![], Skill::Hex);
@ -1451,7 +1511,7 @@ mod tests {
.named(&"camel".to_string()); .named(&"camel".to_string());
resolve(Skill::Injure, &mut x, &mut y, vec![]); resolve(Skill::Injure, &mut x, &mut y, vec![]);
assert!(y.immune(Skill::Heal).is_some()); assert!(y.immune(Skill::HealI).is_some());
// resolutions = heal(&mut y.clone(), &mut y, resolutions); // resolutions = heal(&mut y.clone(), &mut y, resolutions);
} }
@ -1596,7 +1656,7 @@ mod tests {
y.blue_life.force(50); y.blue_life.force(50);
y.deal_red_damage(Skill::Attack, 5); y.deal_red_damage(Skill::Attack, 5);
y.deal_blue_damage(Skill::Blast, 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::Recharge);
@ -1628,7 +1688,7 @@ mod tests {
x.blue_damage.force(50); x.blue_damage.force(50);
amplify(&mut x.clone(), &mut x, vec![], Skill::Amplify); amplify(&mut x.clone(), &mut x, vec![], Skill::AmplifyI);
assert!(x.effects.iter().any(|e| e.effect == Effect::Amplify)); assert!(x.effects.iter().any(|e| e.effect == Effect::Amplify));
assert_eq!(x.blue_damage(), 75); assert_eq!(x.blue_damage(), 75);
} }

6
server/src/vbox.rs
View File

@ -200,7 +200,7 @@ mod tests {
let mut vbox = Vbox::new(); let mut vbox = Vbox::new();
vbox.bound = vec![Item::Attack, Item::Green, Item::Green]; vbox.bound = vec![Item::Attack, Item::Green, Item::Green];
vbox.combine(vec![1,2,0]).unwrap(); vbox.combine(vec![1,2,0]).unwrap();
assert_eq!(vbox.bound[0], Item::Heal); assert_eq!(vbox.bound[0], Item::HealI);
} }
#[test] #[test]
@ -218,14 +218,14 @@ mod tests {
#[test] #[test]
fn reclaim_test() { fn reclaim_test() {
let mut vbox = Vbox::new(); let mut vbox = Vbox::new();
vbox.bound = vec![Item::Strike]; vbox.bound = vec![Item::StrikeI];
vbox.reclaim(0).unwrap(); vbox.reclaim(0).unwrap();
assert_eq!(vbox.bits, 22); assert_eq!(vbox.bits, 22);
} }
#[test] #[test]
fn colours_count_test() { fn colours_count_test() {
let strike = Item::Strike; let strike = Item::StrikeI;
let mut count = Colours::new(); let mut count = Colours::new();
strike.colours(&mut count); strike.colours(&mut count);