From cc05e97473a31b636721312410bdae3ab37fdd5e Mon Sep 17 00:00:00 2001 From: Mashy Date: Tue, 28 May 2019 14:20:48 +1000 Subject: [PATCH] reworked spec calculation structure --- server/src/construct.rs | 14 +- server/src/item.rs | 222 ++++++++++++------------- server/src/spec.rs | 359 +++++++++++++++++++++------------------- 3 files changed, 309 insertions(+), 286 deletions(-) diff --git a/server/src/construct.rs b/server/src/construct.rs index 6d917ea7..f0db76e8 100644 --- a/server/src/construct.rs +++ b/server/src/construct.rs @@ -876,10 +876,10 @@ mod tests { .named(&"redboi".to_string()); construct.learn_mut(Skill::StrikeI); - construct.spec_add(Spec::GreenLifeI).unwrap(); - construct.spec_add(Spec::RedPowerI).unwrap(); - construct.spec_add(Spec::RedPowerI).unwrap(); - construct.spec_add(Spec::BlueLifeI).unwrap(); + construct.spec_add(Spec::LifeGGI).unwrap(); + construct.spec_add(Spec::PowerRRI).unwrap(); + construct.spec_add(Spec::PowerRRI).unwrap(); + construct.spec_add(Spec::LifeBBI).unwrap(); assert_eq!(construct.colours.red, 6); assert_eq!(construct.colours.green, 2); @@ -893,9 +893,9 @@ mod tests { let mut construct = Construct::new() .named(&"player player".to_string()); - construct.spec_add(Spec::RedPowerI).unwrap(); - construct.spec_add(Spec::GreenPowerI).unwrap(); - construct.spec_add(Spec::BluePowerI).unwrap(); + construct.spec_add(Spec::PowerRRI).unwrap(); + construct.spec_add(Spec::PowerGGI).unwrap(); + construct.spec_add(Spec::PowerBBI).unwrap(); let player_colours = Colours { red: 5, diff --git a/server/src/item.rs b/server/src/item.rs index 66db8759..fb8f550c 100644 --- a/server/src/item.rs +++ b/server/src/item.rs @@ -23,28 +23,28 @@ pub enum Item { Speed, // Lifes Upgrades - GreenLifeI, - RedLifeI, - BlueLifeI, - GRLI, - GBLI, - RBLI, + LifeGGI, + LifeRRI, + LifeBBI, + LifeGRI, + LifeGBI, + LifeRBI, // Power Upgrades - RedPowerI, - BluePowerI, - GreenPowerI, - GRDI, - GBDI, - RBDI, + PowerRRI, + PowerBBI, + PowerGGI, + PowerGRI, + PowerGBI, + PowerRBI, // Speed Upgrades - RedSpeedI, - BlueSpeedI, - GreenSpeedI, - GRSpeedI, - GBSpeedI, - RBSpeedI, + SpeedRRI, + SpeedBBI, + SpeedGGI, + SpeedGRI, + SpeedGBI, + SpeedRBI, AmplifyI, AmplifyII, @@ -347,28 +347,28 @@ impl Item { pub fn into_spec(&self) -> Option { match *self { Item::Speed => Some(Spec::Speed), - Item::RedSpeedI => Some(Spec::RedSpeedI), - Item::BlueSpeedI => Some(Spec::BlueSpeedI), - Item::GreenSpeedI => Some(Spec::GreenSpeedI), - Item::GRSpeedI => Some(Spec::GRSpeedI), - Item::GBSpeedI => Some(Spec::GBSpeedI), - Item::RBSpeedI => Some(Spec::RBSpeedI), + Item::SpeedRRI => Some(Spec::SpeedRRI), + Item::SpeedBBI => Some(Spec::SpeedBBI), + Item::SpeedGGI => Some(Spec::SpeedGGI), + Item::SpeedGRI => Some(Spec::SpeedGRI), + Item::SpeedGBI => Some(Spec::SpeedGBI), + Item::SpeedRBI => Some(Spec::SpeedRBI), 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), + Item::PowerRRI => Some(Spec::PowerRRI), + Item::PowerBBI => Some(Spec::PowerBBI), + Item::PowerGGI => Some(Spec::PowerGGI), + Item::PowerGRI => Some(Spec::PowerGRI), + Item::PowerGBI => Some(Spec::PowerGBI), + Item::PowerRBI => Some(Spec::PowerRBI), Item::Life => Some(Spec::Life), - Item::GRLI => Some(Spec::GRLI), - Item::GBLI => Some(Spec::GBLI), - Item::RBLI => Some(Spec::RBLI), - Item::GreenLifeI => Some(Spec::GreenLifeI), - Item::RedLifeI => Some(Spec::RedLifeI), - Item::BlueLifeI => Some(Spec::BlueLifeI), + Item::LifeGRI => Some(Spec::LifeGRI), + Item::LifeGBI => Some(Spec::LifeGBI), + Item::LifeRBI => Some(Spec::LifeRBI), + Item::LifeGGI => Some(Spec::LifeGGI), + Item::LifeRRI => Some(Spec::LifeRRI), + Item::LifeBBI => Some(Spec::LifeBBI), _ => None, } @@ -412,31 +412,31 @@ impl Item { SPEED determines the order in which skills resolve."), // Lifes Upgrades - Item::GreenLifeI => format!("Increases CONSTRUCT GreenLife. + Item::LifeGGI => format!("Increases CONSTRUCT GreenLife. When your CONSTRUCT reaches 0 GreenLife it becomes KO and cannot cast SKILLS."), - Item::RedLifeI => format!("Increases CONSTRUCT RedLife. + Item::LifeRRI => format!("Increases CONSTRUCT RedLife. RedDamage dealt to your construct reduces RedLife before GreenLife."), - Item::BlueLifeI => format!("Increases CONSTRUCT BlueLife. + Item::LifeBBI => format!("Increases CONSTRUCT BlueLife. 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"), + Item::LifeGRI => format!("Increases CONSTRUCT GreenLife + RedLife"), + Item::LifeGBI => format!("Increases CONSTRUCT GreenLife + BlueLife"), + Item::LifeRBI => format!("Increases CONSTRUCT RedLife + BlueLife"), // 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."), + Item::PowerRRI => format!("Increases CONSTRUCT RedPower."), + Item::PowerBBI => format!("Increases CONSTRUCT BluePower."), + Item::PowerGGI => format!("Increases CONSTRUCT GreenPower."), + Item::PowerGRI => format!("Increases CONSTRUCT GreenPower + RedPower."), + Item::PowerGBI => format!("Increases CONSTRUCT GreenPower + BluePower."), + Item::PowerRBI => format!("Increases CONSTRUCT RedPower + BluePower."), // Speed Upgrades - Item::RedSpeedI => format!("Increases CONSTRUCT SPEED and provides COLOUR BONUSES"), - Item::BlueSpeedI => format!("Increases CONSTRUCT SPEED and provides COLOUR BONUSES"), - Item::GreenSpeedI => format!("Increases CONSTRUCT SPEED and provides COLOUR BONUSES"), - Item::GRSpeedI => format!("Increases CONSTRUCT SPEED and provides COLOUR BONUSES"), - Item::GBSpeedI => format!("Increases CONSTRUCT SPEED and provides COLOUR BONUSES"), - Item::RBSpeedI => format!("Increases CONSTRUCT SPEED and provides COLOUR BONUSES"), + Item::SpeedRRI => format!("Increases CONSTRUCT SPEED and provides COLOUR BONUSES"), + Item::SpeedBBI => format!("Increases CONSTRUCT SPEED and provides COLOUR BONUSES"), + Item::SpeedGGI => format!("Increases CONSTRUCT SPEED and provides COLOUR BONUSES"), + Item::SpeedGRI => format!("Increases CONSTRUCT SPEED and provides COLOUR BONUSES"), + Item::SpeedGBI => format!("Increases CONSTRUCT SPEED and provides COLOUR BONUSES"), + Item::SpeedRBI => format!("Increases CONSTRUCT SPEED and provides COLOUR BONUSES"), // Skills <- need to move effect mulltipliers into skills Item::AmplifyI | @@ -749,26 +749,26 @@ impl Item { Item::ChaosII => vec![Item::ChaosI, Item::ChaosI, Item::ChaosI], Item::ChaosIII => vec![Item::ChaosII, Item::ChaosII, Item::ChaosII], - 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::PowerRRI => vec![Item::Power, Item::Red, Item::Red], + Item::PowerGGI => vec![Item::Power, Item::Green, Item::Green], + Item::PowerBBI => vec![Item::Power, Item::Blue, Item::Blue], + Item::PowerGRI => vec![Item::Power, Item::Red, Item::Green], + Item::PowerGBI => vec![Item::Power, Item::Green, Item::Blue], + Item::PowerRBI => 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], - Item::BlueLifeI => vec![Item::Life, Item::Blue, Item::Blue], - Item::GRLI => vec![Item::Life, Item::Red, Item::Green], - Item::GBLI => vec![Item::Life, Item::Green, Item::Blue], - Item::RBLI => vec![Item::Life, Item::Red, Item::Blue], + Item::LifeRRI => vec![Item::Life, Item::Red, Item::Red], + Item::LifeGGI => vec![Item::Life, Item::Green, Item::Green], + Item::LifeBBI => vec![Item::Life, Item::Blue, Item::Blue], + Item::LifeGRI => vec![Item::Life, Item::Red, Item::Green], + Item::LifeGBI => vec![Item::Life, Item::Green, Item::Blue], + Item::LifeRBI => vec![Item::Life, Item::Red, Item::Blue], - Item::RedSpeedI => vec![Item::Speed, Item::Red, Item::Red], - Item::GreenSpeedI => vec![Item::Speed, Item::Green, Item::Green], - Item::BlueSpeedI => vec![Item::Speed, Item::Blue, Item::Blue], - Item::GRSpeedI => vec![Item::Speed, Item::Red, Item::Green], - Item::GBSpeedI => vec![Item::Speed, Item::Green, Item::Blue], - Item::RBSpeedI => vec![Item::Speed, Item::Red, Item::Blue], + Item::SpeedRRI => vec![Item::Speed, Item::Red, Item::Red], + Item::SpeedGGI => vec![Item::Speed, Item::Green, Item::Green], + Item::SpeedBBI => vec![Item::Speed, Item::Blue, Item::Blue], + Item::SpeedGRI => vec![Item::Speed, Item::Red, Item::Green], + Item::SpeedGBI => vec![Item::Speed, Item::Green, Item::Blue], + Item::SpeedRBI => vec![Item::Speed, Item::Red, Item::Blue], _ => vec![*self], } @@ -890,29 +890,29 @@ impl From for Item { impl From for Item { fn from(spec: Spec) -> Item { match spec { - Spec::Speed => Item::Speed, - Spec::RedSpeedI => Item::RedSpeedI, - Spec::BlueSpeedI => Item::BlueSpeedI, - Spec::GreenSpeedI => Item::GreenSpeedI, - Spec::GRSpeedI => Item::GRSpeedI, - Spec::GBSpeedI => Item::GBSpeedI, - Spec::RBSpeedI => Item::RBSpeedI, + Spec::Speed => Item::Speed, + Spec::SpeedRRI => Item::SpeedRRI, + Spec::SpeedBBI => Item::SpeedBBI, + Spec::SpeedGGI => Item::SpeedGGI, + Spec::SpeedGRI => Item::SpeedGRI, + Spec::SpeedGBI => Item::SpeedGBI, + Spec::SpeedRBI => Item::SpeedRBI, - 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, + Spec::Power => Item::Power, + Spec::PowerRRI => Item::PowerRRI, + Spec::PowerBBI => Item::PowerBBI, + Spec::PowerGGI => Item::PowerGGI, + Spec::PowerGRI => Item::PowerGRI, + Spec::PowerGBI => Item::PowerGBI, + Spec::PowerRBI => Item::PowerRBI, - Spec::Life => Item::Life, - Spec::GRLI => Item::GRLI, - Spec::GBLI => Item::GBLI, - Spec::RBLI => Item::RBLI, - Spec::GreenLifeI => Item::GreenLifeI, - Spec::RedLifeI => Item::RedLifeI, - Spec::BlueLifeI => Item::BlueLifeI, + Spec::Life => Item::Life, + Spec::LifeGRI => Item::LifeGRI, + Spec::LifeGBI => Item::LifeGBI, + Spec::LifeRBI => Item::LifeRBI, + Spec::LifeGGI => Item::LifeGGI, + Spec::LifeRRI => Item::LifeRRI, + Spec::LifeBBI => Item::LifeBBI, // _ => panic!("{:?} not implemented as a item", spec), } } @@ -1038,26 +1038,26 @@ pub fn get_combos() -> Vec { Combo { components: Item::ChaosII.combo(), item: Item::ChaosII }, Combo { components: Item::ChaosIII.combo(), item: Item::ChaosIII }, - 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 }, + Combo { components: Item::PowerRRI.combo(), item: Item::PowerRRI }, + Combo { components: Item::PowerGGI.combo(), item: Item::PowerGGI }, + Combo { components: Item::PowerBBI.combo(), item: Item::PowerBBI }, + Combo { components: Item::PowerGRI.combo(), item: Item::PowerGRI }, + Combo { components: Item::PowerGBI.combo(), item: Item::PowerGBI }, + Combo { components: Item::PowerRBI.combo(), item: Item::PowerRBI }, - Combo { components: Item::RedLifeI.combo(), item: Item::RedLifeI }, - Combo { components: Item::GreenLifeI.combo(), item: Item::GreenLifeI }, - Combo { components: Item::BlueLifeI.combo(), item: Item::BlueLifeI }, - Combo { components: Item::GRLI.combo(), item: Item::GRLI }, - Combo { components: Item::GBLI.combo(), item: Item::GBLI }, - Combo { components: Item::RBLI.combo(), item: Item::RBLI }, + Combo { components: Item::LifeRRI.combo(), item: Item::LifeRRI }, + Combo { components: Item::LifeGGI.combo(), item: Item::LifeGGI }, + Combo { components: Item::LifeBBI.combo(), item: Item::LifeBBI }, + Combo { components: Item::LifeGRI.combo(), item: Item::LifeGRI }, + Combo { components: Item::LifeGBI.combo(), item: Item::LifeGBI }, + Combo { components: Item::LifeRBI.combo(), item: Item::LifeRBI }, - Combo { components: Item::RedSpeedI.combo(), item: Item::RedSpeedI }, - Combo { components: Item::GreenSpeedI.combo(), item: Item::GreenSpeedI }, - Combo { components: Item::BlueSpeedI.combo(), item: Item::BlueSpeedI }, - Combo { components: Item::GRSpeedI.combo(), item: Item::GRSpeedI }, - Combo { components: Item::GBSpeedI.combo(), item: Item::GBSpeedI }, - Combo { components: Item::RBSpeedI.combo(), item: Item::RBSpeedI }, + Combo { components: Item::SpeedRRI.combo(), item: Item::SpeedRRI }, + Combo { components: Item::SpeedGGI.combo(), item: Item::SpeedGGI }, + Combo { components: Item::SpeedBBI.combo(), item: Item::SpeedBBI }, + Combo { components: Item::SpeedGRI.combo(), item: Item::SpeedGRI }, + Combo { components: Item::SpeedGBI.combo(), item: Item::SpeedGBI }, + Combo { components: Item::SpeedRBI.combo(), item: Item::SpeedRBI }, ]; diff --git a/server/src/spec.rs b/server/src/spec.rs index 014c3d18..4a5b165d 100644 --- a/server/src/spec.rs +++ b/server/src/spec.rs @@ -1,61 +1,185 @@ use construct::{Stat, Colours}; use util::{IntPct}; + +#[derive(Debug,Clone,Serialize,Deserialize)] +pub struct SpecBonus { + pub req: Colours, + pub bonus: u64, +} + +impl SpecBonus { + pub fn get_bonus(&self, c: &Colours) -> u64 { + if c.red >= self.req.red && c.blue >= self.req.blue && c.green >= self.req.green { + return self.bonus; + } + return 0; + } +} + +#[derive(Debug,Clone,Serialize,Deserialize)] +pub struct SpecData { + pub base: u64, + pub bonuses: Vec, +} + + #[derive(Debug,Copy,Clone,Serialize,Deserialize,PartialEq,PartialOrd,Ord,Eq)] pub enum Spec { Speed, - RedSpeedI, - BlueSpeedI, - GreenSpeedI, - GRSpeedI, - GBSpeedI, - RBSpeedI, + SpeedRRI, + SpeedBBI, + SpeedGGI, + SpeedGRI, + SpeedGBI, + SpeedRBI, // Pure redLife has to come first as it applies the base amount // that is multiplied Life, - GreenLifeI, - RedLifeI, - BlueLifeI, - GRLI, - GBLI, - RBLI, + LifeGGI, + LifeRRI, + LifeBBI, + LifeGRI, + LifeGBI, + LifeRBI, Power, - RedPowerI, - GreenPowerI, - BluePowerI, - GRDI, - GBDI, - RBDI, + PowerRRI, + PowerGGI, + PowerBBI, + PowerGRI, + PowerGBI, + PowerRBI, } impl Spec { pub fn affects(&self) -> Vec { match *self { - 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::Power => vec![Stat::BluePower, Stat::RedPower, Stat::GreenPower], + Spec::PowerRRI => vec![Stat::RedPower], + Spec::PowerGGI => vec![Stat::GreenPower], + Spec::PowerBBI => vec![Stat::BluePower], + Spec::PowerGRI => vec![Stat::GreenPower, Stat::RedPower], + Spec::PowerGBI => vec![Stat::GreenPower, Stat::BluePower], + Spec::PowerRBI => vec![Stat::RedPower, Stat::BluePower], - Spec::Speed => vec![Stat::Speed], - Spec::RedSpeedI => vec![Stat::Speed], - Spec::BlueSpeedI => vec![Stat::Speed], - Spec::GreenSpeedI => vec![Stat::Speed], - Spec::GRSpeedI => vec![Stat::Speed], - Spec::GBSpeedI => vec![Stat::Speed], - Spec::RBSpeedI => vec![Stat::Speed], + Spec::Speed => vec![Stat::Speed], + Spec::SpeedRRI => vec![Stat::Speed], + Spec::SpeedBBI => vec![Stat::Speed], + Spec::SpeedGGI => vec![Stat::Speed], + Spec::SpeedGRI => vec![Stat::Speed], + Spec::SpeedGBI => vec![Stat::Speed], + Spec::SpeedRBI => vec![Stat::Speed], - Spec::Life => vec![Stat::GreenLife], - Spec::RedLifeI => vec![Stat::RedLife], - Spec::BlueLifeI => vec![Stat::BlueLife], - Spec::GreenLifeI => vec![Stat::GreenLife], - Spec::GRLI => vec![Stat::GreenLife, Stat::RedLife], - Spec::GBLI => vec![Stat::GreenLife, Stat::BlueLife], - Spec::RBLI => vec![Stat::BlueLife, Stat::RedLife], + Spec::Life => vec![Stat::GreenLife], + Spec::LifeRRI => vec![Stat::RedLife], + Spec::LifeBBI => vec![Stat::BlueLife], + Spec::LifeGGI => vec![Stat::GreenLife], + Spec::LifeGRI => vec![Stat::GreenLife, Stat::RedLife], + Spec::LifeGBI => vec![Stat::GreenLife, Stat::BlueLife], + Spec::LifeRBI => vec![Stat::BlueLife, Stat::RedLife], + } + } + pub fn data(&self) -> SpecData { + match *self { + Spec::Power => SpecData { base: 5, bonuses: vec![]}, + + Spec::PowerRRI => SpecData {base: 10, bonuses: vec![ + SpecBonus { req: Colours {red: 5, green: 0, blue: 0}, bonus: 10}, + SpecBonus { req: Colours {red: 10, green: 0, blue: 0}, bonus: 20}, + SpecBonus { req: Colours {red: 20, green: 0, blue: 0}, bonus: 40}]}, + + Spec::PowerGGI => SpecData {base: 10, bonuses: vec![ + SpecBonus { req: Colours {red: 0, green: 5, blue: 0}, bonus: 10}, + SpecBonus { req: Colours {red: 0, green: 10, blue: 0}, bonus: 20}, + SpecBonus { req: Colours {red: 0, green: 20, blue: 0}, bonus: 40}]}, + + Spec::PowerBBI => SpecData {base: 10, bonuses: vec![ + SpecBonus { req: Colours {red: 0, green: 0, blue: 5}, bonus: 10}, + SpecBonus { req: Colours {red: 0, green: 0, blue: 10}, bonus: 20}, + SpecBonus { req: Colours {red: 0, green: 0, blue: 20}, bonus: 40}]}, + + Spec::PowerGRI => SpecData {base: 5, bonuses: vec![ + SpecBonus { req: Colours {red: 2, green: 2, blue: 0}, bonus: 10}, + SpecBonus { req: Colours {red: 5, green: 5, blue: 0}, bonus: 15}, + SpecBonus { req: Colours {red: 10, green: 10, blue: 0}, bonus: 30}]}, + + + Spec::PowerGBI => SpecData {base: 5, bonuses: vec![ + SpecBonus { req: Colours {red: 0, green: 2, blue: 2}, bonus: 10}, + SpecBonus { req: Colours {red: 0, green: 5, blue: 5}, bonus: 15}, + SpecBonus { req: Colours {red: 0, green: 10, blue: 10}, bonus: 30}]}, + + Spec::PowerRBI => SpecData {base: 5, bonuses: vec![ + SpecBonus { req: Colours {red: 2, green: 0, blue: 2}, bonus: 10}, + SpecBonus { req: Colours {red: 5, green: 0, blue: 5}, bonus: 15}, + SpecBonus { req: Colours {red: 10, green: 0, blue: 10}, bonus: 30}]}, + + Spec::Speed => SpecData { base: 5, bonuses: vec![]}, + + Spec::SpeedRRI => SpecData {base: 10, bonuses: vec![ + SpecBonus { req: Colours {red: 5, green: 0, blue: 0}, bonus: 10}, + SpecBonus { req: Colours {red: 10, green: 0, blue: 0}, bonus: 20}, + SpecBonus { req: Colours {red: 20, green: 0, blue: 0}, bonus: 40}]}, + + Spec::SpeedGGI => SpecData {base: 10, bonuses: vec![ + SpecBonus { req: Colours {red: 0, green: 5, blue: 0}, bonus: 10}, + SpecBonus { req: Colours {red: 0, green: 10, blue: 0}, bonus: 20}, + SpecBonus { req: Colours {red: 0, green: 20, blue: 0}, bonus: 40}]}, + + Spec::SpeedBBI => SpecData {base: 10, bonuses: vec![ + SpecBonus { req: Colours {red: 0, green: 0, blue: 5}, bonus: 10}, + SpecBonus { req: Colours {red: 0, green: 0, blue: 10}, bonus: 20}, + SpecBonus { req: Colours {red: 0, green: 0, blue: 20}, bonus: 40}]}, + + Spec::SpeedGRI => SpecData {base: 5, bonuses: vec![ + SpecBonus { req: Colours {red: 2, green: 2, blue: 0}, bonus: 10}, + SpecBonus { req: Colours {red: 5, green: 5, blue: 0}, bonus: 15}, + SpecBonus { req: Colours {red: 10, green: 10, blue: 0}, bonus: 30}]}, + + Spec::SpeedGBI => SpecData {base: 5, bonuses: vec![ + SpecBonus { req: Colours {red: 0, green: 2, blue: 2}, bonus: 10}, + SpecBonus { req: Colours {red: 0, green: 5, blue: 5}, bonus: 15}, + SpecBonus { req: Colours {red: 0, green: 10, blue: 10}, bonus: 30}]}, + + Spec::SpeedRBI => SpecData {base: 5, bonuses: vec![ + SpecBonus { req: Colours {red: 2, green: 0, blue: 2}, bonus: 10}, + SpecBonus { req: Colours {red: 5, green: 0, blue: 5}, bonus: 15}, + SpecBonus { req: Colours {red: 10, green: 0, blue: 10}, bonus: 30}]}, + + Spec::Life => SpecData { base: 5, bonuses: vec![]}, + + Spec::LifeRRI => SpecData {base: 10, bonuses: vec![ + SpecBonus { req: Colours {red: 5, green: 0, blue: 0}, bonus: 10}, + SpecBonus { req: Colours {red: 10, green: 0, blue: 0}, bonus: 20}, + SpecBonus { req: Colours {red: 20, green: 0, blue: 0}, bonus: 40}]}, + + Spec::LifeGGI => SpecData {base: 10, bonuses: vec![ + SpecBonus { req: Colours {red: 0, green: 5, blue: 0}, bonus: 10}, + SpecBonus { req: Colours {red: 0, green: 10, blue: 0}, bonus: 20}, + SpecBonus { req: Colours {red: 0, green: 20, blue: 0}, bonus: 40}]}, + + Spec::LifeBBI => SpecData {base: 10, bonuses: vec![ + SpecBonus { req: Colours {red: 0, green: 0, blue: 5}, bonus: 10}, + SpecBonus { req: Colours {red: 0, green: 0, blue: 10}, bonus: 20}, + SpecBonus { req: Colours {red: 0, green: 0, blue: 20}, bonus: 40}]}, + + Spec::LifeGRI => SpecData {base: 5, bonuses: vec![ + SpecBonus { req: Colours {red: 2, green: 2, blue: 0}, bonus: 10}, + SpecBonus { req: Colours {red: 5, green: 5, blue: 0}, bonus: 15}, + SpecBonus { req: Colours {red: 10, green: 10, blue: 0}, bonus: 30}]}, + + + Spec::LifeGBI => SpecData {base: 5, bonuses: vec![ + SpecBonus { req: Colours {red: 0, green: 2, blue: 2}, bonus: 10}, + SpecBonus { req: Colours {red: 0, green: 5, blue: 5}, bonus: 15}, + SpecBonus { req: Colours {red: 0, green: 10, blue: 10}, bonus: 30}]}, + + Spec::LifeRBI => SpecData {base: 5, bonuses: vec![ + SpecBonus { req: Colours {red: 2, green: 0, blue: 2}, bonus: 10}, + SpecBonus { req: Colours {red: 5, green: 0, blue: 5}, bonus: 15}, + SpecBonus { req: Colours {red: 10, green: 0, blue: 10}, bonus: 30}]}, } } @@ -63,136 +187,35 @@ impl Spec { let construct_colour_total: u64 = (construct_colours.red + construct_colours.green + construct_colours.blue) as u64; match *self { // 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::Power | + Spec::PowerRRI | + Spec::PowerGGI | + Spec::PowerBBI | + Spec::PowerGRI | + Spec::PowerGBI | + Spec::PowerRBI | + Spec::Speed | + Spec::SpeedRRI | + Spec::SpeedGGI | + Spec::SpeedBBI | + Spec::SpeedGRI | + Spec::SpeedGBI | + Spec::SpeedRBI => modified + { + let spec_data = self.data(); + base.pct(spec_data.bonuses.iter() + .fold(spec_data.base, |acc, s| acc + s.get_bonus(player_colours))) }, - 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::BluePowerI => modified + { - let mut pct = 10; - if player_colours.blue >= 5 { pct += 10 }; - if player_colours.blue >= 10 { pct += 20 }; - if player_colours.blue >= 20 { pct += 40 }; - base.pct(pct) - }, - Spec::GRDI => modified + { - let mut pct = 5; - if player_colours.green >= 2 && player_colours.red >= 2 { pct += 10 }; - if player_colours.green >= 5 && player_colours.red >= 5 { pct += 15 }; - if player_colours.green >= 10 && player_colours.red >= 10 { pct += 30 }; - base.pct(pct) - }, - Spec::GBDI => modified + { - let mut pct = 5; - if player_colours.green >= 2 && player_colours.blue >= 2 { pct += 10 }; - if player_colours.green >= 5 && player_colours.blue >= 5 { pct += 15 }; - if player_colours.green >= 10 && player_colours.blue >= 10 { pct += 30 }; - base.pct(pct) - }, - Spec::RBDI => modified + { - let mut pct = 5; - if player_colours.blue >= 2 && player_colours.red >= 2 { pct += 10 }; - if player_colours.blue >= 5 && player_colours.red >= 5 { pct += 15 }; - if player_colours.blue >= 10 && player_colours.red >= 10 { pct += 30 }; - base.pct(pct) - }, - // Upgrades to speed Spec - Spec::Speed => modified + base.pct(5), - Spec::RedSpeedI => modified + { - let mut pct = 5; - if player_colours.red >= 5 { pct += 5 }; - if player_colours.red >= 10 { pct += 10 }; - if player_colours.red >= 20 { pct += 20 }; - base.pct(pct) - }, - Spec::GreenSpeedI => modified + { - let mut pct = 5; - if player_colours.green >= 5 { pct += 5 }; - if player_colours.green >= 10 { pct += 10 }; - if player_colours.green >= 20 { pct += 20 }; - base.pct(pct) - }, - Spec::BlueSpeedI => modified + { - let mut pct = 5; - if player_colours.blue >= 5 { pct += 5 }; - if player_colours.blue >= 10 { pct += 10 }; - if player_colours.blue >= 20 { pct += 20 }; - base.pct(pct) - }, - Spec::GRSpeedI => modified + { - let mut pct = 5; - if player_colours.green >= 2 && player_colours.red >= 2 { pct += 5 }; - if player_colours.green >= 5 && player_colours.red >= 5 { pct += 10 }; - if player_colours.green >= 10 && player_colours.red >= 10 { pct += 20 }; - base.pct(pct) - }, - Spec::GBSpeedI => modified + { - let mut pct = 5; - if player_colours.green >= 2 && player_colours.blue >= 2 { pct += 5 }; - if player_colours.green >= 5 && player_colours.blue >= 5 { pct += 10 }; - if player_colours.green >= 10 && player_colours.blue >= 10 { pct += 20 }; - base.pct(pct) - }, - Spec::RBSpeedI => modified + { - let mut pct = 5; - if player_colours.blue >= 2 && player_colours.red >= 2 { pct += 5 }; - if player_colours.blue >= 5 && player_colours.red >= 5 { pct += 10 }; - if player_colours.blue >= 10 && player_colours.red >= 10 { pct += 20 }; - base.pct(pct) - }, - // Upgrades to HP Spec - Spec::Life => modified + base.pct(5), - Spec::GreenLifeI => modified + { - let mut mult: u64 = 25; - if player_colours.green >= 5 { mult += 15 }; - if player_colours.green >= 10 { mult += 30 }; - if player_colours.green >= 20 { mult += 45 }; - mult * construct_colour_total - }, - Spec::RedLifeI => modified + { - let mut mult: u64 = 25; - if player_colours.red >= 5 { mult += 15 }; - if player_colours.red >= 10 { mult += 30 }; - if player_colours.red >= 20 { mult += 45 }; - mult * construct_colour_total - }, - Spec::BlueLifeI => modified + { - let mut mult: u64 = 25; - if player_colours.blue >= 5 { mult += 15 }; - if player_colours.blue >= 10 { mult += 30 }; - if player_colours.blue >= 20 { mult += 45 }; - mult * construct_colour_total - }, - Spec::GRLI => modified + { - let mut mult: u64 = 15; - if player_colours.green >= 2 && player_colours.red >= 2 { mult += 10 }; - if player_colours.green >= 5 && player_colours.red >= 5 { mult += 20 }; - if player_colours.green >= 10 && player_colours.red >= 10 { mult += 40 }; - mult * construct_colour_total - }, - Spec::GBLI => modified + { - let mut mult: u64 = 15; - if player_colours.green >= 2 && player_colours.red >= 2 { mult += 10 }; - if player_colours.green >= 5 && player_colours.red >= 5 { mult += 20 }; - if player_colours.green >= 10 && player_colours.red >= 10 { mult += 40 }; - mult * construct_colour_total - }, - Spec::RBLI => modified + { - let mut mult: u64 = 15; - if player_colours.blue >= 2 && player_colours.red >= 2 { mult += 10 }; - if player_colours.blue >= 5 && player_colours.red >= 5 { mult += 20 }; - if player_colours.blue >= 10 && player_colours.red >= 10 { mult += 40 }; - mult * construct_colour_total + + Spec::Life | + Spec::LifeRRI | + Spec::LifeGGI | + Spec::LifeBBI | + Spec::LifeGRI | + Spec::LifeGBI | + Spec::LifeRBI => modified + { + let spec_data = self.data(); + construct_colour_total * (spec_data.bonuses.iter() + .fold(spec_data.base, |acc, s| acc + s.get_bonus(player_colours))) }, } }