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

moving spec constants to server

Browse Source
This commit is contained in:
ntr 2019-05-28 15:31:01 +10:00
parent cc05e97473
commit 52bec725f7
7 changed files with 328 additions and 296 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
WORKLOG.md
View File

@ -33,6 +33,9 @@
## NOW
*CLIENT*
* fix mobile menu
* make fullscreen
* disappear on touch
*SERVER*

29
client/src/components/info.component.jsx
View File

@ -2,10 +2,9 @@ const preact = require('preact');
const range = require('lodash/range');
const { INFO } = require('./../constants');
const { SPECS } = require('./../utils');
const { COLOUR_ICONS, convertItem } = require('../utils');
function Info(args) {
function InfoComponent(args) {
const {
info,
itemInfo,
@ -24,16 +23,6 @@ function Info(args) {
const isSkill = fullInfo.skill;
const isSpec = fullInfo.spec;
let red = 0;
let blue = 0;
let green = 0;
player.constructs.forEach(construct => {
red += construct.colours.red;
blue += construct.colours.blue;
green += construct.colours.green;
});
const teamColours = { red, blue, green };
if (isSkill) {
return (
<div className="info-skill">
@ -44,8 +33,18 @@ function Info(args) {
}
if (isSpec) {
const breaks = SPECS[info].thresholds;
const colourReqs = SPECS[info].colours || [];
let red = 0;
let blue = 0;
let green = 0;
player.constructs.forEach(construct => {
red += construct.colours.red;
blue += construct.colours.blue;
green += construct.colours.green;
});
const teamColours = { red, blue, green };
const breaks = fullInfo.values;
const colourReqs = fullInfo.values || [];
const thresholdEl = colourReqs.map((c, i) => {
const numIcons = Math.max(...breaks);
@ -142,4 +141,4 @@ function Info(args) {
);
}
module.exports = Info;
module.exports = InfoComponent;

9
client/src/components/instance.equip.jsx
View File

@ -4,7 +4,7 @@ const range = require('lodash/range');
const actions = require('../actions');
const shapes = require('./shapes');
const { convertItem, SPECS } = require('./../utils');
const { convertItem } = require('./../utils');
const addState = connect(
function receiveState(state) {
@ -103,11 +103,12 @@ function Equipment(props) {
const specs = range(0, 9).map(i => {
const item = convertItem(vbox.bound[i]);
if (specList.includes(item)) {
const fullInfo = itemInfo.items.find(i => i.item === item);
if (fullInfo.spec) {
return (
<figure key={i} onClick={e => skillClick(e, i)} onMouseOver={e => hoverInfo(e, item)} >
{SPECS[item].svg(`stat-icon ${SPECS[item].colour}`)}
<figcaption>{SPECS[item].caption}</figcaption>
{shapes[fullInfo.values.shape.toLowerCase()](`stat-icon ${itemInfo[item].colour}`)}
<figcaption>{item}</figcaption>
</figure>
);
} return false;

6
client/src/socket.jsx
View File

@ -300,15 +300,15 @@ function createSocket(events) {
position: 'bottomCenter',
});
sendPing();
sendItemInfo();
if (account) {
events.setAccount(account);
sendAccountInstances();
sendAccountConstructs();
setTimeout(sendItemInfo, 2000);
}
sendPing();
return true;
});

130
client/src/utils.jsx
View File

@ -167,135 +167,6 @@ const STATS = {
},
};
const SPECS = {
Life: {
colour: 'white',
caption: 'Life',
svg: shapes.square
},
GreenLifeI: {
colour: 'green',
caption: 'Life',
thresholds: [5, 10, 20],
svg: shapes.square,
},
RedLifeI: {
colour: 'red',
caption: 'Life',
thresholds: [2, 5, 10],
svg: shapes.square,
},
BlueLifeI: {
colour: 'blue',
caption: 'Life',
thresholds: [2, 5, 10],
svg: shapes.square,
},
GRLI: {
colour: 'yellow',
caption: 'Life',
thresholds: [2, 5, 10],
svg: shapes.square
},
GBLI: {
colour: 'cyan',
caption: 'Life',
thresholds: [2, 5, 10],
svg: shapes.square
},
RBLI: {
colour: 'purple',
caption: 'Life',
thresholds: [2, 5, 10],
svg: shapes.square
},
Power: {
colour: 'white',
caption: 'Power',
thresholds: [],
svg: shapes.circle
},
RedPowerI: {
colour: 'red',
caption: 'PowerI',
thresholds: [5, 10, 20],
svg: shapes.circle
},
BluePowerI: {
colour: 'blue',
caption: 'PowerI',
thresholds: [5, 10, 20],
svg: shapes.circle
},
GreenPowerI: {
colour: 'green',
caption: 'PowerI',
thresholds: [5, 10, 20],
svg: shapes.circle,
},
GRDI: {
colour: 'yellow',
caption: 'PowerI',
thresholds: [2, 5, 10],
svg: shapes.circle
},
GBDI: {
colour: 'cyan',
caption: 'PowerI',
thresholds: [2, 5, 10],
svg: shapes.circle,
},
RBDI: {
colour: 'purple',
caption: 'PowerI',
thresholds: [2, 5, 10],
svg: shapes.circle,
},
Speed: {
colour: 'white',
caption: 'Speed',
svg: shapes.triangle,
},
RedSpeedI: {
colour: 'red',
caption: 'Speed',
thresholds: [5, 10, 20],
svg: shapes.triangle,
},
BlueSpeedI: {
colour: 'blue',
caption: 'Speed',
thresholds: [2, 5, 10],
svg: shapes.triangle,
},
GreenSpeedI: {
colour: 'green',
caption: 'Speed',
thresholds: [2, 5, 10],
svg: shapes.triangle,
},
GRSpeedI: {
colour: 'yellow',
caption: 'Speed',
thresholds: [2, 5, 10],
svg: shapes.triangle,
},
GBSpeedI: {
colour: 'cyan',
caption: 'Speed',
thresholds: [2, 5, 10],
svg: shapes.triangle,
},
RBSpeedI: {
colour: 'purple',
caption: 'Speed',
thresholds: [2, 5, 10],
svg: shapes.triangle,
},
};
const COLOUR_ICONS = {
red: { colour: 'red', caption: 'red', svg: shapes.square },
@ -599,6 +470,5 @@ module.exports = {
resoConstructHealth,
NULL_UUID,
STATS,
SPECS,
COLOUR_ICONS,
};

75
server/src/item.rs
View File

@ -1,5 +1,5 @@
use skill::{Skill, Colour};
use spec::{Spec};
use spec::{Spec, SpecValues};
use construct::{Colours};
#[derive(Debug,Copy,Clone,Serialize,Deserialize,PartialEq,PartialOrd,Ord,Eq)]
@ -26,7 +26,7 @@ pub enum Item {
LifeGGI,
LifeRRI,
LifeBBI,
LifeGRI,
LifeRGI,
LifeGBI,
LifeRBI,
@ -34,7 +34,7 @@ pub enum Item {
PowerRRI,
PowerBBI,
PowerGGI,
PowerGRI,
PowerRGI,
PowerGBI,
PowerRBI,
@ -42,7 +42,7 @@ pub enum Item {
SpeedRRI,
SpeedBBI,
SpeedGGI,
SpeedGRI,
SpeedRGI,
SpeedGBI,
SpeedRBI,
@ -350,7 +350,7 @@ impl Item {
Item::SpeedRRI => Some(Spec::SpeedRRI),
Item::SpeedBBI => Some(Spec::SpeedBBI),
Item::SpeedGGI => Some(Spec::SpeedGGI),
Item::SpeedGRI => Some(Spec::SpeedGRI),
Item::SpeedRGI => Some(Spec::SpeedRGI),
Item::SpeedGBI => Some(Spec::SpeedGBI),
Item::SpeedRBI => Some(Spec::SpeedRBI),
@ -358,12 +358,12 @@ impl Item {
Item::PowerRRI => Some(Spec::PowerRRI),
Item::PowerBBI => Some(Spec::PowerBBI),
Item::PowerGGI => Some(Spec::PowerGGI),
Item::PowerGRI => Some(Spec::PowerGRI),
Item::PowerRGI => Some(Spec::PowerRGI),
Item::PowerGBI => Some(Spec::PowerGBI),
Item::PowerRBI => Some(Spec::PowerRBI),
Item::Life => Some(Spec::Life),
Item::LifeGRI => Some(Spec::LifeGRI),
Item::LifeRGI => Some(Spec::LifeRGI),
Item::LifeGBI => Some(Spec::LifeGBI),
Item::LifeRBI => Some(Spec::LifeRBI),
Item::LifeGGI => Some(Spec::LifeGGI),
@ -418,7 +418,7 @@ impl Item {
RedDamage dealt to your construct reduces RedLife before GreenLife."),
Item::LifeBBI => format!("Increases CONSTRUCT BlueLife.
BlueDamage dealt to your construct reduces BlueLife before GreenLife."),
Item::LifeGRI => format!("Increases CONSTRUCT GreenLife + RedLife"),
Item::LifeRGI => format!("Increases CONSTRUCT GreenLife + RedLife"),
Item::LifeGBI => format!("Increases CONSTRUCT GreenLife + BlueLife"),
Item::LifeRBI => format!("Increases CONSTRUCT RedLife + BlueLife"),
@ -426,7 +426,7 @@ impl Item {
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::PowerRGI => format!("Increases CONSTRUCT GreenPower + RedPower."),
Item::PowerGBI => format!("Increases CONSTRUCT GreenPower + BluePower."),
Item::PowerRBI => format!("Increases CONSTRUCT RedPower + BluePower."),
@ -434,7 +434,7 @@ impl Item {
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::SpeedRGI => 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"),
@ -637,7 +637,7 @@ impl Item {
"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_multiplier() - 100,
self.into_skill().unwrap().effect().last().unwrap().get_duration()),
Item::TriageI |
@ -752,21 +752,21 @@ impl Item {
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::PowerRGI => 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::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::LifeRGI => 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::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::SpeedRGI => 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],
@ -894,7 +894,7 @@ impl From<Spec> for Item {
Spec::SpeedRRI => Item::SpeedRRI,
Spec::SpeedBBI => Item::SpeedBBI,
Spec::SpeedGGI => Item::SpeedGGI,
Spec::SpeedGRI => Item::SpeedGRI,
Spec::SpeedRGI => Item::SpeedRGI,
Spec::SpeedGBI => Item::SpeedGBI,
Spec::SpeedRBI => Item::SpeedRBI,
@ -902,12 +902,12 @@ impl From<Spec> for Item {
Spec::PowerRRI => Item::PowerRRI,
Spec::PowerBBI => Item::PowerBBI,
Spec::PowerGGI => Item::PowerGGI,
Spec::PowerGRI => Item::PowerGRI,
Spec::PowerRGI => Item::PowerRGI,
Spec::PowerGBI => Item::PowerGBI,
Spec::PowerRBI => Item::PowerRBI,
Spec::Life => Item::Life,
Spec::LifeGRI => Item::LifeGRI,
Spec::LifeRGI => Item::LifeRGI,
Spec::LifeGBI => Item::LifeGBI,
Spec::LifeRBI => Item::LifeRBI,
Spec::LifeGGI => Item::LifeGGI,
@ -1041,21 +1041,21 @@ pub fn get_combos() -> Vec<Combo> {
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::PowerRGI.combo(), item: Item::PowerRGI },
Combo { components: Item::PowerGBI.combo(), item: Item::PowerGBI },
Combo { components: Item::PowerRBI.combo(), item: Item::PowerRBI },
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::LifeRGI.combo(), item: Item::LifeRGI },
Combo { components: Item::LifeGBI.combo(), item: Item::LifeGBI },
Combo { components: Item::LifeRBI.combo(), item: Item::LifeRBI },
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::SpeedRGI.combo(), item: Item::SpeedRGI },
Combo { components: Item::SpeedGBI.combo(), item: Item::SpeedGBI },
Combo { components: Item::SpeedRBI.combo(), item: Item::SpeedRBI },
@ -1066,11 +1066,36 @@ pub fn get_combos() -> Vec<Combo> {
return combinations;
}
#[derive(Debug,Clone,Copy,Serialize,Deserialize)]
pub enum Shape {
Circle,
Diamond,
Hexagon,
Pentagon,
Square,
Squircle,
Triangle,
Saw,
VboxColour,
}
#[derive(Debug,Clone,Copy,Serialize,Deserialize)]
pub enum ItemColour {
W,
RR,
GG,
BB,
RG,
RB,
GB,
}
#[derive(Debug,Clone,Serialize,Deserialize)]
pub struct ItemInfo {
pub item: Item,
pub spec: bool,
pub skill: bool,
pub values: Option<SpecValues>,
pub description: String,
}
@ -1101,6 +1126,10 @@ pub fn item_info() -> ItemInfoCtr {
spec: v.into_spec().is_some(),
skill: v.into_skill().is_some(),
description: v.into_description(),
values: match v.into_spec() {
Some(s) => Some(s.values()),
None => None
},
})
.collect::<Vec<ItemInfo>>();
@ -1139,4 +1168,10 @@ mod tests {
]);
}
#[test]
fn item_info_test() {
let info = item_info();
println!("{:#?}", info);
}
}

238
server/src/spec.rs
View File

@ -1,4 +1,5 @@
use construct::{Stat, Colours};
use item::{Shape, ItemColour};
use util::{IntPct};
@ -18,9 +19,11 @@ impl SpecBonus {
}
#[derive(Debug,Clone,Serialize,Deserialize)]
pub struct SpecData {
pub struct SpecValues {
pub base: u64,
pub bonuses: Vec<SpecBonus>,
pub shape: Shape,
pub colour: ItemColour,
}
@ -30,7 +33,7 @@ pub enum Spec {
SpeedRRI,
SpeedBBI,
SpeedGGI,
SpeedGRI,
SpeedRGI,
SpeedGBI,
SpeedRBI,
// Pure redLife has to come first as it applies the base amount
@ -39,7 +42,7 @@ pub enum Spec {
LifeGGI,
LifeRRI,
LifeBBI,
LifeGRI,
LifeRGI,
LifeGBI,
LifeRBI,
@ -47,7 +50,7 @@ pub enum Spec {
PowerRRI,
PowerGGI,
PowerBBI,
PowerGRI,
PowerRGI,
PowerGBI,
PowerRBI,
}
@ -59,7 +62,7 @@ impl Spec {
Spec::PowerRRI => vec![Stat::RedPower],
Spec::PowerGGI => vec![Stat::GreenPower],
Spec::PowerBBI => vec![Stat::BluePower],
Spec::PowerGRI => vec![Stat::GreenPower, Stat::RedPower],
Spec::PowerRGI => vec![Stat::GreenPower, Stat::RedPower],
Spec::PowerGBI => vec![Stat::GreenPower, Stat::BluePower],
Spec::PowerRBI => vec![Stat::RedPower, Stat::BluePower],
@ -67,7 +70,7 @@ impl Spec {
Spec::SpeedRRI => vec![Stat::Speed],
Spec::SpeedBBI => vec![Stat::Speed],
Spec::SpeedGGI => vec![Stat::Speed],
Spec::SpeedGRI => vec![Stat::Speed],
Spec::SpeedRGI => vec![Stat::Speed],
Spec::SpeedGBI => vec![Stat::Speed],
Spec::SpeedRBI => vec![Stat::Speed],
@ -75,111 +78,232 @@ impl Spec {
Spec::LifeRRI => vec![Stat::RedLife],
Spec::LifeBBI => vec![Stat::BlueLife],
Spec::LifeGGI => vec![Stat::GreenLife],
Spec::LifeGRI => vec![Stat::GreenLife, Stat::RedLife],
Spec::LifeRGI => vec![Stat::GreenLife, Stat::RedLife],
Spec::LifeGBI => vec![Stat::GreenLife, Stat::BlueLife],
Spec::LifeRBI => vec![Stat::BlueLife, Stat::RedLife],
}
}
pub fn data(&self) -> SpecData {
pub fn values(&self) -> SpecValues {
match *self {
Spec::Power => SpecData { base: 5, bonuses: vec![]},
Spec::Power => SpecValues {
colour: ItemColour::W,
base: 5,
shape: Shape::Circle,
bonuses: vec![]
},
Spec::PowerRRI => SpecData {base: 10, bonuses: vec![
Spec::PowerRRI => SpecValues {
colour: ItemColour::RR,
base: 10,
shape: Shape::Circle,
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}]},
SpecBonus { req: Colours { red: 20, green: 0, blue: 0 }, bonus: 40 }
],
},
Spec::PowerGGI => SpecData {base: 10, bonuses: vec![
Spec::PowerGGI => SpecValues {
colour: ItemColour::GG,
base: 10,
shape: Shape::Circle,
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}]},
SpecBonus { req: Colours { red: 0, green: 20, blue: 0 }, bonus: 40 }
],
},
Spec::PowerBBI => SpecData {base: 10, bonuses: vec![
Spec::PowerBBI => SpecValues {
colour: ItemColour::BB,
base: 10,
shape: Shape::Circle,
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}]},
SpecBonus { req: Colours { red: 0, green: 0, blue: 20 }, bonus: 40 }
],
},
Spec::PowerGRI => SpecData {base: 5, bonuses: vec![
Spec::PowerRGI => SpecValues {
colour: ItemColour::RG,
base: 5,
shape: Shape::Circle,
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}]},
SpecBonus { req: Colours { red: 10, green: 10, blue: 0 }, bonus: 30 }
],
},
Spec::PowerGBI => SpecData {base: 5, bonuses: vec![
Spec::PowerGBI => SpecValues {
colour: ItemColour::GB,
base: 5,
shape: Shape::Circle,
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}]},
SpecBonus { req: Colours { red: 0, green: 10, blue: 10 }, bonus: 30 }
],
},
Spec::PowerRBI => SpecData {base: 5, bonuses: vec![
Spec::PowerRBI => SpecValues {
colour: ItemColour::RB,
base: 5,
shape: Shape::Circle,
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}]},
SpecBonus { req: Colours { red: 10, green: 0, blue: 10 }, bonus: 30 }
],
},
Spec::Speed => SpecData { base: 5, bonuses: vec![]},
Spec::Speed => SpecValues {
colour: ItemColour::W,
base: 5,
shape: Shape::Triangle,
bonuses: vec![]
},
Spec::SpeedRRI => SpecData {base: 10, bonuses: vec![
Spec::SpeedRRI => SpecValues {
colour: ItemColour::RR,
base: 10,
shape: Shape::Triangle,
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}]},
SpecBonus { req: Colours { red: 20, green: 0, blue: 0 }, bonus: 40 }
],
},
Spec::SpeedGGI => SpecData {base: 10, bonuses: vec![
Spec::SpeedGGI => SpecValues {
colour: ItemColour::GG,
base: 10,
shape: Shape::Triangle,
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}]},
SpecBonus { req: Colours { red: 0, green: 20, blue: 0 }, bonus: 40 }
],
},
Spec::SpeedBBI => SpecData {base: 10, bonuses: vec![
Spec::SpeedBBI => SpecValues {
colour: ItemColour::BB,
base: 10,
shape: Shape::Triangle,
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}]},
SpecBonus { req: Colours { red: 0, green: 0, blue: 20 }, bonus: 40 }
],
},
Spec::SpeedGRI => SpecData {base: 5, bonuses: vec![
Spec::SpeedRGI => SpecValues {
colour: ItemColour::RG,
base: 5,
shape: Shape::Triangle,
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}]},
SpecBonus { req: Colours { red: 10, green: 10, blue: 0 }, bonus: 30 }
],
},
Spec::SpeedGBI => SpecData {base: 5, bonuses: vec![
Spec::SpeedGBI => SpecValues {
colour: ItemColour::GB,
base: 5,
shape: Shape::Triangle,
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}]},
SpecBonus { req: Colours { red: 0, green: 10, blue: 10 }, bonus: 30 }
],
},
Spec::SpeedRBI => SpecData {base: 5, bonuses: vec![
Spec::SpeedRBI => SpecValues {
colour: ItemColour::RB,
base: 5,
shape: Shape::Triangle,
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}]},
SpecBonus { req: Colours { red: 10, green: 0, blue: 10 }, bonus: 30 }
],
},
Spec::Life => SpecData { base: 5, bonuses: vec![]},
Spec::Life => SpecValues {
colour: ItemColour::W,
base: 5,
shape: Shape::Square,
bonuses: vec![]},
Spec::LifeRRI => SpecData {base: 10, bonuses: vec![
Spec::LifeRRI => SpecValues {
colour: ItemColour::RR,
base: 10,
shape: Shape::Square,
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}]},
SpecBonus { req: Colours { red: 20, green: 0, blue: 0 }, bonus: 40 }
],
},
Spec::LifeGGI => SpecData {base: 10, bonuses: vec![
Spec::LifeGGI => SpecValues {
colour: ItemColour::GG,
base: 10,
shape: Shape::Square,
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}]},
SpecBonus { req: Colours { red: 0, green: 20, blue: 0 }, bonus: 40 }
],
},
Spec::LifeBBI => SpecData {base: 10, bonuses: vec![
Spec::LifeBBI => SpecValues {
colour: ItemColour::BB,
base: 10,
shape: Shape::Square,
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}]},
SpecBonus { req: Colours { red: 0, green: 0, blue: 20 }, bonus: 40 }
],
},
Spec::LifeGRI => SpecData {base: 5, bonuses: vec![
Spec::LifeRGI => SpecValues {
colour: ItemColour::RG,
base: 5,
shape: Shape::Square,
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}]},
SpecBonus { req: Colours { red: 10, green: 10, blue: 0 }, bonus: 30 }
],
},
Spec::LifeGBI => SpecData {base: 5, bonuses: vec![
Spec::LifeGBI => SpecValues {
colour: ItemColour::GB,
base: 5,
shape: Shape::Square,
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}]},
SpecBonus { req: Colours { red: 0, green: 10, blue: 10 }, bonus: 30 }
],
},
Spec::LifeRBI => SpecData {base: 5, bonuses: vec![
Spec::LifeRBI => SpecValues {
colour: ItemColour::RB,
base: 5,
shape: Shape::Square,
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}]},
SpecBonus { req: Colours { red: 10, green: 0, blue: 10 }, bonus: 30 }
],
},
}
}
@ -191,31 +315,31 @@ impl Spec {
Spec::PowerRRI |
Spec::PowerGGI |
Spec::PowerBBI |
Spec::PowerGRI |
Spec::PowerRGI |
Spec::PowerGBI |
Spec::PowerRBI |
Spec::Speed |
Spec::SpeedRRI |
Spec::SpeedGGI |
Spec::SpeedBBI |
Spec::SpeedGRI |
Spec::SpeedRGI |
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)))
let spec_values = self.values();
base.pct(spec_values.bonuses.iter()
.fold(spec_values.base, |acc, s| acc + s.get_bonus(player_colours)))
},
Spec::Life |
Spec::LifeRRI |
Spec::LifeGGI |
Spec::LifeBBI |
Spec::LifeGRI |
Spec::LifeRGI |
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)))
let spec_values = self.values();
construct_colour_total * (spec_values.bonuses.iter()
.fold(spec_values.base, |acc, s| acc + s.get_bonus(player_colours)))
},
}
}