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

damage -> power

Browse Source
This commit is contained in:
ntr 2019-05-25 16:04:52 +10:00
parent 7e2a95204e
commit 33f4cfa525
6 changed files with 174 additions and 176 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

104
server/src/construct.rs
View File

@ -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::<Vec<(Effect, Option<EffectMeta>)>>();
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::<Vec<(Effect, Option<EffectMeta>)>>();
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::<Vec<(Effect, Option<EffectMeta>)>>();
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::<Vec<(Effect, Option<EffectMeta>)>>();
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::<Vec<(Effect, Option<EffectMeta>)>>();
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::<Vec<(Effect, Option<EffectMeta>)>>();
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;
}

4
server/src/game.rs
View File

@ -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]

138
server/src/item.rs
View File

@ -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<Spec> 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> {
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 },

70
server/src/skill.rs
View File

@ -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]

32
server/src/spec.rs
View File

@ -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<Stat> {
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 };

2
server/src/vbox.rs
View File

@ -70,7 +70,7 @@ impl Vbox {
];
let specs = vec![
(Item::Damage, 1),
(Item::Power, 1),
(Item::Life, 1),
(Item::Speed, 1),
];