From 33f4cfa525cd577b15070ada1f012474ee079afb Mon Sep 17 00:00:00 2001 From: ntr Date: Sat, 25 May 2019 16:04:52 +1000 Subject: [PATCH] damage -> power --- server/src/construct.rs | 104 +++++++++++++++--------------- server/src/game.rs | 4 +- server/src/item.rs | 138 ++++++++++++++++++++-------------------- server/src/skill.rs | 70 ++++++++++---------- server/src/spec.rs | 32 +++++----- server/src/vbox.rs | 2 +- 6 files changed, 174 insertions(+), 176 deletions(-) diff --git a/server/src/construct.rs b/server/src/construct.rs index 9c29721d..58e37f68 100644 --- a/server/src/construct.rs +++ b/server/src/construct.rs @@ -107,11 +107,11 @@ pub enum Stat { Int, GreenLife, Speed, - RedDamage, + RedPower, + BluePower, + GreenPower, RedDamageTaken, - BlueDamage, BlueDamageTaken, - GreenDamage, GreenDamageTaken, RedLife, BlueLife, @@ -182,11 +182,11 @@ pub struct ConstructRecover { pub struct Construct { pub id: Uuid, pub account: Uuid, - pub red_damage: ConstructStat, + pub red_power: ConstructStat, pub red_life: ConstructStat, pub blue_life: ConstructStat, - pub blue_damage: ConstructStat, - pub green_damage: ConstructStat, + pub blue_power: ConstructStat, + pub green_power: ConstructStat, pub speed: ConstructStat, pub green_life: ConstructStat, pub evasion: ConstructStat, @@ -203,11 +203,11 @@ impl Construct { return Construct { id, account: id, - red_damage: ConstructStat { base: 256, value: 256, max: 256, stat: Stat::RedDamage }, + red_power: ConstructStat { base: 256, value: 256, max: 256, stat: Stat::RedPower }, red_life: ConstructStat { base: 0, value: 0, max: 0, stat: Stat::RedLife }, - blue_damage: ConstructStat { base: 256, value: 256, max: 256, stat: Stat::BlueDamage }, + blue_power: ConstructStat { base: 256, value: 256, max: 256, stat: Stat::BluePower }, blue_life: ConstructStat { base: 0, value: 0, max: 0, stat: Stat::BlueLife }, - green_damage: ConstructStat { base: 256, value: 256, max: 256, stat: Stat::GreenDamage }, + green_power: ConstructStat { base: 256, value: 256, max: 256, stat: Stat::GreenPower }, green_life: ConstructStat { base: 1024, value: 1024, max: 1024, stat: Stat::GreenLife }, speed: ConstructStat { base: 128, value: 128, max: 128, stat: Stat::Speed }, evasion: ConstructStat { base: 0, value: 0, max: 0, stat: Stat::Evasion }, @@ -276,13 +276,13 @@ impl Construct { pub fn apply_modifiers(&mut self, player_colours: &Colours) -> &mut Construct { self.specs.sort_unstable(); - self.red_damage.recalculate(&self.specs, &self.colours, player_colours); + self.red_power.recalculate(&self.specs, &self.colours, player_colours); self.red_life.recalculate(&self.specs, &self.colours, player_colours); - self.blue_damage.recalculate(&self.specs, &self.colours, player_colours); + self.blue_power.recalculate(&self.specs, &self.colours, player_colours); self.blue_life.recalculate(&self.specs, &self.colours, player_colours); self.evasion.recalculate(&self.specs, &self.colours, player_colours); self.speed.recalculate(&self.specs, &self.colours, player_colours); - self.green_damage.recalculate(&self.specs, &self.colours, player_colours); + self.green_power.recalculate(&self.specs, &self.colours, player_colours); self.green_life.recalculate(&self.specs, &self.colours, player_colours); self @@ -428,37 +428,37 @@ impl Construct { } // Stats - pub fn red_damage(&self) -> u64 { - let red_damage_mods = self.effects.iter() - .filter(|e| e.effect.modifications().contains(&Stat::RedDamage)) + pub fn red_power(&self) -> u64 { + let red_power_mods = self.effects.iter() + .filter(|e| e.effect.modifications().contains(&Stat::RedPower)) .map(|e| (e.effect, e.meta)) .collect::)>>(); - let modified_red_damage = red_damage_mods.iter() - .fold(self.red_damage.value, |acc, fx| fx.0.apply(acc, fx.1)); - return modified_red_damage; + let modified_red_power = red_power_mods.iter() + .fold(self.red_power.value, |acc, fx| fx.0.apply(acc, fx.1)); + return modified_red_power; } - pub fn blue_damage(&self) -> u64 { - let blue_damage_mods = self.effects.iter() - .filter(|e| e.effect.modifications().contains(&Stat::BlueDamage)) + pub fn blue_power(&self) -> u64 { + let blue_power_mods = self.effects.iter() + .filter(|e| e.effect.modifications().contains(&Stat::BluePower)) .map(|e| (e.effect, e.meta)) .collect::)>>(); - let modified_blue_damage = blue_damage_mods.iter() - .fold(self.blue_damage.value, |acc, fx| fx.0.apply(acc, fx.1)); - return modified_blue_damage; + let modified_blue_power = blue_power_mods.iter() + .fold(self.blue_power.value, |acc, fx| fx.0.apply(acc, fx.1)); + return modified_blue_power; } - pub fn green_damage(&self) -> u64 { - let green_damage_mods = self.effects.iter() - .filter(|e| e.effect.modifications().contains(&Stat::GreenDamage)) + pub fn green_power(&self) -> u64 { + let green_power_mods = self.effects.iter() + .filter(|e| e.effect.modifications().contains(&Stat::GreenPower)) .map(|e| (e.effect, e.meta)) .collect::)>>(); - let modified_green_damage = green_damage_mods.iter() - .fold(self.green_damage.value, |acc, fx| fx.0.apply(acc, fx.1)); - return modified_green_damage; + let modified_green_power = green_power_mods.iter() + .fold(self.green_power.value, |acc, fx| fx.0.apply(acc, fx.1)); + return modified_green_power; } pub fn skill_speed(&self, s: Skill) -> u64 { @@ -538,17 +538,17 @@ impl Construct { .map(|e| (e.effect, e.meta)) .collect::)>>(); - let modified_damage = mods.iter() + let modified_power = mods.iter() .fold(amount, |acc, fx| fx.0.apply(acc, fx.1)); match self.affected(Effect::Invert) { false => { let current_green_life = self.green_life(); - self.green_life.increase(modified_damage); + self.green_life.increase(modified_power); let new_green_life = self.green_life.value; let healing = new_green_life - current_green_life; - let overhealing = modified_damage - healing; + let overhealing = modified_power - healing; events.push(Event::Healing { skill, @@ -561,7 +561,7 @@ impl Construct { // there is no green shield (yet) let current_green_life = self.green_life(); - self.reduce_green_life(modified_damage); + self.reduce_green_life(modified_power); let delta = current_green_life - self.green_life(); events.push(Event::Damage { @@ -597,7 +597,7 @@ impl Construct { .map(|e| (e.effect, e.meta)) .collect::)>>(); - let modified_damage = mods.iter() + let modified_power = mods.iter() .fold(amount, |acc, fx| fx.0.apply(acc, fx.1)); match self.affected(Effect::Invert) { @@ -606,8 +606,8 @@ impl Construct { // eg 50 red_life 25 damage -> 0 remainder 25 mitigation // 50 red_life 100 damage -> 50 remainder 50 mitigation // 50 red_life 5 damage -> 0 remainder 5 mitigation - let remainder = modified_damage.saturating_sub(self.red_life.value); - let mitigation = modified_damage.saturating_sub(remainder); + let remainder = modified_power.saturating_sub(self.red_life.value); + let mitigation = modified_power.saturating_sub(remainder); // reduce red_life by mitigation amount self.red_life.reduce(mitigation); @@ -628,10 +628,10 @@ impl Construct { events.push(Event::Inversion { skill }); let current_green_life = self.green_life(); - self.green_life.increase(modified_damage); + self.green_life.increase(modified_power); let new_green_life = self.green_life.value; let healing = new_green_life - current_green_life; - let overhealing = modified_damage - healing; + let overhealing = modified_power - healing; let current_life = self.red_life.value; self.red_life.increase(overhealing); @@ -676,13 +676,13 @@ impl Construct { .map(|e| (e.effect, e.meta)) .collect::)>>(); - let modified_damage = mods.iter() + let modified_power = mods.iter() .fold(amount, |acc, fx| fx.0.apply(acc, fx.1)); match self.affected(Effect::Invert) { false => { - let remainder = modified_damage.saturating_sub(self.blue_life.value); - let mitigation = modified_damage.saturating_sub(remainder); + let remainder = modified_power.saturating_sub(self.blue_life.value); + let mitigation = modified_power.saturating_sub(remainder); // reduce blue_life by mitigation amount self.blue_life.reduce(mitigation); @@ -703,10 +703,10 @@ impl Construct { events.push(Event::Inversion { skill }); let current_green_life = self.green_life(); - self.green_life.increase(modified_damage); + self.green_life.increase(modified_power); let new_green_life = self.green_life.value; let healing = new_green_life - current_green_life; - let overhealing = modified_damage - healing; + let overhealing = modified_power - healing; let current_life = self.blue_life.value; self.blue_life.increase(overhealing); @@ -872,8 +872,8 @@ mod tests { construct.learn_mut(Skill::Strike); construct.spec_add(Spec::GreenLifeI).unwrap(); - construct.spec_add(Spec::RedDamageI).unwrap(); - construct.spec_add(Spec::RedDamageI).unwrap(); + construct.spec_add(Spec::RedPowerI).unwrap(); + construct.spec_add(Spec::RedPowerI).unwrap(); construct.spec_add(Spec::BlueLifeI).unwrap(); assert_eq!(construct.colours.red, 6); @@ -888,9 +888,9 @@ mod tests { let mut construct = Construct::new() .named(&"player player".to_string()); - construct.spec_add(Spec::RedDamageI).unwrap(); - construct.spec_add(Spec::GreenDamageI).unwrap(); - construct.spec_add(Spec::BlueDamageI).unwrap(); + construct.spec_add(Spec::RedPowerI).unwrap(); + construct.spec_add(Spec::GreenPowerI).unwrap(); + construct.spec_add(Spec::BluePowerI).unwrap(); let player_colours = Colours { red: 5, @@ -900,9 +900,9 @@ mod tests { construct.apply_modifiers(&player_colours); - assert!(construct.red_damage.value == construct.red_damage.base + construct.red_damage.base.pct(20)); - assert!(construct.green_damage.value == construct.green_damage.base + construct.green_damage.base.pct(40)); - assert!(construct.blue_damage.value == construct.blue_damage.base + construct.blue_damage.base.pct(80)); + assert!(construct.red_power.value == construct.red_power.base + construct.red_power.base.pct(20)); + assert!(construct.green_power.value == construct.green_power.base + construct.green_power.base.pct(40)); + assert!(construct.blue_power.value == construct.blue_power.base + construct.blue_power.base.pct(80)); return; } diff --git a/server/src/game.rs b/server/src/game.rs index c4509030..88c7a98b 100644 --- a/server/src/game.rs +++ b/server/src/game.rs @@ -1082,7 +1082,7 @@ mod tests { let x_construct = x_player.constructs[0].clone(); let y_construct = y_player.constructs[0].clone(); - game.player_by_id(y_player.id).unwrap().construct_by_id(y_construct.id).unwrap().red_damage.force(1000000000); + game.player_by_id(y_player.id).unwrap().construct_by_id(y_construct.id).unwrap().red_power.force(1000000000); game.player_by_id(y_player.id).unwrap().construct_by_id(y_construct.id).unwrap().speed.force(1000000000); // just in case @@ -1166,7 +1166,7 @@ mod tests { // should not be stunned because of parry assert!(game.player_by_id(x_player.id).unwrap().constructs[0].is_stunned() == false); // riposte - assert_eq!(game.player_by_id(y_player.id).unwrap().constructs[0].green_life(), (1024 - x_construct.red_damage().pct(Skill::Riposte.multiplier()))); + assert_eq!(game.player_by_id(y_player.id).unwrap().constructs[0].green_life(), (1024 - x_construct.red_power().pct(Skill::Riposte.multiplier()))); } #[test] diff --git a/server/src/item.rs b/server/src/item.rs index 3724a547..5c8611d4 100644 --- a/server/src/item.rs +++ b/server/src/item.rs @@ -18,7 +18,7 @@ pub enum Item { // specs // Base - Damage, + Power, Life, Speed, @@ -30,10 +30,10 @@ pub enum Item { GBLI, RBLI, - // Damage Upgrades - RedDamageI, - BlueDamageI, - GreenDamageI, + // Power Upgrades + RedPowerI, + BluePowerI, + GreenPowerI, GRDI, GBDI, RBDI, @@ -136,7 +136,7 @@ impl Item { Item::Debuff => 2, Item::Stun => 2, - Item::Damage => 3, + Item::Power => 3, Item::Life => 3, Item::Speed => 3, @@ -234,10 +234,10 @@ impl Item { Item::GBSpeedI => Some(Spec::GBSpeedI), Item::RBSpeedI => Some(Spec::RBSpeedI), - Item::Damage => Some(Spec::Damage), - Item::RedDamageI => Some(Spec::RedDamageI), - Item::BlueDamageI => Some(Spec::BlueDamageI), - Item::GreenDamageI => Some(Spec::GreenDamageI), + Item::Power => Some(Spec::Power), + Item::RedPowerI => Some(Spec::RedPowerI), + Item::BluePowerI => Some(Spec::BluePowerI), + Item::GreenPowerI => Some(Spec::GreenPowerI), Item::GRDI => Some(Spec::GRDI), Item::GBDI => Some(Spec::GBDI), Item::RBDI => Some(Spec::RBDI), @@ -271,21 +271,21 @@ impl Item { Item::Red => format!("Combine with skills and specs to create upgraded items. \n Speed and chaos."), // base skills - Item::Attack => format!("Deal red damage based on {:?}% red power", + Item::Attack => format!("Deal RedDamage based on {:?}% RedPower", self.into_skill().unwrap().multiplier()), - Item::Block => format!("Reduce incoming red damage by {:?}%", + Item::Block => format!("Reduce incoming RedDamage by {:?}%", 100 - self.into_skill().unwrap().effect().first().unwrap().get_multiplier()), Item::Stun => format!("Stun target construct for {:?}T", self.into_skill().unwrap().effect().first().unwrap().get_duration()), - Item::Buff => format!("Increase target construct red damage and speed by {:?}%", + Item::Buff => format!("Increase target construct RedPower and speed by {:?}%", self.into_skill().unwrap().effect().first().unwrap().get_multiplier() - 100), Item::Debuff => format!("Slow target construct speed by {:?}%", 100 - self.into_skill().unwrap().effect().first().unwrap().get_multiplier()), // specs // Base - Item::Damage => format!("Base ITEM for increased DAMAGE. DAMAGE determines the power of your SKILLS."), + Item::Power => format!("Base ITEM for increased Power. Power determines the damage caused by your SKILLS."), Item::Life => format!("Base ITEM for increased LIFE. When your CONSTRUCT reaches 0 GreenLife it becomes KO and cannot cast SKILLS."), Item::Speed => format!("Base ITEM for increased SPEED. @@ -295,20 +295,20 @@ impl Item { Item::GreenLifeI => format!("Increases CONSTRUCT GreenLife. When your CONSTRUCT reaches 0 GreenLife it becomes KO and cannot cast SKILLS."), Item::RedLifeI => format!("Increases CONSTRUCT RedLife. - Red damage dealt to your construct reduces RedLife before GreenLife."), + RedDamage dealt to your construct reduces RedLife before GreenLife."), Item::BlueLifeI => format!("Increases CONSTRUCT BlueLife. - Blue damage dealt to your construct reduces BlueLife before GreenLife."), + BlueDamage dealt to your construct reduces BlueLife before GreenLife."), Item::GRLI => format!("Increases CONSTRUCT GreenLife + RedLife"), Item::GBLI => format!("Increases CONSTRUCT GreenLife + BlueLife"), Item::RBLI => format!("Increases CONSTRUCT RedLife + BlueLife"), - // Damage Upgrades - Item::RedDamageI => format!("Increases CONSTRUCT RedDamage."), - Item::BlueDamageI => format!("Increases CONSTRUCT BlueDamage."), - Item::GreenDamageI => format!("Increases CONSTRUCT GreenDamage."), - Item::GRDI => format!("Increases CONSTRUCT GreenDamage + RedDamage."), - Item::GBDI => format!("Increases CONSTRUCT GreenDamage + BlueDamage."), - Item::RBDI => format!("Increases CONSTRUCT RedDamage + BlueDamage."), + // Power Upgrades + Item::RedPowerI => format!("Increases CONSTRUCT RedPower."), + Item::BluePowerI => format!("Increases CONSTRUCT BluePower."), + Item::GreenPowerI => format!("Increases CONSTRUCT GreenPower."), + Item::GRDI => format!("Increases CONSTRUCT GreenPower + RedPower."), + Item::GBDI => format!("Increases CONSTRUCT GreenPower + BluePower."), + Item::RBDI => format!("Increases CONSTRUCT RedPower + BluePower."), // Speed Upgrades Item::RedSpeedI => format!("Increases CONSTRUCT SPEED and provides COLOUR BONUSES"), @@ -319,7 +319,7 @@ impl Item { Item::RBSpeedI => format!("Increases CONSTRUCT SPEED and provides COLOUR BONUSES"), // Skills <- need to move effect mulltipliers into skills - Item::Amplify => format!("Increase red and blue power by {:?}%. Lasts {:?}T", + Item::Amplify => format!("Increase red and BluePower by {:?}%. Lasts {:?}T", self.into_skill().unwrap().effect().first().unwrap().get_multiplier() - 100, self.into_skill().unwrap().effect().first().unwrap().get_duration()), @@ -327,29 +327,29 @@ impl Item { Banished constructs are immune to all skills and effects.", self.into_skill().unwrap().effect().first().unwrap().get_duration()), - Item::Blast => format!("Deals blue damage {:?}% blue power.", self.into_skill().unwrap().multiplier()), + Item::Blast => format!("Deals BlueDamage {:?}% BluePower.", self.into_skill().unwrap().multiplier()), Item::Chaos => format!( - "Hits twice for red and blue damage. Damage is random 0 to 30% + {:?}% red and blue power.", + "Hits twice for red and BlueDamage. Damage is random 0 to 30% + {:?}% red and BluePower.", self.into_skill().unwrap().multiplier()), Item::Clutch => format!("Construct cannot be KO'd while active. Additionally provides immunity to disables."), Item::Corrupt => format!( - "Self targetting defensive for {:?}T. Applies corrupt to attackers dealing blue damage {:?}% blue power per turn for {:?}T.", + "Self targetting defensive for {:?}T. Applies corrupt to attackers dealing BlueDamage {:?}% BluePower per turn for {:?}T.", self.into_skill().unwrap().effect().first().unwrap().get_duration(), Skill::Corrupt.multiplier(), self.into_skill().unwrap().effect().last().unwrap().get_duration()), Item::Curse => format!( - "Increases red and blue damage taken by {:?}%. Lasts {:?}T", + "Increases red and BlueDamage taken by {:?}%. Lasts {:?}T", self.into_skill().unwrap().effect().first().unwrap().get_multiplier() - 100, self.into_skill().unwrap().effect().first().unwrap().get_duration()), Item::Decay => format!( - "Reduces healing taken by {:?}% and deals blue damage {:?}% blue power each turn. Lasts {:?}T", + "Reduces healing taken by {:?}% and deals BlueDamage {:?}% BluePower each turn. Lasts {:?}T", 100 - self.into_skill().unwrap().effect().first().unwrap().get_multiplier(), self.into_skill().unwrap().multiplier(), self.into_skill().unwrap().effect().first().unwrap().get_duration()), @@ -357,17 +357,17 @@ impl Item { Item::Hostility => format!( "Gain Hostility for {:?}T. {} Hatred lasts {:?}T", self.into_skill().unwrap().effect().first().unwrap().get_duration(), - "When attacked by Hostility you gain Hatred which increased red and blue power based on damage taken.", + "When attacked by Hostility you gain Hatred which increased red and BluePower based on Damage taken.", self.into_skill().unwrap().effect().last().unwrap().get_duration()), Item::Haste => format!( "Haste increases Speed by {:?}%, Red based Attack skills will strike again dealing {:?}{}. Lasts {:?}T", self.into_skill().unwrap().effect().first().unwrap().get_multiplier() - 100, Skill::HasteStrike.multiplier(), - "% Speed as Red Damage", + "% Speed as RedDamage", self.into_skill().unwrap().effect().first().unwrap().get_duration()), - Item::Heal => format!("Heals for {:?}% green power.", self.into_skill().unwrap().multiplier()), + Item::Heal => format!("Heals for {:?}% GreenPower.", self.into_skill().unwrap().multiplier()), Item::Hex => format!("Blue based skill that applies Hex for {:?}T. \ Hexed targets cannot cast any skills.", @@ -375,34 +375,34 @@ impl Item { Item::Impurity => format!( - "Impurity increases Green Power by {:?}%, Blue based Attack skills will blast again dealing {:?}{}. Lasts {:?}T", + "Impurity increases GreenPower by {:?}%, Blue based Attack skills will blast again dealing {:?}{}. Lasts {:?}T", self.into_skill().unwrap().effect().first().unwrap().get_multiplier() - 100, Skill::ImpureBlast.multiplier(), - "% Green Power as Blue Damage", + "% GreenPower as BluePower", self.into_skill().unwrap().effect().first().unwrap().get_duration()), Item::Invert => format!( - "Reverse healing into damage and damage into healing. - Any excess red or blue damage is converted into shield recharge."), + "Reverse healing into Damage and Damage into healing. + Any excess red or BlueDamage is converted into shield recharge."), - Item::Parry => format!("{} {:?}% red power and blocks red skills for {:?}T. {} {:?}% red power.", + Item::Parry => format!("{} {:?}% RedPower and blocks red skills for {:?}T. {} {:?}% RedPower.", "Self targetting skill. Recharges RedLife for", self.into_skill().unwrap().multiplier(), self.into_skill().unwrap().effect().first().unwrap().get_duration(), - "If a red skill is parried the construct will riposte the source dealing red damage", + "If a red skill is parried the construct will riposte the source dealing RedDamage", Skill::Riposte.multiplier()), Item::Purge => format!("Remove buffs from target construct"), Item::Purify => format!( - "Remove debuffs and heals for {:?}% green power per debuff removed.", + "Remove debuffs and heals for {:?}% GreenPower per debuff removed.", self.into_skill().unwrap().multiplier()), Item::Reflect => format!( "Reflect incoming skills to source. Lasts {:?}T", self.into_skill().unwrap().effect().first().unwrap().get_duration()), Item::Recharge => format!( - "Recharge red and blue shield based on {:?} red and blue power", + "Recharge red and blue shield based on {:?} red and BluePower", self.into_skill().unwrap().multiplier()), Item::Ruin => format!( @@ -410,69 +410,67 @@ impl Item { self.into_skill().unwrap().effect().first().unwrap().get_duration()), Item::Scatter => format!( - "Caster links with target. Linked constructs split incoming damage evenly. Recharges target blue shield {:?}% of blue power", + "Caster links with target. Linked constructs split incoming Damage evenly. Recharges target blue shield {:?}% of BluePower", self.into_skill().unwrap().multiplier()), Item::Silence => 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 BlueDamage {:?}% BluePower. {}", self.into_skill().unwrap().effect().first().unwrap().get_duration(), self.into_skill().unwrap().multiplier(), - "Deals 45% more damage per blue skill on target"), + "Deals 45% more Damage per blue skill on target"), Item::Slay => format!( - "Deals red damage {:?}% red power and provides self healing based on damage dealt.", + "Deals RedDamage {:?}% RedPower and provides self healing based on Damage dealt.", self.into_skill().unwrap().multiplier()), Item::Sleep => format!( - "Stun for {:?}T and heal for {:?}% green power.", + "Stun for {:?}T and heal for {:?}% GreenPower.", self.into_skill().unwrap().effect().first().unwrap().get_duration(), self.into_skill().unwrap().multiplier()), Item::Snare => format!( - "Block the target from using red skills for {:?}T and deals red damage {:?}% red power. {}", + "Block the target from using red skills for {:?}T and deals RedDamage {:?}% RedPower. {}", self.into_skill().unwrap().effect().first().unwrap().get_duration(), self.into_skill().unwrap().multiplier(), - "Deals 35% more damage per red skill on target"), + "Deals 35% more Damage per red skill on target"), Item::Strangle => format!( "Strangle the target disabling skills from both the caster and the target. - While strangling deal red damage each turn {:?}% red power. Lasts {:?}T.", + While strangling deal RedDamage each turn {:?}% RedPower. Lasts {:?}T.", self.into_skill().unwrap().multiplier(), self.into_skill().unwrap().effect().first().unwrap().get_duration()), Item::Strike => format!( - "Hits at maximum speed dealing red damage {:?}% red power", + "Hits at maximum speed dealing RedDamage {:?}% RedPower", self.into_skill().unwrap().multiplier()), Item::StrikeII => format!( - "Hits at maximum speed dealing red damage {:?}% red power", + "Hits at maximum speed dealing RedDamage {:?}% RedPower", self.into_skill().unwrap().multiplier()), Item::StrikeIII => format!( - "Hits at maximum speed dealing red damage {:?}% red power", + "Hits at maximum speed dealing RedDamage {:?}% RedPower", self.into_skill().unwrap().multiplier()), Item::Siphon => format!( - "Deals blue damage {:?}% blue power each turn and heals caster based on damage dealt. Lasts {:?}T", + "Deals BlueDamage {:?}% BluePower each turn and heals caster based on Damage dealt. Lasts {:?}T", self.into_skill().unwrap().multiplier(), self.into_skill().unwrap().effect().first().unwrap().get_duration()), - Item::Taunt => format!("{} {:?}T. Recharges RedLife for {:?} red power.", + Item::Taunt => format!("{} {:?}T. Recharges RedLife for {:?} RedPower.", "Taunt redirects skills against the team to target, lasts", self.into_skill().unwrap().effect().first().unwrap().get_duration(), self.into_skill().unwrap().multiplier()), Item::Throw => format!( - "Stun the target for {:?}T and applies Vulnerable increasing red damage taken by {:?}% for {:?}T", + "Stun the target for {:?}T and applies Vulnerable increasing RedDamage taken by {:?}% for {:?}T", self.into_skill().unwrap().effect().first().unwrap().get_duration(), self.into_skill().unwrap().effect().first().unwrap().get_multiplier() - 100, self.into_skill().unwrap().effect().last().unwrap().get_duration()), Item::Triage => format!( - "Heals target for {:?}% green power each turn. Lasts {:?}T", + "Heals target for {:?}% GreenPower each turn. Lasts {:?}T", self.into_skill().unwrap().multiplier(), self.into_skill().unwrap().effect().first().unwrap().get_duration()), - - _ => format!("..."), } } @@ -517,12 +515,12 @@ impl Item { Item::Siphon => vec![Item::Attack, Item::Green, Item::Blue], Item::Chaos => vec![Item::Attack, Item::Red, Item::Blue], - Item::RedDamageI => vec![Item::Damage, Item::Red, Item::Red], - Item::GreenDamageI => vec![Item::Damage, Item::Green, Item::Green], - Item::BlueDamageI => vec![Item::Damage, Item::Blue, Item::Blue], - Item::GRDI => vec![Item::Damage, Item::Red, Item::Green], - Item::GBDI => vec![Item::Damage, Item::Green, Item::Blue], - Item::RBDI => vec![Item::Damage, Item::Red, Item::Blue], + Item::RedPowerI => vec![Item::Power, Item::Red, Item::Red], + Item::GreenPowerI => vec![Item::Power, Item::Green, Item::Green], + Item::BluePowerI => vec![Item::Power, Item::Blue, Item::Blue], + Item::GRDI => vec![Item::Power, Item::Red, Item::Green], + Item::GBDI => vec![Item::Power, Item::Green, Item::Blue], + Item::RBDI => vec![Item::Power, Item::Red, Item::Blue], Item::RedLifeI => vec![Item::Life, Item::Red, Item::Red], Item::GreenLifeI => vec![Item::Life, Item::Green, Item::Green], @@ -612,10 +610,10 @@ impl From for Item { Spec::GBSpeedI => Item::GBSpeedI, Spec::RBSpeedI => Item::RBSpeedI, - Spec::Damage => Item::Damage, - Spec::RedDamageI => Item::RedDamageI, - Spec::BlueDamageI => Item::BlueDamageI, - Spec::GreenDamageI => Item::GreenDamageI, + Spec::Power => Item::Power, + Spec::RedPowerI => Item::RedPowerI, + Spec::BluePowerI => Item::BluePowerI, + Spec::GreenPowerI => Item::GreenPowerI, Spec::GRDI => Item::GRDI, Spec::GBDI => Item::GBDI, Spec::RBDI => Item::RBDI, @@ -679,9 +677,9 @@ pub fn get_combos() -> Vec { Combo { components: Item::Siphon.combo(), item: Item::Siphon }, Combo { components: Item::Chaos.combo(), item: Item::Chaos }, - Combo { components: Item::RedDamageI.combo(), item: Item::RedDamageI }, - Combo { components: Item::GreenDamageI.combo(), item: Item::GreenDamageI }, - Combo { components: Item::BlueDamageI.combo(), item: Item::BlueDamageI }, + Combo { components: Item::RedPowerI.combo(), item: Item::RedPowerI }, + Combo { components: Item::GreenPowerI.combo(), item: Item::GreenPowerI }, + Combo { components: Item::BluePowerI.combo(), item: Item::BluePowerI }, Combo { components: Item::GRDI.combo(), item: Item::GRDI }, Combo { components: Item::GBDI.combo(), item: Item::GBDI }, Combo { components: Item::RBDI.combo(), item: Item::RBDI }, diff --git a/server/src/skill.rs b/server/src/skill.rs index d4cf3c02..77dac474 100644 --- a/server/src/skill.rs +++ b/server/src/skill.rs @@ -92,7 +92,7 @@ pub fn resolve(skill: Skill, source: &mut Construct, target: &mut Construct, mut Skill::Blast | Skill::Chaos | Skill::Siphon => { - let amount = source.green_damage().pct(Skill::ImpureBlast.multiplier()); + let amount = source.green_power().pct(Skill::ImpureBlast.multiplier()); target.deal_blue_damage(Skill::ImpureBlast, amount) .into_iter() .for_each(|e| resolutions.push(Resolution::new(source, target).event(e))); @@ -424,14 +424,14 @@ impl Effect { match self { Effect::Vulnerable => vec![Stat::RedDamageTaken], Effect::Block => vec![Stat::RedDamageTaken], - Effect::Buff => vec![Stat::RedDamage, Stat::Speed], + Effect::Buff => vec![Stat::RedPower, Stat::Speed], - Effect::Hatred => vec![Stat::RedDamage, Stat::BlueDamage], + Effect::Hatred => vec![Stat::RedPower, Stat::BluePower], - Effect::Amplify => vec![Stat::RedDamage, Stat::BlueDamage], + Effect::Amplify => vec![Stat::RedPower, Stat::BluePower], Effect::Curse => vec![Stat::BlueDamageTaken], - Effect::Impurity => vec![Stat::GreenDamage], + Effect::Impurity => vec![Stat::GreenPower], Effect::Wither => vec![Stat::GreenDamageTaken], Effect::Haste => vec![Stat::Speed], @@ -885,7 +885,7 @@ fn touch(source: &mut Construct, target: &mut Construct, mut results: Resolution } fn attack(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions { - let amount = source.red_damage().pct(skill.multiplier()); + let amount = source.red_power().pct(skill.multiplier()); target.deal_red_damage(skill, amount) .into_iter() .for_each(|e| results.push(Resolution::new(source, target).event(e))); @@ -894,7 +894,7 @@ fn attack(source: &mut Construct, target: &mut Construct, mut results: Resolutio } fn strike(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions { - let amount = source.red_damage().pct(skill.multiplier()); + let amount = source.red_power().pct(skill.multiplier()); target.deal_red_damage(skill, amount) .into_iter() .for_each(|e| results.push(Resolution::new(source, target).event(e))); @@ -903,7 +903,7 @@ fn strike(source: &mut Construct, target: &mut Construct, mut results: Resolutio } fn injure(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions { - let amount = source.red_damage().pct(skill.multiplier()); + let amount = source.red_power().pct(skill.multiplier()); target.deal_red_damage(skill, amount) .into_iter() .for_each(|e| results.push(Resolution::new(source, target).event(e))); @@ -925,7 +925,7 @@ fn sleep(source: &mut Construct, target: &mut Construct, mut results: Resolution skill.effect().into_iter() .for_each(|e| (results.push(Resolution::new(source, target).event(target.add_effect(skill, e))))); - let amount = source.green_damage().pct(skill.multiplier()); + let amount = source.green_power().pct(skill.multiplier()); target.deal_green_damage(skill, amount) .into_iter() .for_each(|e| results.push(Resolution::new(source, target).event(e))); @@ -940,7 +940,7 @@ fn clutch(source: &mut Construct, target: &mut Construct, mut results: Resolutio } fn taunt(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions { - let red_amount = source.red_damage().pct(skill.multiplier()); + let red_amount = source.red_power().pct(skill.multiplier()); results.push(Resolution::new(source, target).event(target.recharge(skill, red_amount, 0))); skill.effect().into_iter() @@ -969,7 +969,7 @@ fn strangle(source: &mut Construct, target: &mut Construct, mut results: Resolut } fn strangle_tick(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions { - let amount = source.red_damage().pct(skill.multiplier()); + let amount = source.red_power().pct(skill.multiplier()); target.deal_red_damage(skill, amount) .into_iter() .for_each(|e| results.push(Resolution::new(source, target).event(e))); @@ -1000,7 +1000,7 @@ fn buff(source: &mut Construct, target: &mut Construct, mut results: Resolutions } fn parry(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions { - let red_amount = source.red_damage().pct(skill.multiplier()); + let red_amount = source.red_power().pct(skill.multiplier()); results.push(Resolution::new(source, target).event(target.recharge(skill, red_amount, 0))); skill.effect().into_iter() @@ -1009,7 +1009,7 @@ fn parry(source: &mut Construct, target: &mut Construct, mut results: Resolution } fn riposte(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions { - let amount = source.red_damage().pct(skill.multiplier()); + let amount = source.red_power().pct(skill.multiplier()); target.deal_red_damage(skill, amount) .into_iter() .for_each(|e| results.push(Resolution::new(source, target).event(e))); @@ -1028,7 +1028,7 @@ fn snare(source: &mut Construct, target: &mut Construct, mut results: Resolution false => acc, }); - let amount = source.red_damage().pct(skill.multiplier()).pct(s_multi); + let amount = source.red_power().pct(skill.multiplier()).pct(s_multi); target.deal_red_damage(skill, amount) .into_iter() .for_each(|e| results.push(Resolution::new(source, target).event(e))); @@ -1038,7 +1038,7 @@ fn snare(source: &mut Construct, target: &mut Construct, mut results: Resolution } fn slay(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions { - let amount = source.red_damage().pct(skill.multiplier()); + let amount = source.red_power().pct(skill.multiplier()); let slay_events = target.deal_red_damage(skill, amount); for e in slay_events { @@ -1058,7 +1058,7 @@ fn slay(source: &mut Construct, target: &mut Construct, mut results: Resolutions } fn heal(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions { - let amount = source.green_damage().pct(skill.multiplier()); + let amount = source.green_power().pct(skill.multiplier()); target.deal_green_damage(skill, amount) .into_iter() .for_each(|e| results.push(Resolution::new(source, target).event(e))); @@ -1075,7 +1075,7 @@ fn triage(source: &mut Construct, target: &mut Construct, mut results: Resolutio } fn triage_tick(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions { - let amount = source.green_damage().pct(skill.multiplier()); + let amount = source.green_power().pct(skill.multiplier()); target.deal_green_damage(Skill::TriageTick, amount) .into_iter() .for_each(|e| results.push(Resolution::new(source, target).event(e))); @@ -1085,12 +1085,12 @@ fn triage_tick(source: &mut Construct, target: &mut Construct, mut results: Reso fn chaos(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions { let mut rng = thread_rng(); let b_rng: u64 = rng.gen_range(0, 30); - let amount = source.blue_damage().pct(skill.multiplier() + b_rng); + let amount = source.blue_power().pct(skill.multiplier() + b_rng); target.deal_blue_damage(skill, amount) .into_iter() .for_each(|e| results.push(Resolution::new(source, target).event(e))); let r_rng: u64 = rng.gen_range(0, 30); - let amount = source.red_damage().pct(skill.multiplier() + r_rng); + let amount = source.red_power().pct(skill.multiplier() + r_rng); target.deal_red_damage(skill, amount) .into_iter() .for_each(|e| results.push(Resolution::new(source, target).event(e))); @@ -1098,7 +1098,7 @@ fn chaos(source: &mut Construct, target: &mut Construct, mut results: Resolution } fn blast(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions { - let amount = source.blue_damage().pct(skill.multiplier()); + let amount = source.blue_power().pct(skill.multiplier()); target.deal_blue_damage(skill, amount) .into_iter() .for_each(|e| results.push(Resolution::new(source, target).event(e))); @@ -1139,7 +1139,7 @@ fn decay(source: &mut Construct, target: &mut Construct, mut results: Resolution } fn decay_tick(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions { - let amount = source.blue_damage().pct(skill.multiplier()); + let amount = source.blue_power().pct(skill.multiplier()); target.deal_blue_damage(skill, amount) .into_iter() .for_each(|e| results.push(Resolution::new(source, target).event(e))); @@ -1163,7 +1163,7 @@ fn corruption(source: &mut Construct, target: &mut Construct, mut results: Resol } fn corruption_tick(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions { - let amount = source.blue_damage().pct(skill.multiplier()); + let amount = source.blue_power().pct(skill.multiplier()); target.deal_blue_damage(skill, amount) .into_iter() .for_each(|e| results.push(Resolution::new(source, target).event(e))); @@ -1219,15 +1219,15 @@ fn reflect(source: &mut Construct, target: &mut Construct, mut results: Resoluti skill.effect().into_iter() .for_each(|e| (results.push(Resolution::new(source, target).event(target.add_effect(skill, e))))); - let blue_amount = source.blue_damage().pct(skill.multiplier()); + let blue_amount = source.blue_power().pct(skill.multiplier()); results.push(Resolution::new(source, target).event(target.recharge(skill, 0, blue_amount))); return results;; } fn recharge(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions { - let red_amount = source.red_damage().pct(skill.multiplier()); - let blue_amount = source.blue_damage().pct(skill.multiplier()); + let red_amount = source.red_power().pct(skill.multiplier()); + let blue_amount = source.blue_power().pct(skill.multiplier()); results.push(Resolution::new(source, target).event(target.recharge(skill, red_amount, blue_amount))); return results; @@ -1243,7 +1243,7 @@ fn siphon(source: &mut Construct, target: &mut Construct, mut results: Resolutio } fn siphon_tick(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions { - let amount = source.blue_damage().pct(skill.multiplier()); + let amount = source.blue_power().pct(skill.multiplier()); let siphon_events = target.deal_blue_damage(Skill::SiphonTick, amount); for e in siphon_events { @@ -1263,7 +1263,7 @@ fn siphon_tick(source: &mut Construct, target: &mut Construct, mut results: Reso } fn scatter(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions { - let blue_amount = source.blue_damage().pct(skill.multiplier()); + let blue_amount = source.blue_power().pct(skill.multiplier()); results.push(Resolution::new(source, target).event(target.recharge(skill, 0, blue_amount))); skill.effect().into_iter().for_each(|e| { @@ -1311,7 +1311,7 @@ fn silence(source: &mut Construct, target: &mut Construct, mut results: Resoluti false => acc, }); - let amount = source.blue_damage().pct(skill.multiplier()).pct(s_multi); + let amount = source.blue_power().pct(skill.multiplier()).pct(s_multi); target.deal_blue_damage(skill, amount) .into_iter() .for_each(|e| results.push(Resolution::new(source, target).event(e))); @@ -1332,7 +1332,7 @@ fn purge(source: &mut Construct, target: &mut Construct, mut results: Resolution fn purify(source: &mut Construct, target: &mut Construct, mut results: Resolutions, skill: Skill) -> Resolutions { results.push(Resolution::new(source, target).event(Event::Skill { skill })); - let amount = source.green_damage().pct(skill.multiplier()); + let amount = source.green_power().pct(skill.multiplier()); while let Some(i) = target.effects .iter() .position(|ce| ce.effect.category() == EffectCategory::Debuff) { @@ -1397,7 +1397,7 @@ mod tests { .named(&"camel".to_string()); // ensure it doesn't have 0 pd - x.red_damage.force(100); + x.red_power.force(100); y.green_life.force(500); block(&mut y.clone(), &mut y, vec![], Skill::Block); @@ -1420,7 +1420,7 @@ mod tests { let mut y = Construct::new() .named(&"camel".to_string()); - x.red_damage.force(10000000000000); // multiplication of int max will cause overflow + x.red_power.force(10000000000000); // multiplication of int max will cause overflow clutch(&mut y.clone(), &mut y, vec![], Skill::Clutch); assert!(y.affected(Effect::Clutch)); @@ -1466,7 +1466,7 @@ mod tests { // give red shield but reduce to 0 y.red_life.force(64); y.red_life.reduce(64); - x.red_damage.force(256 + 64); + x.red_power.force(256 + 64); invert(&mut y.clone(), &mut y, vec![], Skill::Invert); assert!(y.affected(Effect::Invert)); @@ -1569,7 +1569,7 @@ mod tests { .named(&"pretaliation".to_string()); // ensure it doesn't have 0 sd - x.blue_damage.force(50); + x.blue_power.force(50); // remove all mitigation y.red_life.force(0); @@ -1626,11 +1626,11 @@ mod tests { let mut x = Construct::new() .named(&"muji".to_string()); - x.blue_damage.force(50); + x.blue_power.force(50); amplify(&mut x.clone(), &mut x, vec![], Skill::Amplify); assert!(x.effects.iter().any(|e| e.effect == Effect::Amplify)); - assert_eq!(x.blue_damage(), 75); + assert_eq!(x.blue_power(), 75); } #[test] diff --git a/server/src/spec.rs b/server/src/spec.rs index c642dc1e..014c3d18 100644 --- a/server/src/spec.rs +++ b/server/src/spec.rs @@ -20,10 +20,10 @@ pub enum Spec { GBLI, RBLI, - Damage, - RedDamageI, - GreenDamageI, - BlueDamageI, + Power, + RedPowerI, + GreenPowerI, + BluePowerI, GRDI, GBDI, RBDI, @@ -32,13 +32,13 @@ pub enum Spec { impl Spec { pub fn affects(&self) -> Vec { match *self { - Spec::Damage => vec![Stat::BlueDamage, Stat::RedDamage, Stat::GreenDamage], - Spec::RedDamageI => vec![Stat::RedDamage], - Spec::GreenDamageI => vec![Stat::GreenDamage], - Spec::BlueDamageI => vec![Stat::BlueDamage], - Spec::GRDI => vec![Stat::GreenDamage, Stat::RedDamage], - Spec::GBDI => vec![Stat::GreenDamage, Stat::BlueDamage], - Spec::RBDI => vec![Stat::RedDamage, Stat::BlueDamage], + Spec::Power => vec![Stat::BluePower, Stat::RedPower, Stat::GreenPower], + Spec::RedPowerI => vec![Stat::RedPower], + Spec::GreenPowerI => vec![Stat::GreenPower], + Spec::BluePowerI => vec![Stat::BluePower], + Spec::GRDI => vec![Stat::GreenPower, Stat::RedPower], + Spec::GBDI => vec![Stat::GreenPower, Stat::BluePower], + Spec::RBDI => vec![Stat::RedPower, Stat::BluePower], Spec::Speed => vec![Stat::Speed], Spec::RedSpeedI => vec![Stat::Speed], @@ -62,23 +62,23 @@ impl Spec { pub fn apply(&self, modified: u64, base: u64, construct_colours: &Colours, player_colours: &Colours) -> u64 { let construct_colour_total: u64 = (construct_colours.red + construct_colours.green + construct_colours.blue) as u64; match *self { - // Upgrades to Damage Spec - Spec::Damage => modified + base.pct(5), - Spec::RedDamageI => modified + { + // Upgrades to Power Spec + Spec::Power => modified + base.pct(5), + Spec::RedPowerI => modified + { let mut pct = 10; if player_colours.red >= 5 { pct += 10 }; if player_colours.red >= 10 { pct += 20 }; if player_colours.red >= 20 { pct += 40 }; base.pct(pct) }, - Spec::GreenDamageI => modified + { + Spec::GreenPowerI => modified + { let mut pct = 10; if player_colours.green >= 5 { pct += 10 }; if player_colours.green >= 10 { pct += 20 }; if player_colours.green >= 20 { pct += 40 }; base.pct(pct) }, - Spec::BlueDamageI => modified + { + Spec::BluePowerI => modified + { let mut pct = 10; if player_colours.blue >= 5 { pct += 10 }; if player_colours.blue >= 10 { pct += 20 }; diff --git a/server/src/vbox.rs b/server/src/vbox.rs index f551859a..e2e3c7fd 100644 --- a/server/src/vbox.rs +++ b/server/src/vbox.rs @@ -70,7 +70,7 @@ impl Vbox { ]; let specs = vec![ - (Item::Damage, 1), + (Item::Power, 1), (Item::Life, 1), (Item::Speed, 1), ];