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

reworked spec calculation structure

Browse Source
This commit is contained in:
Mashy 2019-05-28 14:20:48 +10:00
parent 0b7473382b
commit cc05e97473
3 changed files with 309 additions and 286 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
server/src/construct.rs
View File

@ -876,10 +876,10 @@ mod tests {
.named(&"redboi".to_string()); .named(&"redboi".to_string());
construct.learn_mut(Skill::StrikeI); construct.learn_mut(Skill::StrikeI);
construct.spec_add(Spec::GreenLifeI).unwrap(); construct.spec_add(Spec::LifeGGI).unwrap();
construct.spec_add(Spec::RedPowerI).unwrap(); construct.spec_add(Spec::PowerRRI).unwrap();
construct.spec_add(Spec::RedPowerI).unwrap(); construct.spec_add(Spec::PowerRRI).unwrap();
construct.spec_add(Spec::BlueLifeI).unwrap(); construct.spec_add(Spec::LifeBBI).unwrap();
assert_eq!(construct.colours.red, 6); assert_eq!(construct.colours.red, 6);
assert_eq!(construct.colours.green, 2); assert_eq!(construct.colours.green, 2);
@ -893,9 +893,9 @@ mod tests {
let mut construct = Construct::new() let mut construct = Construct::new()
.named(&"player player".to_string()); .named(&"player player".to_string());
construct.spec_add(Spec::RedPowerI).unwrap(); construct.spec_add(Spec::PowerRRI).unwrap();
construct.spec_add(Spec::GreenPowerI).unwrap(); construct.spec_add(Spec::PowerGGI).unwrap();
construct.spec_add(Spec::BluePowerI).unwrap(); construct.spec_add(Spec::PowerBBI).unwrap();
let player_colours = Colours { let player_colours = Colours {
red: 5, red: 5,

222
server/src/item.rs
View File

@ -23,28 +23,28 @@ pub enum Item {
Speed, Speed,
// Lifes Upgrades // Lifes Upgrades
GreenLifeI, LifeGGI,
RedLifeI, LifeRRI,
BlueLifeI, LifeBBI,
GRLI, LifeGRI,
GBLI, LifeGBI,
RBLI, LifeRBI,
// Power Upgrades // Power Upgrades
RedPowerI, PowerRRI,
BluePowerI, PowerBBI,
GreenPowerI, PowerGGI,
GRDI, PowerGRI,
GBDI, PowerGBI,
RBDI, PowerRBI,
// Speed Upgrades // Speed Upgrades
RedSpeedI, SpeedRRI,
BlueSpeedI, SpeedBBI,
GreenSpeedI, SpeedGGI,
GRSpeedI, SpeedGRI,
GBSpeedI, SpeedGBI,
RBSpeedI, SpeedRBI,
AmplifyI, AmplifyI,
AmplifyII, AmplifyII,
@ -347,28 +347,28 @@ impl Item {
pub fn into_spec(&self) -> Option<Spec> { pub fn into_spec(&self) -> Option<Spec> {
match *self { match *self {
Item::Speed => Some(Spec::Speed), Item::Speed => Some(Spec::Speed),
Item::RedSpeedI => Some(Spec::RedSpeedI), Item::SpeedRRI => Some(Spec::SpeedRRI),
Item::BlueSpeedI => Some(Spec::BlueSpeedI), Item::SpeedBBI => Some(Spec::SpeedBBI),
Item::GreenSpeedI => Some(Spec::GreenSpeedI), Item::SpeedGGI => Some(Spec::SpeedGGI),
Item::GRSpeedI => Some(Spec::GRSpeedI), Item::SpeedGRI => Some(Spec::SpeedGRI),
Item::GBSpeedI => Some(Spec::GBSpeedI), Item::SpeedGBI => Some(Spec::SpeedGBI),
Item::RBSpeedI => Some(Spec::RBSpeedI), Item::SpeedRBI => Some(Spec::SpeedRBI),
Item::Power => Some(Spec::Power), Item::Power => Some(Spec::Power),
Item::RedPowerI => Some(Spec::RedPowerI), Item::PowerRRI => Some(Spec::PowerRRI),
Item::BluePowerI => Some(Spec::BluePowerI), Item::PowerBBI => Some(Spec::PowerBBI),
Item::GreenPowerI => Some(Spec::GreenPowerI), Item::PowerGGI => Some(Spec::PowerGGI),
Item::GRDI => Some(Spec::GRDI), Item::PowerGRI => Some(Spec::PowerGRI),
Item::GBDI => Some(Spec::GBDI), Item::PowerGBI => Some(Spec::PowerGBI),
Item::RBDI => Some(Spec::RBDI), Item::PowerRBI => Some(Spec::PowerRBI),
Item::Life => Some(Spec::Life), Item::Life => Some(Spec::Life),
Item::GRLI => Some(Spec::GRLI), Item::LifeGRI => Some(Spec::LifeGRI),
Item::GBLI => Some(Spec::GBLI), Item::LifeGBI => Some(Spec::LifeGBI),
Item::RBLI => Some(Spec::RBLI), Item::LifeRBI => Some(Spec::LifeRBI),
Item::GreenLifeI => Some(Spec::GreenLifeI), Item::LifeGGI => Some(Spec::LifeGGI),
Item::RedLifeI => Some(Spec::RedLifeI), Item::LifeRRI => Some(Spec::LifeRRI),
Item::BlueLifeI => Some(Spec::BlueLifeI), Item::LifeBBI => Some(Spec::LifeBBI),
_ => None, _ => None,
} }
@ -412,31 +412,31 @@ impl Item {
SPEED determines the order in which skills resolve."), SPEED determines the order in which skills resolve."),
// Lifes Upgrades // 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."), 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."), 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."), BlueDamage dealt to your construct reduces BlueLife before GreenLife."),
Item::GRLI => format!("Increases CONSTRUCT GreenLife + RedLife"), Item::LifeGRI => format!("Increases CONSTRUCT GreenLife + RedLife"),
Item::GBLI => format!("Increases CONSTRUCT GreenLife + BlueLife"), Item::LifeGBI => format!("Increases CONSTRUCT GreenLife + BlueLife"),
Item::RBLI => format!("Increases CONSTRUCT RedLife + BlueLife"), Item::LifeRBI => format!("Increases CONSTRUCT RedLife + BlueLife"),
// Power Upgrades // Power Upgrades
Item::RedPowerI => format!("Increases CONSTRUCT RedPower."), Item::PowerRRI => format!("Increases CONSTRUCT RedPower."),
Item::BluePowerI => format!("Increases CONSTRUCT BluePower."), Item::PowerBBI => format!("Increases CONSTRUCT BluePower."),
Item::GreenPowerI => format!("Increases CONSTRUCT GreenPower."), Item::PowerGGI => format!("Increases CONSTRUCT GreenPower."),
Item::GRDI => format!("Increases CONSTRUCT GreenPower + RedPower."), Item::PowerGRI => format!("Increases CONSTRUCT GreenPower + RedPower."),
Item::GBDI => format!("Increases CONSTRUCT GreenPower + BluePower."), Item::PowerGBI => format!("Increases CONSTRUCT GreenPower + BluePower."),
Item::RBDI => format!("Increases CONSTRUCT RedPower + BluePower."), Item::PowerRBI => format!("Increases CONSTRUCT RedPower + BluePower."),
// Speed Upgrades // Speed Upgrades
Item::RedSpeedI => format!("Increases CONSTRUCT SPEED and provides COLOUR BONUSES"), Item::SpeedRRI => format!("Increases CONSTRUCT SPEED and provides COLOUR BONUSES"),
Item::BlueSpeedI => format!("Increases CONSTRUCT SPEED and provides COLOUR BONUSES"), Item::SpeedBBI => format!("Increases CONSTRUCT SPEED and provides COLOUR BONUSES"),
Item::GreenSpeedI => format!("Increases CONSTRUCT SPEED and provides COLOUR BONUSES"), Item::SpeedGGI => format!("Increases CONSTRUCT SPEED and provides COLOUR BONUSES"),
Item::GRSpeedI => format!("Increases CONSTRUCT SPEED and provides COLOUR BONUSES"), Item::SpeedGRI => format!("Increases CONSTRUCT SPEED and provides COLOUR BONUSES"),
Item::GBSpeedI => format!("Increases CONSTRUCT SPEED and provides COLOUR BONUSES"), Item::SpeedGBI => format!("Increases CONSTRUCT SPEED and provides COLOUR BONUSES"),
Item::RBSpeedI => 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 // Skills <- need to move effect mulltipliers into skills
Item::AmplifyI | Item::AmplifyI |
@ -749,26 +749,26 @@ impl Item {
Item::ChaosII => vec![Item::ChaosI, Item::ChaosI, Item::ChaosI], Item::ChaosII => vec![Item::ChaosI, Item::ChaosI, Item::ChaosI],
Item::ChaosIII => vec![Item::ChaosII, Item::ChaosII, Item::ChaosII], Item::ChaosIII => vec![Item::ChaosII, Item::ChaosII, Item::ChaosII],
Item::RedPowerI => vec![Item::Power, Item::Red, Item::Red], Item::PowerRRI => vec![Item::Power, Item::Red, Item::Red],
Item::GreenPowerI => vec![Item::Power, Item::Green, Item::Green], Item::PowerGGI => vec![Item::Power, Item::Green, Item::Green],
Item::BluePowerI => vec![Item::Power, Item::Blue, Item::Blue], Item::PowerBBI => vec![Item::Power, Item::Blue, Item::Blue],
Item::GRDI => vec![Item::Power, Item::Red, Item::Green], Item::PowerGRI => vec![Item::Power, Item::Red, Item::Green],
Item::GBDI => vec![Item::Power, Item::Green, Item::Blue], Item::PowerGBI => vec![Item::Power, Item::Green, Item::Blue],
Item::RBDI => vec![Item::Power, Item::Red, Item::Blue], Item::PowerRBI => vec![Item::Power, Item::Red, Item::Blue],
Item::RedLifeI => vec![Item::Life, Item::Red, Item::Red], Item::LifeRRI => vec![Item::Life, Item::Red, Item::Red],
Item::GreenLifeI => vec![Item::Life, Item::Green, Item::Green], Item::LifeGGI => vec![Item::Life, Item::Green, Item::Green],
Item::BlueLifeI => vec![Item::Life, Item::Blue, Item::Blue], Item::LifeBBI => vec![Item::Life, Item::Blue, Item::Blue],
Item::GRLI => vec![Item::Life, Item::Red, Item::Green], Item::LifeGRI => vec![Item::Life, Item::Red, Item::Green],
Item::GBLI => vec![Item::Life, Item::Green, Item::Blue], Item::LifeGBI => vec![Item::Life, Item::Green, Item::Blue],
Item::RBLI => vec![Item::Life, Item::Red, Item::Blue], Item::LifeRBI => vec![Item::Life, Item::Red, Item::Blue],
Item::RedSpeedI => vec![Item::Speed, Item::Red, Item::Red], Item::SpeedRRI => vec![Item::Speed, Item::Red, Item::Red],
Item::GreenSpeedI => vec![Item::Speed, Item::Green, Item::Green], Item::SpeedGGI => vec![Item::Speed, Item::Green, Item::Green],
Item::BlueSpeedI => vec![Item::Speed, Item::Blue, Item::Blue], Item::SpeedBBI => vec![Item::Speed, Item::Blue, Item::Blue],
Item::GRSpeedI => vec![Item::Speed, Item::Red, Item::Green], Item::SpeedGRI => vec![Item::Speed, Item::Red, Item::Green],
Item::GBSpeedI => vec![Item::Speed, Item::Green, Item::Blue], Item::SpeedGBI => vec![Item::Speed, Item::Green, Item::Blue],
Item::RBSpeedI => vec![Item::Speed, Item::Red, Item::Blue], Item::SpeedRBI => vec![Item::Speed, Item::Red, Item::Blue],
_ => vec![*self], _ => vec![*self],
} }
@ -890,29 +890,29 @@ impl From<Skill> for Item {
impl From<Spec> for Item { impl From<Spec> for Item {
fn from(spec: Spec) -> Item { fn from(spec: Spec) -> Item {
match spec { match spec {
Spec::Speed => Item::Speed, Spec::Speed => Item::Speed,
Spec::RedSpeedI => Item::RedSpeedI, Spec::SpeedRRI => Item::SpeedRRI,
Spec::BlueSpeedI => Item::BlueSpeedI, Spec::SpeedBBI => Item::SpeedBBI,
Spec::GreenSpeedI => Item::GreenSpeedI, Spec::SpeedGGI => Item::SpeedGGI,
Spec::GRSpeedI => Item::GRSpeedI, Spec::SpeedGRI => Item::SpeedGRI,
Spec::GBSpeedI => Item::GBSpeedI, Spec::SpeedGBI => Item::SpeedGBI,
Spec::RBSpeedI => Item::RBSpeedI, Spec::SpeedRBI => Item::SpeedRBI,
Spec::Power => Item::Power, Spec::Power => Item::Power,
Spec::RedPowerI => Item::RedPowerI, Spec::PowerRRI => Item::PowerRRI,
Spec::BluePowerI => Item::BluePowerI, Spec::PowerBBI => Item::PowerBBI,
Spec::GreenPowerI => Item::GreenPowerI, Spec::PowerGGI => Item::PowerGGI,
Spec::GRDI => Item::GRDI, Spec::PowerGRI => Item::PowerGRI,
Spec::GBDI => Item::GBDI, Spec::PowerGBI => Item::PowerGBI,
Spec::RBDI => Item::RBDI, Spec::PowerRBI => Item::PowerRBI,
Spec::Life => Item::Life, Spec::Life => Item::Life,
Spec::GRLI => Item::GRLI, Spec::LifeGRI => Item::LifeGRI,
Spec::GBLI => Item::GBLI, Spec::LifeGBI => Item::LifeGBI,
Spec::RBLI => Item::RBLI, Spec::LifeRBI => Item::LifeRBI,
Spec::GreenLifeI => Item::GreenLifeI, Spec::LifeGGI => Item::LifeGGI,
Spec::RedLifeI => Item::RedLifeI, Spec::LifeRRI => Item::LifeRRI,
Spec::BlueLifeI => Item::BlueLifeI, Spec::LifeBBI => Item::LifeBBI,
// _ => panic!("{:?} not implemented as a item", spec), // _ => panic!("{:?} not implemented as a item", spec),
} }
} }
@ -1038,26 +1038,26 @@ pub fn get_combos() -> Vec<Combo> {
Combo { components: Item::ChaosII.combo(), item: Item::ChaosII }, Combo { components: Item::ChaosII.combo(), item: Item::ChaosII },
Combo { components: Item::ChaosIII.combo(), item: Item::ChaosIII }, Combo { components: Item::ChaosIII.combo(), item: Item::ChaosIII },
Combo { components: Item::RedPowerI.combo(), item: Item::RedPowerI }, Combo { components: Item::PowerRRI.combo(), item: Item::PowerRRI },
Combo { components: Item::GreenPowerI.combo(), item: Item::GreenPowerI }, Combo { components: Item::PowerGGI.combo(), item: Item::PowerGGI },
Combo { components: Item::BluePowerI.combo(), item: Item::BluePowerI }, Combo { components: Item::PowerBBI.combo(), item: Item::PowerBBI },
Combo { components: Item::GRDI.combo(), item: Item::GRDI }, Combo { components: Item::PowerGRI.combo(), item: Item::PowerGRI },
Combo { components: Item::GBDI.combo(), item: Item::GBDI }, Combo { components: Item::PowerGBI.combo(), item: Item::PowerGBI },
Combo { components: Item::RBDI.combo(), item: Item::RBDI }, Combo { components: Item::PowerRBI.combo(), item: Item::PowerRBI },
Combo { components: Item::RedLifeI.combo(), item: Item::RedLifeI }, Combo { components: Item::LifeRRI.combo(), item: Item::LifeRRI },
Combo { components: Item::GreenLifeI.combo(), item: Item::GreenLifeI }, Combo { components: Item::LifeGGI.combo(), item: Item::LifeGGI },
Combo { components: Item::BlueLifeI.combo(), item: Item::BlueLifeI }, Combo { components: Item::LifeBBI.combo(), item: Item::LifeBBI },
Combo { components: Item::GRLI.combo(), item: Item::GRLI }, Combo { components: Item::LifeGRI.combo(), item: Item::LifeGRI },
Combo { components: Item::GBLI.combo(), item: Item::GBLI }, Combo { components: Item::LifeGBI.combo(), item: Item::LifeGBI },
Combo { components: Item::RBLI.combo(), item: Item::RBLI }, Combo { components: Item::LifeRBI.combo(), item: Item::LifeRBI },
Combo { components: Item::RedSpeedI.combo(), item: Item::RedSpeedI }, Combo { components: Item::SpeedRRI.combo(), item: Item::SpeedRRI },
Combo { components: Item::GreenSpeedI.combo(), item: Item::GreenSpeedI }, Combo { components: Item::SpeedGGI.combo(), item: Item::SpeedGGI },
Combo { components: Item::BlueSpeedI.combo(), item: Item::BlueSpeedI }, Combo { components: Item::SpeedBBI.combo(), item: Item::SpeedBBI },
Combo { components: Item::GRSpeedI.combo(), item: Item::GRSpeedI }, Combo { components: Item::SpeedGRI.combo(), item: Item::SpeedGRI },
Combo { components: Item::GBSpeedI.combo(), item: Item::GBSpeedI }, Combo { components: Item::SpeedGBI.combo(), item: Item::SpeedGBI },
Combo { components: Item::RBSpeedI.combo(), item: Item::RBSpeedI }, Combo { components: Item::SpeedRBI.combo(), item: Item::SpeedRBI },
]; ];

359
server/src/spec.rs
View File

@ -1,61 +1,185 @@
use construct::{Stat, Colours}; use construct::{Stat, Colours};
use util::{IntPct}; 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<SpecBonus>,
}
#[derive(Debug,Copy,Clone,Serialize,Deserialize,PartialEq,PartialOrd,Ord,Eq)] #[derive(Debug,Copy,Clone,Serialize,Deserialize,PartialEq,PartialOrd,Ord,Eq)]
pub enum Spec { pub enum Spec {
Speed, Speed,
RedSpeedI, SpeedRRI,
BlueSpeedI, SpeedBBI,
GreenSpeedI, SpeedGGI,
GRSpeedI, SpeedGRI,
GBSpeedI, SpeedGBI,
RBSpeedI, SpeedRBI,
// Pure redLife has to come first as it applies the base amount // Pure redLife has to come first as it applies the base amount
// that is multiplied // that is multiplied
Life, Life,
GreenLifeI, LifeGGI,
RedLifeI, LifeRRI,
BlueLifeI, LifeBBI,
GRLI, LifeGRI,
GBLI, LifeGBI,
RBLI, LifeRBI,
Power, Power,
RedPowerI, PowerRRI,
GreenPowerI, PowerGGI,
BluePowerI, PowerBBI,
GRDI, PowerGRI,
GBDI, PowerGBI,
RBDI, PowerRBI,
} }
impl Spec { impl Spec {
pub fn affects(&self) -> Vec<Stat> { pub fn affects(&self) -> Vec<Stat> {
match *self { match *self {
Spec::Power => vec![Stat::BluePower, Stat::RedPower, Stat::GreenPower], Spec::Power => vec![Stat::BluePower, Stat::RedPower, Stat::GreenPower],
Spec::RedPowerI => vec![Stat::RedPower], Spec::PowerRRI => vec![Stat::RedPower],
Spec::GreenPowerI => vec![Stat::GreenPower], Spec::PowerGGI => vec![Stat::GreenPower],
Spec::BluePowerI => vec![Stat::BluePower], Spec::PowerBBI => vec![Stat::BluePower],
Spec::GRDI => vec![Stat::GreenPower, Stat::RedPower], Spec::PowerGRI => vec![Stat::GreenPower, Stat::RedPower],
Spec::GBDI => vec![Stat::GreenPower, Stat::BluePower], Spec::PowerGBI => vec![Stat::GreenPower, Stat::BluePower],
Spec::RBDI => vec![Stat::RedPower, Stat::BluePower], Spec::PowerRBI => vec![Stat::RedPower, Stat::BluePower],
Spec::Speed => vec![Stat::Speed], Spec::Speed => vec![Stat::Speed],
Spec::RedSpeedI => vec![Stat::Speed], Spec::SpeedRRI => vec![Stat::Speed],
Spec::BlueSpeedI => vec![Stat::Speed], Spec::SpeedBBI => vec![Stat::Speed],
Spec::GreenSpeedI => vec![Stat::Speed], Spec::SpeedGGI => vec![Stat::Speed],
Spec::GRSpeedI => vec![Stat::Speed], Spec::SpeedGRI => vec![Stat::Speed],
Spec::GBSpeedI => vec![Stat::Speed], Spec::SpeedGBI => vec![Stat::Speed],
Spec::RBSpeedI => vec![Stat::Speed], Spec::SpeedRBI => vec![Stat::Speed],
Spec::Life => vec![Stat::GreenLife], Spec::Life => vec![Stat::GreenLife],
Spec::RedLifeI => vec![Stat::RedLife], Spec::LifeRRI => vec![Stat::RedLife],
Spec::BlueLifeI => vec![Stat::BlueLife], Spec::LifeBBI => vec![Stat::BlueLife],
Spec::GreenLifeI => vec![Stat::GreenLife], Spec::LifeGGI => vec![Stat::GreenLife],
Spec::GRLI => vec![Stat::GreenLife, Stat::RedLife], Spec::LifeGRI => vec![Stat::GreenLife, Stat::RedLife],
Spec::GBLI => vec![Stat::GreenLife, Stat::BlueLife], Spec::LifeGBI => vec![Stat::GreenLife, Stat::BlueLife],
Spec::RBLI => vec![Stat::BlueLife, Stat::RedLife], 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; let construct_colour_total: u64 = (construct_colours.red + construct_colours.green + construct_colours.blue) as u64;
match *self { match *self {
// Upgrades to Power Spec // Upgrades to Power Spec
Spec::Power => modified + base.pct(5), Spec::Power |
Spec::RedPowerI => modified + { Spec::PowerRRI |
let mut pct = 10; Spec::PowerGGI |
if player_colours.red >= 5 { pct += 10 }; Spec::PowerBBI |
if player_colours.red >= 10 { pct += 20 }; Spec::PowerGRI |
if player_colours.red >= 20 { pct += 40 }; Spec::PowerGBI |
base.pct(pct) 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; Spec::Life |
if player_colours.green >= 5 { pct += 10 }; Spec::LifeRRI |
if player_colours.green >= 10 { pct += 20 }; Spec::LifeGGI |
if player_colours.green >= 20 { pct += 40 }; Spec::LifeBBI |
base.pct(pct) Spec::LifeGRI |
}, Spec::LifeGBI |
Spec::BluePowerI => modified + { Spec::LifeRBI => modified + {
let mut pct = 10; let spec_data = self.data();
if player_colours.blue >= 5 { pct += 10 }; construct_colour_total * (spec_data.bonuses.iter()
if player_colours.blue >= 10 { pct += 20 }; .fold(spec_data.base, |acc, s| acc + s.get_bonus(player_colours)))
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
}, },
} }
} }