core init

core/.cargo/config

@@ -0,0 +1,3 @@
+[target.x86_64-pc-windows-msvc.gnu]
+rustc-link-search = ["C:\\Program Files\\PostgreSQL\\pg96\\lib"]
+

core/.gitignore

@@ -0,0 +1,4 @@
+target/
+Cargo.lock
+log/
+.env

core/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "mnml-core"
+version = "1.10.0"
+authors = ["ntr <ntr@smokestack.io>", "mashy <mashy@mnml.gg>"]
+
+[dependencies]
+serde = "1"
+serde_derive = "1"
+
+rand = "0.6"
+uuid = { version = "0.5", features = ["serde", "v4"] }
+chrono = { version = "0.4", features = ["serde"] }
+bcrypt = "0.2"
+
+failure = "0.1"
+
+log = "0.4"

core/src/effect.rs

@@ -0,0 +1,209 @@
+use construct::{Stat, EffectMeta};
+use skill::{Skill};
+use util::{IntPct};
+
+pub type Cooldown = Option<u8>;
+
+#[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
+pub enum Effect {
+    Amplify,
+    Banish,
+    Block,
+    Buff,
+    Counter,
+    Curse,
+    Haste,
+    Hybrid,
+    Intercept,
+    Invert,
+    Pure,
+    Purge,
+    Reflect,
+    Restrict,
+    Silence,
+    Slow,
+    Stun,
+    Sustain,
+    Vulnerable,
+    Wither, // Reduce green dmg (healing) taken
+
+    // electric is the buff that applies
+    // electrocute the dmg debuff
+    Electric,
+    Electrocute,
+
+    // absorbtion is the buff
+    // absorb is the increased damage
+    Absorb,
+    Absorption,
+
+    // magic immunity
+
+    // effects over time
+    Triage,
+    Decay,
+    Regen,
+    Siphon,
+
+    // Airborne,
+    // Boost
+    // Bleed,
+    // Blind,
+    // Deadly,
+    // Enslave,
+    // Fury,
+    // Injured,
+    // Leech,
+    // Mesmerise,
+    // Untouchable,
+    // SpeedSiphon,
+    // SpeedIncrease,
+
+    Ko,
+}
+
+impl Effect {
+    pub fn immune(&self, skill: Skill) -> bool {
+        match self {
+            Effect::Banish => true,
+            Effect::Sustain => [
+                Skill::Stun,
+                Skill::Silence,
+                Skill::SilencePlus,
+                Skill::SilencePlusPlus,
+                Skill::Ruin,
+                Skill::RuinPlus,
+                Skill::RuinPlusPlus,
+                Skill::Restrict,
+                Skill::RestrictPlus,
+                Skill::RestrictPlusPlus
+            ].contains(&skill),
+            _ => false,
+        }
+    }
+
+    pub fn disables_skill(&self, skill: Skill) -> bool {
+        if skill.is_tick() {
+            return false;
+        }
+
+        match self {
+            Effect::Stun => true,
+            Effect::Banish => true,
+            Effect::Silence => skill.colours().contains(&Colour::Blue),
+            Effect::Restrict => skill.colours().contains(&Colour::Red),
+            Effect::Purge => skill.colours().contains(&Colour::Green),
+            Effect::Ko => skill.ko_castable(),
+            _ => false,
+        }
+    }
+
+    pub fn modifications(&self) -> Vec<Stat> {
+        match self {
+            // Bases
+            Effect::Block => vec![Stat::RedDamageTaken, Stat::BlueDamageTaken],
+            Effect::Buff => vec![Stat::BluePower, Stat::RedPower, Stat::Speed],
+            Effect::Slow => vec![Stat::Speed],
+
+            // Power changes
+            Effect::Absorption => vec![Stat::RedPower, Stat::BluePower],
+            Effect::Amplify => vec![Stat::RedPower, Stat::BluePower],
+            Effect::Hybrid => vec![Stat::GreenPower],
+
+            // Damage taken changes
+            Effect::Curse => vec![Stat::RedDamageTaken, Stat::BlueDamageTaken],
+            Effect::Pure => vec![Stat::GreenDamageTaken], // increased green taken
+            Effect::Vulnerable => vec![Stat::RedDamageTaken],
+            Effect::Wither => vec![Stat::GreenDamageTaken], // reduced green taken
+
+            // Speed
+            Effect::Haste => vec![Stat::Speed],
+
+            _ => vec![],
+        }
+    }
+
+    pub fn apply(&self, value: u64, meta: Option<EffectMeta>) -> u64 {
+        match self {
+            Effect::Amplify |
+            Effect::Vulnerable |
+            Effect::Block |
+            Effect::Buff |
+            Effect::Curse |
+            Effect::Haste |
+            Effect::Slow |
+            Effect::Hybrid |
+            Effect::Pure |
+            Effect::Wither  => value.pct(match meta {
+                Some(EffectMeta::Multiplier(d)) => d,
+                _ => 100,
+            }),
+
+            Effect::Absorption      => value + match meta {
+                Some(EffectMeta::AddedDamage(d)) => d,
+                _ => {
+                    warn!("absorb meta not damage");
+                    return 0;
+                }
+            },
+
+            _ => {
+                warn!("{:?} does not have a mod effect", self);
+                return value;
+            },
+        }
+    }
+
+    pub fn colour(&self) -> Option<Colour> {
+        match self {
+            // physical
+            Effect::Stun => Some(Colour::Red),
+            Effect::Block => Some(Colour::Green),
+            Effect::Buff => Some(Colour::Green),
+            Effect::Counter => Some(Colour::Green),
+            Effect::Vulnerable => Some(Colour::Red),
+            Effect::Restrict => Some(Colour::Red),
+            Effect::Sustain => Some(Colour::Green),
+            Effect::Intercept => Some(Colour::Green),
+
+            // magic
+            Effect::Curse => Some(Colour::Blue),
+            Effect::Banish => None,
+            // Effect::Banish => rng.gen_bool(0.5),
+
+            Effect::Slow => Some(Colour::Blue),
+            Effect::Haste => Some(Colour::Green),
+            Effect::Absorption => Some(Colour::Green),
+            Effect::Reflect => Some(Colour::Green),
+            Effect::Amplify => Some(Colour::Green),
+            Effect::Silence => Some(Colour::Blue),
+            Effect::Wither => Some(Colour::Blue),
+            Effect::Purge => Some(Colour::Blue),
+
+            Effect::Electric => Some(Colour::Green),
+            Effect::Electrocute => Some(Colour::Blue),
+
+            Effect::Absorb => Some(Colour::Green),
+
+            // magic
+            Effect::Hybrid => Some(Colour::Green),
+            Effect::Invert => Some(Colour::Green),
+
+            // effects over time
+            Effect::Triage => Some(Colour::Green),
+            Effect::Decay => Some(Colour::Blue),
+            Effect::Regen => Some(Colour::Green),
+            Effect::Siphon => Some(Colour::Blue),
+            Effect::Pure => Some(Colour::Green),
+
+            Effect::Ko => None,
+        }
+    }
+}
+
+#[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
+pub enum Colour {
+    Red,
+    Blue,
+    Green,
+}

core/src/instance.rs

@@ -0,0 +1,631 @@
+
+use std::collections::{HashMap};
+
+use uuid::Uuid;
+
+use failure::Error;
+use failure::err_msg;
+
+// timekeeping
+use chrono::prelude::*;
+use chrono::Duration;
+
+use player::{Player, Score};
+use mob::{bot_player, instance_mobs};
+use game::{Game};
+use item::{Item};
+use vbox;
+
+
+#[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
+enum InstancePhase {
+    Lobby,
+    InProgress,
+    Finished,
+}
+
+pub type ChatState = HashMap<Uuid, String>;
+
+#[derive(Debug,Clone,Serialize,Deserialize)]
+struct Round {
+    game_id: Option<Uuid>,
+    finished: bool,
+}
+
+impl Round {
+    fn new() -> Round {
+        Round { game_id: None, finished: false }
+    }
+}
+
+#[derive(Debug,Clone,Copy,Serialize,Deserialize)]
+pub enum TimeControl {
+    Standard,
+    Slow,
+    Practice,
+}
+
+impl TimeControl {
+    fn vbox_time_seconds(&self) -> i64 {
+        match self {
+            TimeControl::Standard => 180,
+            TimeControl::Slow => 240,
+            TimeControl::Practice => panic!("practice vbox seconds called"),
+        }
+    }
+
+    fn game_time_seconds(&self) -> i64 {
+        match self {
+            TimeControl::Standard => 60,
+            TimeControl::Slow => 120,
+            TimeControl::Practice => panic!("practice game seconds called"),
+        }
+    }
+
+    pub fn vbox_phase_end(&self) -> Option<DateTime<Utc>> {
+        match self {
+            TimeControl::Practice => None,
+            _ => Some(Utc::now()
+                .checked_add_signed(Duration::seconds(self.vbox_time_seconds()))
+                .expect("could not set vbox phase end")),
+        }
+    }
+
+    pub fn lobby_timeout(&self) -> DateTime<Utc> {
+        Utc::now()
+            .checked_add_signed(Duration::seconds(15))
+            .expect("could not set phase end")
+    }
+
+    pub fn game_phase_end(&self, resolution_time_ms: i64) -> Option<DateTime<Utc>> {
+        match self {
+            TimeControl::Practice => None,
+            _ => Some(Utc::now()
+                .checked_add_signed(Duration::milliseconds(self.game_time_seconds() * 1000 + resolution_time_ms))
+                .expect("could not set game phase end")),
+        }
+    }
+}
+
+#[derive(Debug,Clone,Serialize,Deserialize)]
+pub struct Instance {
+    pub id: Uuid,
+    pub name: String,
+
+    players: Vec<Player>,
+    rounds: Vec<Round>,
+
+    max_players: usize,
+    time_control: TimeControl,
+
+    phase: InstancePhase,
+    phase_end: Option<DateTime<Utc>>,
+    phase_start: DateTime<Utc>,
+
+    winner: Option<Uuid>,
+}
+
+impl Instance {
+    fn new() -> Instance {
+        Instance {
+            id: Uuid::new_v4(),
+            players: vec![],
+            rounds: vec![],
+            phase: InstancePhase::Lobby,
+            max_players: 2,
+            name: String::new(),
+            time_control: TimeControl::Standard,
+            phase_start: Utc::now(),
+            phase_end: Some(TimeControl::Standard.lobby_timeout()),
+            winner: None,
+        }
+    }
+
+    pub fn redact(mut self, account: Uuid) -> Instance {
+        self.players = self.players.into_iter()
+            .map(|p| p.redact(account))
+            .collect();
+
+        self
+    }
+
+    fn phase_timed_out(&self) -> bool {
+        match self.phase_end {
+            Some(t) => Utc::now().signed_duration_since(t).num_milliseconds() > 0,
+            None => false,
+        }
+    }
+
+    fn timed_out_players(&self) -> Vec<Uuid> {
+        self.players
+            .iter()
+            .filter(|p| !p.ready)
+            .map(|p| p.id)
+            .collect::<Vec<Uuid>>()
+    }
+
+    pub fn upkeep(mut self) -> (Instance, Option<Game>) {
+        // time out lobbies that have been open too long
+        if self.phase == InstancePhase::Lobby && self.phase_timed_out() {
+            self.finish();
+            return (self, None);
+        }
+
+        if self.phase != InstancePhase::InProgress {
+            return (self, None);
+        }
+
+        if !self.phase_timed_out() {
+            return (self, None);
+        }
+
+        let new_game = self
+            .timed_out_players()
+            .iter()
+            .filter_map(|p| self.player_ready(*p).unwrap())
+            .collect::<Vec<Game>>()
+            .into_iter()
+            .next();
+
+        (self, new_game)
+    }
+
+    fn set_name(mut self, name: String) -> Result<Instance, Error> {
+        if name.len() == 0 {
+            return Err(err_msg("name must have a length"));
+        }
+
+        self.name = name;
+        Ok(self)
+    }
+
+    fn set_time_control(mut self, tc: TimeControl) -> Instance {
+        self.time_control = tc;
+        self
+    }
+
+    fn add_player(&mut self, player: Player) -> Result<&mut Instance, Error> {
+        if self.players.len() >= self.max_players {
+            return Err(err_msg("game full"))
+        }
+
+        match self.players.iter().find(|p| p.id == player.id) {
+            Some(_p) => return Err(err_msg("already joined")),
+            None => (),
+        };
+
+        self.players.push(player);
+        Ok(self)
+    }
+
+    fn player_ready(&mut self, player_id: Uuid) -> Result<Option<Game>, Error> {
+        if ![InstancePhase::InProgress, InstancePhase::Lobby].contains(&self.phase) {
+            return Err(err_msg("instance not in start or vbox phase"));
+        }
+
+        // LOBBY CHECKS
+        if self.phase == InstancePhase::Lobby {
+            let i = self.players
+                .iter_mut()
+                .position(|p| p.id == player_id)
+                .ok_or(err_msg("player_id not found"))?;
+
+            let v = !self.players[i].ready;
+            self.players[i].set_ready(v);
+
+            match self.can_start() {
+                true => {
+                    self.start();
+                    return Ok(None);
+                }
+                false => return Ok(None),
+            };
+        }
+
+        // GAME PHASE READY
+        let i = self.players
+            .iter_mut()
+            .position(|p| p.id == player_id)
+            .ok_or(err_msg("player_id not found"))?;
+
+        let v = !self.players[i].ready;
+        self.players[i].set_ready(v);
+
+        // start the game even if afk noobs have no skills
+        if !self.phase_timed_out() && self.players[i].constructs.iter().all(|c| c.skills.len() == 0) {
+            return Err(err_msg("your constructs have no skills"));
+        }
+
+        // create a game object if both players are ready
+        // this should only happen once
+
+        let all_ready = self.round_ready_check();
+
+        if !all_ready {
+            return Ok(None);
+        }
+
+        let game = self.create_round_game();
+
+        let current_round = self.rounds
+            .last_mut()
+            .expect("instance does not have any rounds");
+
+        current_round.game_id = Some(game.id);
+
+        return Ok(Some(game));
+
+    }
+
+    fn round_ready_check(&mut self) -> bool {
+        self.players
+            .iter()
+            .all(|p| p.ready)
+    }
+
+    // maybe just embed the games in the instance
+    // but seems hella inefficient
+    fn create_round_game(&mut self) -> Game {
+        let current_round = self.rounds
+            .last_mut()
+            .expect("instance does not have any rounds");
+
+
+        let mut game = Game::new();
+        current_round.game_id = Some(game.id);
+
+        // disable upkeep until players finish their game
+        self.phase_end = None;
+
+        game
+            .set_player_num(2)
+            .set_player_constructs(3)
+            .set_time_control(self.time_control)
+            .set_instance(self.id);
+
+        for player in self.players.clone().into_iter() {
+            game.player_add(player).unwrap();
+        }
+
+        assert!(game.can_start());
+        return game.start();
+    }
+
+    fn can_start(&self) -> bool {
+        self.players.len() == self.max_players && self.all_ready()
+    }
+
+    fn start(&mut self) -> &mut Instance {
+        // self.players.sort_unstable_by_key(|p| p.id);
+        self.next_round()
+    }
+
+    fn next_round(&mut self) -> &mut Instance {
+        if self.finish_condition() {
+            return self.finish();
+        }
+
+        self.phase = InstancePhase::InProgress;
+        self.phase_start = Utc::now();
+        self.phase_end = self.time_control.vbox_phase_end();
+
+        let bits = match self.rounds.len() > 0 {
+            true => 30,
+            false => 0,
+        };
+
+        self.players.iter_mut().for_each(|p| {
+            p.vbox.balance_add(bits);
+            p.set_ready(false);
+            p.vbox.fill();
+        });
+
+        self.rounds.push(Round::new());
+        self.bot_round_actions();
+
+        self
+    }
+
+    fn finish_condition(&mut self) -> bool {
+        self.players.iter().any(|p| p.score == Score::Win)
+    }
+
+    pub fn finish(&mut self) -> &mut Instance {
+        self.phase = InstancePhase::Finished;
+
+        for player in self.players.iter() {
+            if player.score == Score::Win {
+                self.winner = Some(player.id);
+            }
+        }
+
+        self
+    }
+
+    fn finished(&self) -> bool {
+        self.phase == InstancePhase::Finished
+    }
+
+    fn bot_round_actions(&mut self) -> &mut Instance {
+        for bot in self.players.iter_mut().filter(|p| p.bot) {
+            bot.vbox.fill();
+            bot.autobuy();
+        }
+
+        let games = self.players
+            .clone()
+            .iter()
+            .filter(|b| b.bot)
+            .filter_map(|b| self.player_ready(b.id).unwrap())
+            .collect::<Vec<Game>>();
+
+        for game in games {
+            if game.finished() {
+                self.game_finished(&game).unwrap();
+            } else {
+                info!("{:?} unfishededes", game);
+            }
+        }
+
+        self
+    }
+
+    fn current_game_id(&self) -> Option<Uuid> {
+        if self.phase != InstancePhase::InProgress {
+            return None;
+        }
+
+        let current_round = self.rounds
+            .last()
+            .expect("instance does not have any rounds");
+
+        if current_round.finished || current_round.game_id.is_none() {
+            return None;
+        }
+
+        return current_round.game_id;
+    }
+
+    fn game_finished(&mut self, game: &Game) -> Result<&mut Instance, Error> {
+        {
+            let current_round = self.rounds
+                .iter_mut()
+                .filter(|r| r.game_id.is_some())
+                .find(|r| r.game_id.unwrap() == game.id);
+
+            match current_round {
+                Some(c) => c.finished = true,
+                None => return Err(err_msg("instance does not have a round for this game")),
+            };
+        }
+
+        // if you don't win, you lose
+        // ties can happen if both players agree to a draw
+        // or ticks fire and knock everybody out
+        if let Some(winner) = game.winner() {
+            let winner = self.players.iter_mut()
+                .find(|p| p.id == winner.id)
+                .unwrap();
+            winner.score = winner.score.add_win(&Score::Zero);
+        };
+
+        if self.all_games_finished() {
+            self.next_round();
+        }
+
+        Ok(self)
+    }
+
+    fn all_ready(&self) -> bool {
+        self.players.iter().all(|p| p.ready)
+    }
+
+    fn all_games_finished(&self) -> bool {
+        match self.rounds.last() {
+            Some(r) => r.finished,
+            None => true,
+        }
+    }
+
+    // PLAYER ACTIONS
+    fn account_player(&mut self, account: Uuid) -> Result<&mut Player, Error> {
+        self.players
+            .iter_mut()
+            .find(|p| p.id == account)
+            .ok_or(err_msg("account not in instance"))
+    }
+
+    fn account_opponent(&mut self, account: Uuid) -> Result<&mut Player, Error> {
+        self.players
+            .iter_mut()
+            .find(|p| p.id != account)
+            .ok_or(err_msg("opponent not in instance"))
+    }
+
+    pub fn vbox_action_allowed(&self, account: Uuid) -> Result<(), Error> {
+        if self.players.iter().find(|p| p.id == account).is_none() {
+            return Err(err_msg("player not in this instance"));
+        }
+
+        if self.phase == InstancePhase::Lobby {
+            return Err(err_msg("game not yet started"));
+        }
+
+        if self.current_game_id().is_some() {
+            return Err(err_msg("you cannot perform vbox actions while in a game"));
+        }
+
+        Ok(())
+    }
+
+    pub fn vbox_refill(mut self, account: Uuid) -> Result<Instance, Error> {
+        self.vbox_action_allowed(account)?;
+        self.account_player(account)?
+            .vbox_refill()?;
+        Ok(self)
+    }
+
+    pub fn vbox_buy(mut self, account: Uuid, group: vbox::ItemType, index: String, construct_id: Option<Uuid>) -> Result<Instance, Error> {
+        self.vbox_action_allowed(account)?;
+        self.account_player(account)?
+            .vbox_buy(group, index, construct_id)?;
+        Ok(self)
+    }
+
+    pub fn vbox_combine(mut self, account: Uuid, inv_indices: Vec<String>, vbox_indices: vbox::VboxIndices) -> Result<Instance, Error> {
+        self.vbox_action_allowed(account)?;
+        self.account_player(account)?
+            .vbox_combine(inv_indices, vbox_indices)?;
+        Ok(self)
+    }
+
+    pub fn vbox_refund(mut self, account: Uuid, index: String) -> Result<Instance, Error> {
+        self.vbox_action_allowed(account)?;
+        self.account_player(account)?
+            .vbox_refund(index)?;
+        Ok(self)
+    }
+
+    pub fn vbox_apply(mut self, account: Uuid, index: String, construct_id: Uuid) -> Result<Instance, Error> {
+        self.vbox_action_allowed(account)?;
+        self.account_player(account)?
+            .vbox_equip(index, construct_id)?;
+        Ok(self)
+    }
+
+    pub fn vbox_unequip(mut self, account: Uuid, target: Item, construct_id: Uuid, target_construct_id: Option<Uuid>) -> Result<Instance, Error> {
+        self.vbox_action_allowed(account)?;
+        self.account_player(account)?
+            .vbox_unequip(target, construct_id, target_construct_id)?;
+        Ok(self)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn instance_pve_test() {
+        let mut instance = Instance::new();
+
+        let bot = bot_player();
+        let bot_one = bot.id;
+        instance.add_player(bot).unwrap();
+
+        let bot = bot_player();
+        let bot_two = bot.id;
+        instance.add_player(bot).unwrap();
+
+        assert_eq!(instance.phase, InstancePhase::Lobby);
+        instance.player_ready(bot_one).unwrap();
+        instance.player_ready(bot_two).unwrap();
+
+        assert_eq!(instance.phase, InstancePhase::Finished);
+    }
+
+    #[test]
+    fn instance_bot_vbox_test() {
+        let _instance = Instance::new();
+        let player_account = Uuid::new_v4();
+        let constructs = instance_mobs(player_account);
+        let _player = Player::new(player_account, &"test".to_string(), constructs).set_bot(true);
+    }
+
+    #[test]
+    fn instance_start_test() {
+        let mut instance = Instance::new();
+
+        assert_eq!(instance.max_players, 2);
+
+        let player_account = Uuid::new_v4();
+        let constructs = instance_mobs(player_account);
+        let player = Player::new(player_account, &"a".to_string(), constructs);
+        let a_id = player.id;
+
+        instance.add_player(player).expect("could not add player");
+        assert!(!instance.can_start());
+
+        let player_account = Uuid::new_v4();
+        let constructs = instance_mobs(player_account);
+        let player = Player::new(player_account, &"b".to_string(), constructs);
+        let b_id = player.id;
+
+        instance.add_player(player).expect("could not add player");
+
+        assert_eq!(instance.phase, InstancePhase::Lobby);
+        instance.player_ready(a_id).expect("a ready");
+        assert!(!instance.can_start());
+
+        instance.player_ready(b_id).expect("b ready");
+        assert_eq!(instance.phase, InstancePhase::InProgress);
+
+        assert!(!instance.can_start());
+
+        instance.players[0].autobuy();
+        instance.players[1].autobuy();
+
+        instance.player_ready(a_id).expect("a ready");
+        let game = instance.player_ready(b_id).expect("b ready");
+
+        assert!(game.is_some());
+    }
+
+    #[test]
+    fn instance_upkeep_test() {
+        let mut instance = Instance::new();
+
+        let player_account = Uuid::new_v4();
+        let constructs = instance_mobs(player_account);
+        let player = Player::new(player_account, &"a".to_string(), constructs);
+        let a_id = player.id;
+
+        instance.add_player(player).expect("could not add player");
+        assert!(!instance.can_start());
+
+        let player_account = Uuid::new_v4();
+        let constructs = instance_mobs(player_account);
+        let player = Player::new(player_account, &"b".to_string(), constructs);
+        let b_id = player.id;
+        instance.add_player(player).expect("could not add player");
+
+        instance.players[0].autobuy();
+
+        instance.player_ready(a_id).expect("a ready");
+        instance.player_ready(b_id).expect("b ready");
+
+        instance.phase_end = Some(Utc::now().checked_sub_signed(Duration::seconds(500)).unwrap());
+
+        let (mut instance, new_games) = instance.upkeep();
+
+        assert!(new_games.is_some());
+
+        let game = new_games.unwrap();
+        assert!(game.finished());
+
+        instance.game_finished(&game).unwrap();
+
+        assert_eq!(instance.rounds.len(), 2);
+        assert!(instance.players.iter().all(|p| !p.ready));
+
+        // info!("{:#?}", instance);
+    }
+
+    #[test]
+    fn instance_upkeep_idle_lobby_test() {
+        let mut instance = Instance::new();
+
+        let player_account = Uuid::new_v4();
+        let constructs = instance_mobs(player_account);
+        let player = Player::new(player_account, &"a".to_string(), constructs);
+        let _a_id = player.id;
+
+        instance.add_player(player).expect("could not add player");
+        assert!(!instance.can_start());
+
+        instance.phase_end = Some(Utc::now().checked_sub_signed(Duration::minutes(61)).unwrap());
+        let (instance, _new_games) = instance.upkeep();
+
+        assert!(instance.finished());
+    }
+}

core/src/lib.rs

@@ -0,0 +1,23 @@
+extern crate rand;
+extern crate uuid;
+extern crate bcrypt;
+extern crate chrono;
+
+extern crate serde;
+#[macro_use] extern crate serde_derive;
+#[macro_use] extern crate failure;
+
+#[macro_use] extern crate log;
+
+pub mod construct;
+pub mod effect;
+pub mod game;
+pub mod instance;
+pub mod item;
+pub mod mob;
+pub mod names;
+pub mod player;
+pub mod skill;
+pub mod spec;
+pub mod util;
+pub mod vbox;

core/src/mob.rs

@@ -0,0 +1,30 @@
+use uuid::Uuid;
+
+use std::iter;
+
+use construct::{Construct};
+use names::{name};
+use player::{Player};
+
+pub fn generate_mob() -> Construct {
+    let mob = Construct::new()
+        .named(&name());
+
+    return mob;
+}
+
+pub fn instance_mobs(player_id: Uuid) -> Vec<Construct> {
+    iter::repeat_with(||
+            generate_mob()
+                .set_account(player_id))
+                // .learn(Skill::Attack))
+        .take(3)
+        .collect::<Vec<Construct>>()
+}
+
+pub fn bot_player() -> Player {
+    let bot_id = Uuid::new_v4();
+    let constructs = instance_mobs(bot_id);
+    Player::new(bot_id, &name(), constructs).set_bot(true)
+}
+

core/src/names.rs

@@ -0,0 +1,138 @@
+use rand::prelude::*;
+use rand::{thread_rng};
+
+const FIRSTS: [&'static str; 53] = [
+    "artificial",
+    "ambient",
+    "borean",
+    "brewing",
+    "bristling",
+    "compressed",
+    "ceramic",
+    "chromatic",
+    "concave",
+    "convex",
+    "distorted",
+    "deserted",
+    "emotive",
+    "emotionless",
+    "elliptical",
+    "extrasolar",
+    "fierce",
+    "fossilised",
+    "frozen",
+    "gravitational",
+    "jovian",
+    "inverted",
+    "leafy",
+    "lurking",
+    "limitless",
+    "magnetic",
+    "metallic",
+    "mossy",
+    "mighty",
+    "modulated",
+    "nocturnal",
+    "noisy",
+    "nutritious",
+    "powerful",
+    "obscure",
+    "organic",
+    "oxygenated",
+    "oscillating",
+    "ossified",
+    "orbiting",
+    "piscine",
+    "polar",
+    "pure",
+    "recalcitrant",
+    "rogue",
+    "sealed",
+    "subversive",
+    "subterranean",
+    "supercooled",
+    "subsonic",
+    "synthetic",
+    "terrestrial",
+    "weary",
+];
+
+const LASTS: [&'static str; 63] = [
+    "artifact",
+    "assembly",
+    "antenna",
+    "alloy",
+    "carrier",
+    "carbon",
+    "console",
+    "construct",
+    "coordinates",
+    "craft",
+    "core",
+    "design",
+    "drone",
+    "distortion",
+    "detector",
+    "energy",
+    "entropy",
+    "exoplanet",
+    "foilage",
+    "forest",
+    "form",
+    "fossil",
+    "frequency",
+    "function",
+    "fusion",
+    "fission",
+    "information",
+    "insulator",
+    "layout",
+    "lifeform",
+    "liquid",
+    "landmass",
+    "lens",
+    "mass",
+    "mantle",
+    "magnetism",
+    "mechanism",
+    "mountain",
+    "nectar",
+    "nebula",
+    "oxide",
+    "orbit",
+    "pattern",
+    "plant",
+    "planet",
+    "poseidon",
+    "problem",
+    "receiver",
+    "replicant",
+    "river",
+    "satellite",
+    "scaffold",
+    "structure",
+    "shape",
+    "signal",
+    "synthesiser",
+    "system",
+    "tower",
+    "transmitter",
+    "traveller",
+    "vibration",
+    "warning",
+    "wildlife",
+];
+
+pub fn name() -> String {
+    let mut rng = thread_rng();
+
+    let first = rng.gen_range(0, FIRSTS.len() - 1);
+    let last = rng.gen_range(0, LASTS.len() - 1);
+
+    let mut s = String::new();
+    s.push_str(FIRSTS[first]);
+    s.push(' ');
+    s.push_str(LASTS[last]);
+
+    s
+}

core/src/player.rs

@@ -0,0 +1,442 @@
+use std::collections::{HashMap};
+
+use uuid::Uuid;
+use rand::prelude::*;
+
+use failure::Error;
+use failure::err_msg;
+
+use construct::{Construct, Colours};
+use vbox::{Vbox, ItemType, VboxIndices};
+use item::{Item, ItemEffect};
+use effect::{Effect};
+
+const DISCARD_COST: usize = 2;
+
+#[derive(Debug,Copy,Clone,Serialize,Deserialize,Eq,PartialEq)]
+pub enum Score {
+    Zero,
+    One,
+    Two,
+    Three,
+    Adv,
+
+    Win,
+    Lose,
+}
+
+impl Score {
+    pub fn add_win(self, _opp: &Score) -> Score {
+        match self {
+            Score::Zero => Score::One,
+            Score::One => Score::Two,
+            Score::Two => Score::Win,
+            //  Tennis scoring
+            // Score::Three => match opp {
+            //     Score::Adv => Score::Three,
+            //     Score::Three => Score::Adv,
+            //     _ => Score::Win,
+            // }
+            // Score::Adv => Score::Win,
+
+            _ => panic!("faulty score increment {:?}", self),
+        }
+    }
+
+    pub fn add_loss(self) -> Score {
+        match self {
+            // Score::Adv => Score::Three,
+            _ => self,
+        }
+    }
+
+}
+
+#[derive(Debug,Clone,Serialize,Deserialize)]
+pub struct Player {
+    pub id: Uuid,
+    pub img: Option<Uuid>,
+    pub name: String,
+    pub vbox: Vbox,
+    pub constructs: Vec<Construct>,
+    pub bot: bool,
+    pub ready: bool,
+    pub draw_offered: bool,
+    pub score: Score,
+}
+
+impl Player {
+    pub fn new(account: Uuid, name: &String, constructs: Vec<Construct>) -> Player {
+        Player {
+            id: account,
+            img: Some(account),
+            name: name.clone(),
+            vbox: Vbox::new(),
+            constructs,
+            bot: false,
+            ready: false,
+            draw_offered: false,
+            score: Score::Zero,
+        }
+    }
+
+    pub fn redact(mut self, account: Uuid) -> Player {
+        // all g
+        if account == self.id {
+            return self;
+        }
+
+        // remove vbox
+        self.vbox = Vbox::new();
+
+        // hide skills
+        for construct in self.constructs.iter_mut() {
+            construct.skills = vec![];
+            construct.specs = vec![];
+        }
+
+        self
+    }
+
+    pub fn set_bot(mut self, bot: bool) -> Player {
+        self.bot = bot;
+        self
+    }
+
+    pub fn set_ready(&mut self, ready: bool) -> &mut Player {
+        self.ready = ready;
+        self
+    }
+
+    pub fn forfeit(&mut self) -> &mut Player {
+        for construct in self.constructs.iter_mut() {
+            construct.force_ko();
+        }
+        self
+    }
+
+    pub fn set_win(&mut self) -> &mut Player {
+        self.score = Score::Win;
+        self
+    }
+
+    pub fn set_lose(&mut self) -> &mut Player {
+        self.score = Score::Lose;
+        self
+    }
+
+    pub fn construct_get(&mut self, id: Uuid) -> Result<&mut Construct, Error> {
+        self.constructs.iter_mut().find(|c| c.id == id).ok_or(err_msg("construct not found"))
+    }
+
+    pub fn autobuy(&mut self) -> &mut Player {
+        let mut rng = thread_rng();
+
+        // skill buying phase
+        while self.constructs.iter().any(|c| c.skills.len() < 3) {
+            // find the construct with the smallest number of skills
+            let construct_id = match self.constructs.iter().min_by_key(|c| c.skills.len()) {
+                None => panic!("no constructs in autobuy"),
+                Some(c) => c.id,
+            };
+
+            let i = self.vbox.stash.iter()
+                .find(|(_i, v)| v.into_skill().is_some())
+                .map(|(i, _v)| i.clone());
+
+            // got a skill in stash
+            if let Some(i) = i {
+                // AAAAAAAAAAAAAAAAAAAA
+                // there's a bad bug here where if this apply fails
+                // the item in question will be silently dropped
+                let item = self.vbox.stash.remove(&i).unwrap();
+                self.vbox_apply(item, construct_id).ok();
+                continue;
+            }
+            // need to buy one
+            else {
+
+                // do we have any colours in store?
+                let colours = self.vbox.store[&ItemType::Colours].keys()
+                    .cloned()
+                    .collect::<Vec<String>>();
+
+                // how about a base skill?
+                let base = match self.vbox.store[&ItemType::Skills].iter().next() {
+                    Some(b) => Some(b.0.clone()),
+                    None => None,
+                };
+
+                // if no: try to refill and start again
+                match colours.len() < 2 || base.is_none() {
+                    true => match self.vbox_refill() {
+                        Ok(_) => continue,
+                        Err(_) => break, // give up
+                    },
+                    false => {
+                        let mut vbox_items = HashMap::new();
+                        vbox_items.insert(ItemType::Colours, colours);
+                        vbox_items.insert(ItemType::Skills, vec![base.unwrap()]);
+
+                        match self.vbox_combine(vec![], Some(vbox_items)) {
+                            Ok(_) => continue,
+                            Err(_) => break, // give up
+                        }
+                    }
+                }
+            }
+        }
+
+        // spec buying phase
+        while self.constructs.iter().any(|c| c.specs.len() < 3) {
+            // find the construct with the smallest number of skills
+            let construct_id = match self.constructs.iter().min_by_key(|c| c.specs.len()) {
+                None => panic!("no constructs in autobuy"),
+                Some(c) => c.id,
+            };
+
+            let i = self.vbox.stash.iter()
+                .find(|(_i, v)| v.into_spec().is_some())
+                .map(|(i, _v)| i.clone());
+
+            // got a skill in stash
+            if let Some(i) = i {
+                // AAAAAAAAAAAAAAAAAAAA
+                // there's a bad bug here where if this apply fails
+                // the item in question will be silently dropped
+                let item = self.vbox.stash.remove(&i).unwrap();
+                self.vbox_apply(item, construct_id).ok();
+                continue;
+            }
+            // need to buy one
+            else {
+                // do we have any colours in store?
+                let colours = self.vbox.store[&ItemType::Colours].keys()
+                    .cloned()
+                    .collect::<Vec<String>>();
+
+                // how about a base spec?
+                let base = match self.vbox.store[&ItemType::Specs].iter().next() {
+                    Some(b) => Some(b.0.clone()),
+                    None => None,
+                };
+
+                // if no: try to refill and start again
+                match colours.len() < 2 || base.is_none() {
+                    true => match self.vbox_refill() {
+                        Ok(_) => continue,
+                        Err(_) => break, // give up
+                    },
+                    false => {
+                        let mut vbox_items = HashMap::new();
+                        vbox_items.insert(ItemType::Colours, colours);
+                        vbox_items.insert(ItemType::Specs, vec![base.unwrap()]);
+
+                        match self.vbox_combine(vec![], Some(vbox_items)) {
+                            Ok(_) => continue,
+                            Err(_) => break, // give up
+                        }
+                    }
+                }
+            }
+        }
+
+        // upgrading phase
+        // NYI
+
+        return self;
+    }
+
+    pub fn vbox_refill(&mut self) -> Result<&mut Player, Error> {
+        self.vbox.balance_sub(DISCARD_COST)?;
+        self.vbox.fill();
+        Ok(self)
+    }
+
+    pub fn bot_vbox_accept(&mut self, group: ItemType) -> Result<&mut Player, Error> {
+        let item = self.vbox.bot_buy(group)?;
+        self.vbox.stash_add(item, None)?;
+        Ok(self)
+    }
+
+    pub fn vbox_buy(&mut self, group: ItemType, index: String, construct_id: Option<Uuid>) -> Result<&mut Player, Error> {
+        let item = self.vbox.buy(group, &index)?;
+
+        match construct_id {
+            Some(id) => { self.vbox_apply(item, id)?; },
+            None => { self.vbox.stash_add(item, None)?; },
+        };
+
+        Ok(self)
+    }
+
+    pub fn vbox_combine(&mut self, inv_indices: Vec<String>, vbox_indices: VboxIndices) -> Result<&mut Player, Error> {
+        self.vbox.combine(inv_indices, vbox_indices)?;
+        Ok(self)
+    }
+
+    pub fn vbox_refund(&mut self, index: String) -> Result<&mut Player, Error> {
+        self.vbox.refund(index)?;
+        Ok(self)
+    }
+
+    pub fn vbox_equip(&mut self, index: String, construct_id: Uuid) -> Result<&mut Player, Error> {
+        let item = self.vbox.stash.remove(&index)
+            .ok_or(format_err!("no item at index {:?} {:}", self, &index))?;
+
+        self.vbox_apply(item, construct_id)
+    }
+
+    pub fn vbox_apply(&mut self, item: Item, construct_id: Uuid) -> Result<&mut Player, Error> {
+        match item.effect() {
+            Some(ItemEffect::Skill) => {
+                let skill = item.into_skill().ok_or(format_err!("item {:?} has no associated skill", item))?;
+                let construct = self.construct_get(construct_id)?;
+                // done here because i teach them a tonne of skills for tests
+                let max_skills = 3;
+                if construct.skills.len() >= max_skills {
+                    return Err(format_err!("construct at max skills ({:?})", max_skills));
+                }
+
+                if construct.knows(skill) {
+                    return Err(format_err!("construct already knows skill ({:?})" , skill));
+                }
+
+                construct.learn_mut(skill);
+            },
+            Some(ItemEffect::Spec) => {
+                let spec = item.into_spec().ok_or(format_err!("item {:?} has no associated spec", item))?;
+                let construct = self.construct_get(construct_id)?;
+                construct.spec_add(spec)?;
+
+            },
+            None => return Err(err_msg("item has no effect on constructs")),
+        }
+
+        // now the item has been applied
+        // recalculate the stats of the whole player
+        let player_colours = self.constructs.iter().fold(Colours::new(), |tc, c| {
+            Colours {
+                red: tc.red + c.colours.red,
+                green: tc.green + c.colours.green,
+                blue: tc.blue + c.colours.blue
+            }
+        });
+
+        for construct in self.constructs.iter_mut() {
+            construct.apply_modifiers(&player_colours);
+        }
+
+        Ok(self)
+    }
+
+    pub fn vbox_unequip(&mut self, target: Item, construct_id: Uuid, target_construct_id: Option<Uuid>) -> Result<&mut Player, Error> {
+        if self.vbox.stash.len() >= 9 && !target_construct_id.is_some() {
+            return Err(err_msg("too many items stash"));
+        }
+
+        match target.effect() {
+            Some(ItemEffect::Skill) => {
+                let skill = target.into_skill().ok_or(format_err!("item {:?} has no associated skill", target))?;
+                let construct = self.construct_get(construct_id)?;
+                construct.forget(skill)?;
+            },
+            Some(ItemEffect::Spec) => {
+                let spec = target.into_spec().ok_or(format_err!("item {:?} has no associated spec", target))?;
+                let construct = self.construct_get(construct_id)?;
+                construct.spec_remove(spec)?;
+            },
+            None => return Err(err_msg("item has no effect on constructs")),
+        }
+
+        // now the item has been applied
+        // recalculate the stats of the whole player
+        let player_colours = self.constructs.iter().fold(Colours::new(), |tc, c| {
+            Colours {
+                red: tc.red + c.colours.red,
+                green: tc.green + c.colours.green,
+                blue: tc.blue + c.colours.blue
+            }
+        });
+
+        for construct in self.constructs.iter_mut() {
+            construct.apply_modifiers(&player_colours);
+        }
+
+        match target_construct_id {
+            Some(cid) => { self.vbox_apply(target, cid)?; },
+            None => { self.vbox.stash_add(target, None)?; },
+        };
+
+        Ok(self)
+    }
+
+    // GAME METHODS
+    pub fn skills_required(&self) -> usize {
+        let required = self.constructs.iter()
+            .filter(|c| !c.is_ko())
+            .filter(|c| c.available_skills().len() > 0)
+            .collect::<Vec<&Construct>>().len();
+        // info!("{:} requires {:} skills this turn", self.id, required);
+        return required;
+    }
+
+    pub fn intercepting(&self) -> Option<&Construct> {
+        self.constructs.iter()
+            .find(|c| c.affected(Effect::Intercept))
+    }
+
+    pub fn construct_by_id(&mut self, id: Uuid) -> Option<&mut Construct> {
+        self.constructs.iter_mut().find(|c| c.id == id)
+    }
+
+}
+
+#[cfg(test)]
+mod tests {
+    use mob::instance_mobs;
+    use super::*;
+
+    #[test]
+    fn player_bot_vbox_test() {
+        let player_account = Uuid::new_v4();
+        let constructs = instance_mobs(player_account);
+        let mut player = Player::new(player_account, &"test".to_string(), constructs).set_bot(true);
+
+        player.vbox.fill();
+        player.autobuy();
+
+        assert!(player.constructs.iter().all(|c| c.skills.len() >= 1));
+    }
+
+    #[test]
+    fn player_score_test() {
+        let player_account = Uuid::new_v4();
+        let constructs = instance_mobs(player_account);
+        let mut player = Player::new(player_account, &"test".to_string(), constructs).set_bot(true);
+
+        player.score = player.score.add_win(&Score::Zero);
+        player.score = player.score.add_win(&Score::Zero);
+        player.score = player.score.add_win(&Score::Zero);
+        assert_eq!(player.score, Score::Win); // 40 / 0
+
+        // Bo7 tennis scoring
+        /*assert_eq!(player.score, Score::Three); // 40 / 0
+
+        player.score = player.score.add_loss(); // adv -> deuce
+        assert_eq!(player.score, Score::Three);
+
+        player.score = player.score.add_loss(); // adv -> deuce
+        assert_eq!(player.score, Score::Three);
+
+        player.score = player.score.add_win(&Score::Adv); // opp adv -> stays deuce
+        assert_eq!(player.score, Score::Three);
+
+        player.score = player.score.add_win(&Score::Three);
+        assert_eq!(player.score, Score::Adv);
+
+        player.score = player.score.add_win(&Score::Three);
+        assert_eq!(player.score, Score::Win);*/
+    }
+
+}

core/src/spec.rs

@@ -0,0 +1,734 @@
+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 SpecValues {
+    pub base: u64,
+    pub bonuses: Vec<SpecBonus>,
+}
+
+impl SpecValues {
+    pub fn max_value (&self, c: &Colours) -> u64 {
+        self.bonuses.iter().fold(self.base, |acc, s| acc + s.get_bonus(c))
+    }
+
+    pub fn base (self) -> u64 {
+        self.base
+    }
+}
+
+
+#[derive(Debug,Copy,Clone,Serialize,Deserialize,PartialEq,PartialOrd,Ord,Eq)]
+pub enum Spec {
+    Speed,
+    SpeedRR,
+    SpeedBB,
+    SpeedGG,
+    SpeedRG,
+    SpeedGB,
+    SpeedRB,
+
+    SpeedRRPlus,
+    SpeedBBPlus,
+    SpeedGGPlus,
+    SpeedRGPlus,
+    SpeedGBPlus,
+    SpeedRBPlus,
+
+    SpeedRRPlusPlus,
+    SpeedBBPlusPlus,
+    SpeedGGPlusPlus,
+    SpeedRGPlusPlus,
+    SpeedGBPlusPlus,
+    SpeedRBPlusPlus,
+
+    Life,
+    LifeGG,
+    LifeRR,
+    LifeBB,
+    LifeRG,
+    LifeGB,
+    LifeRB,
+    LifeGGPlus,
+    LifeRRPlus,
+    LifeBBPlus,
+    LifeRGPlus,
+    LifeGBPlus,
+    LifeRBPlus,
+    LifeGGPlusPlus,
+    LifeRRPlusPlus,
+    LifeBBPlusPlus,
+    LifeRGPlusPlus,
+    LifeGBPlusPlus,
+    LifeRBPlusPlus,
+
+    Power,
+    PowerRR,
+    PowerGG,
+    PowerBB,
+    PowerRG,
+    PowerGB,
+    PowerRB,
+    PowerRRPlus,
+    PowerGGPlus,
+    PowerBBPlus,
+    PowerRGPlus,
+    PowerGBPlus,
+    PowerRBPlus,
+    PowerRRPlusPlus,
+    PowerGGPlusPlus,
+    PowerBBPlusPlus,
+    PowerRGPlusPlus,
+    PowerGBPlusPlus,
+    PowerRBPlusPlus,
+
+}
+
+impl Spec {
+    pub fn affects(&self) -> Vec<Stat> {
+        match *self {
+            Spec::Power     => vec![Stat::BluePower, Stat::RedPower, Stat::GreenPower],
+            Spec::PowerRR => vec![Stat::RedPower],
+            Spec::PowerGG => vec![Stat::GreenPower],
+            Spec::PowerBB => vec![Stat::BluePower],
+            Spec::PowerRG => vec![Stat::GreenPower, Stat::RedPower],
+            Spec::PowerGB => vec![Stat::GreenPower, Stat::BluePower],
+            Spec::PowerRB => vec![Stat::RedPower, Stat::BluePower],
+            Spec::PowerRRPlus  => vec![Stat::RedPower],
+            Spec::PowerGGPlus  => vec![Stat::GreenPower],
+            Spec::PowerBBPlus  => vec![Stat::BluePower],
+            Spec::PowerRGPlus  => vec![Stat::GreenPower, Stat::RedPower],
+            Spec::PowerGBPlus  => vec![Stat::GreenPower, Stat::BluePower],
+            Spec::PowerRBPlus  => vec![Stat::RedPower, Stat::BluePower],
+            Spec::PowerRRPlusPlus  => vec![Stat::RedPower],
+            Spec::PowerGGPlusPlus  => vec![Stat::GreenPower],
+            Spec::PowerBBPlusPlus  => vec![Stat::BluePower],
+            Spec::PowerRGPlusPlus  => vec![Stat::GreenPower, Stat::RedPower],
+            Spec::PowerGBPlusPlus  => vec![Stat::GreenPower, Stat::BluePower],
+            Spec::PowerRBPlusPlus  => vec![Stat::RedPower, Stat::BluePower],
+
+            Spec::Speed      => vec![Stat::Speed],
+            Spec::SpeedRR  => vec![Stat::Speed],
+            Spec::SpeedBB  => vec![Stat::Speed],
+            Spec::SpeedGG  => vec![Stat::Speed],
+            Spec::SpeedRG  => vec![Stat::Speed],
+            Spec::SpeedGB  => vec![Stat::Speed],
+            Spec::SpeedRB  => vec![Stat::Speed],
+            Spec::SpeedRRPlus  => vec![Stat::Speed],
+            Spec::SpeedBBPlus  => vec![Stat::Speed],
+            Spec::SpeedGGPlus  => vec![Stat::Speed],
+            Spec::SpeedRGPlus  => vec![Stat::Speed],
+            Spec::SpeedGBPlus  => vec![Stat::Speed],
+            Spec::SpeedRBPlus  => vec![Stat::Speed],
+            Spec::SpeedRRPlusPlus => vec![Stat::Speed],
+            Spec::SpeedBBPlusPlus => vec![Stat::Speed],
+            Spec::SpeedGGPlusPlus => vec![Stat::Speed],
+            Spec::SpeedRGPlusPlus => vec![Stat::Speed],
+            Spec::SpeedGBPlusPlus => vec![Stat::Speed],
+            Spec::SpeedRBPlusPlus => vec![Stat::Speed],
+
+            Spec::Life      => vec![Stat::GreenLife],
+            Spec::LifeRR  => vec![Stat::RedLife],
+            Spec::LifeBB  => vec![Stat::BlueLife],
+            Spec::LifeGG  => vec![Stat::GreenLife],
+            Spec::LifeRG  => vec![Stat::GreenLife, Stat::RedLife],
+            Spec::LifeGB  => vec![Stat::GreenLife, Stat::BlueLife],
+            Spec::LifeRB  => vec![Stat::BlueLife, Stat::RedLife],
+            Spec::LifeRRPlus   => vec![Stat::RedLife],
+            Spec::LifeBBPlus   => vec![Stat::BlueLife],
+            Spec::LifeGGPlus   => vec![Stat::GreenLife],
+            Spec::LifeRGPlus   => vec![Stat::GreenLife, Stat::RedLife],
+            Spec::LifeGBPlus   => vec![Stat::GreenLife, Stat::BlueLife],
+            Spec::LifeRBPlus   => vec![Stat::BlueLife, Stat::RedLife],
+            Spec::LifeRRPlusPlus   => vec![Stat::RedLife],
+            Spec::LifeBBPlusPlus   => vec![Stat::BlueLife],
+            Spec::LifeGGPlusPlus   => vec![Stat::GreenLife],
+            Spec::LifeRGPlusPlus   => vec![Stat::GreenLife, Stat::RedLife],
+            Spec::LifeGBPlusPlus   => vec![Stat::GreenLife, Stat::BlueLife],
+            Spec::LifeRBPlusPlus   => vec![Stat::BlueLife, Stat::RedLife],
+        }
+    }
+
+    pub fn values(&self) -> SpecValues {
+        match *self {
+            Spec::Power => SpecValues {
+                base: 10,
+                bonuses: vec![]
+            },
+
+            Spec::PowerRR=> SpecValues {
+                base: 25,
+                bonuses: vec![
+                    SpecBonus { req: Colours { red: 5, green: 0, blue: 0 }, bonus: 10 },
+                    SpecBonus { req: Colours { red: 10, green: 0, blue: 0 }, bonus: 15 },
+                    SpecBonus { req: Colours { red: 20, green: 0, blue: 0 }, bonus: 20 }
+                ],
+            },
+
+            Spec::PowerGG=> SpecValues {
+                base: 25,
+                bonuses: vec![
+                    SpecBonus { req: Colours { red: 0, green: 5, blue: 0 }, bonus: 10 },
+                    SpecBonus { req: Colours { red: 0, green: 10, blue: 0 }, bonus: 15 },
+                    SpecBonus { req: Colours { red: 0, green: 20, blue: 0 }, bonus: 20 }
+                ],
+            },
+
+            Spec::PowerBB=> SpecValues {
+                base: 25,
+                bonuses: vec![
+                    SpecBonus { req: Colours { red: 0, green: 0, blue: 5 }, bonus: 10 },
+                    SpecBonus { req: Colours { red: 0, green: 0, blue: 10 }, bonus: 15 },
+                    SpecBonus { req: Colours { red: 0, green: 0, blue: 20 }, bonus: 20 }
+                ],
+            },
+
+            Spec::PowerRG=> SpecValues {
+                base: 20,
+                bonuses: vec![
+                    SpecBonus { req: Colours { red: 2, green: 2, blue: 0 }, bonus: 5 },
+                    SpecBonus { req: Colours { red: 5, green: 5, blue: 0 }, bonus: 10 },
+                    SpecBonus { req: Colours { red: 10, green: 10, blue: 0 }, bonus: 15 }
+                ],
+            },
+
+            Spec::PowerGB=> SpecValues {
+                base: 20,
+                bonuses: vec![
+                    SpecBonus { req: Colours { red: 0, green: 2, blue: 2 }, bonus: 5 },
+                    SpecBonus { req: Colours { red: 0, green: 5, blue: 5 }, bonus: 10 },
+                    SpecBonus { req: Colours { red: 0, green: 10, blue: 10 }, bonus: 15 }
+                ],
+            },
+
+            Spec::PowerRB=> SpecValues {
+                base: 20,
+                bonuses: vec![
+                    SpecBonus { req: Colours { red: 2, green: 0, blue: 2 }, bonus: 5 },
+                    SpecBonus { req: Colours { red: 5, green: 0, blue: 5 }, bonus: 10 },
+                    SpecBonus { req: Colours { red: 10, green: 0, blue: 10 }, bonus: 15 }
+                ],
+            },
+
+            Spec::PowerRRPlus => SpecValues {
+                base: 45,
+                bonuses: vec![
+                    SpecBonus { req: Colours { red: 5, green: 0, blue: 0 }, bonus: 15 },
+                    SpecBonus { req: Colours { red: 10, green: 0, blue: 0 }, bonus: 25 },
+                    SpecBonus { req: Colours { red: 20, green: 0, blue: 0 }, bonus: 35 }
+                ],
+            },
+
+            Spec::PowerGGPlus => SpecValues {
+                base: 45,
+                bonuses: vec![
+                    SpecBonus { req: Colours { red: 0, green: 5, blue: 0 }, bonus: 15 },
+                    SpecBonus { req: Colours { red: 0, green: 10, blue: 0 }, bonus: 25 },
+                    SpecBonus { req: Colours { red: 0, green: 20, blue: 0 }, bonus: 35 }
+                ],
+            },
+
+            Spec::PowerBBPlus => SpecValues {
+                base: 45,
+                bonuses: vec![
+                    SpecBonus { req: Colours { red: 0, green: 0, blue: 5 }, bonus: 15 },
+                    SpecBonus { req: Colours { red: 0, green: 0, blue: 10 }, bonus: 25 },
+                    SpecBonus { req: Colours { red: 0, green: 0, blue: 20 }, bonus: 35 }
+                ],
+            },
+
+            Spec::PowerRGPlus => SpecValues {
+                base: 35,
+                bonuses: vec![
+                    SpecBonus { req: Colours { red: 2, green: 2, blue: 0 }, bonus: 10 },
+                    SpecBonus { req: Colours { red: 5, green: 5, blue: 0 }, bonus: 20 },
+                    SpecBonus { req: Colours { red: 10, green: 10, blue: 0 }, bonus: 25 }
+                ],
+            },
+
+            Spec::PowerGBPlus => SpecValues {
+                base: 35,
+                bonuses: vec![
+                    SpecBonus { req: Colours { red: 0, green: 2, blue: 2 }, bonus: 10 },
+                    SpecBonus { req: Colours { red: 0, green: 5, blue: 5 }, bonus: 20 },
+                    SpecBonus { req: Colours { red: 0, green: 10, blue: 10 }, bonus: 25 }
+                ],
+            },
+
+            Spec::PowerRBPlus => SpecValues {
+                base: 35,
+                bonuses: vec![
+                    SpecBonus { req: Colours { red: 2, green: 0, blue: 2 }, bonus: 10 },
+                    SpecBonus { req: Colours { red: 5, green: 0, blue: 5 }, bonus: 20 },
+                    SpecBonus { req: Colours { red: 10, green: 0, blue: 10 }, bonus: 25 }
+                ],
+            },
+            Spec::PowerRRPlusPlus => SpecValues {
+                base: 80,
+                bonuses: vec![
+                    SpecBonus { req: Colours { red: 5, green: 0, blue: 0 }, bonus: 25 },
+                    SpecBonus { req: Colours { red: 10, green: 0, blue: 0 }, bonus: 45 },
+                    SpecBonus { req: Colours { red: 20, green: 0, blue: 0 }, bonus: 60 }
+                ],
+            },
+
+            Spec::PowerGGPlusPlus => SpecValues {
+                base: 80,
+                bonuses: vec![
+                    SpecBonus { req: Colours { red: 0, green: 5, blue: 0 }, bonus: 25 },
+                    SpecBonus { req: Colours { red: 0, green: 10, blue: 0 }, bonus: 45 },
+                    SpecBonus { req: Colours { red: 0, green: 20, blue: 0 }, bonus: 60 }
+                ],
+            },
+
+            Spec::PowerBBPlusPlus => SpecValues {
+                base: 80,
+                bonuses: vec![
+                    SpecBonus { req: Colours { red: 0, green: 0, blue: 5 }, bonus: 25 },
+                    SpecBonus { req: Colours { red: 0, green: 0, blue: 10 }, bonus: 45 },
+                    SpecBonus { req: Colours { red: 0, green: 0, blue: 20 }, bonus: 60 }
+                ],
+            },
+
+            Spec::PowerRGPlusPlus => SpecValues {
+                base: 60,
+                bonuses: vec![
+                    SpecBonus { req: Colours { red: 2, green: 2, blue: 0 }, bonus: 20 },
+                    SpecBonus { req: Colours { red: 5, green: 5, blue: 0 }, bonus: 30 },
+                    SpecBonus { req: Colours { red: 10, green: 10, blue: 0 }, bonus: 45 }
+                ],
+            },
+
+            Spec::PowerGBPlusPlus => SpecValues {
+                base: 60,
+                bonuses: vec![
+                    SpecBonus { req: Colours { red: 0, green: 2, blue: 2 }, bonus: 20 },
+                    SpecBonus { req: Colours { red: 0, green: 5, blue: 5 }, bonus: 30 },
+                    SpecBonus { req: Colours { red: 0, green: 10, blue: 10 }, bonus: 45 }
+                ],
+            },
+
+            Spec::PowerRBPlusPlus => SpecValues {
+                base: 60,
+                bonuses: vec![
+                    SpecBonus { req: Colours { red: 2, green: 0, blue: 2 }, bonus: 20 },
+                    SpecBonus { req: Colours { red: 5, green: 0, blue: 5 }, bonus: 30 },
+                    SpecBonus { req: Colours { red: 10, green: 0, blue: 10 }, bonus: 45 }
+                ],
+            },
+
+            Spec::Speed => SpecValues {
+                base: 40,
+                bonuses: vec![]
+            },
+
+            Spec::SpeedRR=> SpecValues {
+                base: 80,
+                bonuses: vec![
+                    SpecBonus { req: Colours { red: 5, green: 0, blue: 0 }, bonus: 80 },
+                    SpecBonus { req: Colours { red: 10, green: 0, blue: 0 }, bonus: 80 },
+                    SpecBonus { req: Colours { red: 20, green: 0, blue: 0 }, bonus: 80 }
+                ],
+            },
+
+            Spec::SpeedGG=> SpecValues {
+                base: 80,
+                bonuses: vec![
+                    SpecBonus { req: Colours { red: 0, green: 5, blue: 0 }, bonus: 80 },
+                    SpecBonus { req: Colours { red: 0, green: 10, blue: 0 }, bonus: 80 },
+                    SpecBonus { req: Colours { red: 0, green: 20, blue: 0 }, bonus: 80 }
+                ],
+            },
+
+            Spec::SpeedBB=> SpecValues {
+                base: 80,
+                bonuses: vec![
+                    SpecBonus { req: Colours { red: 0, green: 0, blue: 5 }, bonus: 80 },
+                    SpecBonus { req: Colours { red: 0, green: 0, blue: 10 }, bonus: 80 },
+                    SpecBonus { req: Colours { red: 0, green: 0, blue: 20 }, bonus: 80 }
+                ],
+            },
+
+            Spec::SpeedRG=> SpecValues {
+                base: 60,
+                bonuses: vec![
+                    SpecBonus { req: Colours { red: 2, green: 2, blue: 0 }, bonus: 60 },
+                    SpecBonus { req: Colours { red: 5, green: 5, blue: 0 }, bonus: 60 },
+                    SpecBonus { req: Colours { red: 10, green: 10, blue: 0 }, bonus: 60 }
+                ],
+            },
+
+            Spec::SpeedGB=> SpecValues {
+                base: 60,
+                bonuses: vec![
+                    SpecBonus { req: Colours { red: 0, green: 2, blue: 2 }, bonus: 60 },
+                    SpecBonus { req: Colours { red: 0, green: 5, blue: 5 }, bonus: 60 },
+                    SpecBonus { req: Colours { red: 0, green: 10, blue: 10 }, bonus: 60 }
+                ],
+            },
+
+            Spec::SpeedRB=> SpecValues {
+                base: 60,
+                bonuses: vec![
+                    SpecBonus { req: Colours { red: 2, green: 0, blue: 2 }, bonus: 60 },
+                    SpecBonus { req: Colours { red: 5, green: 0, blue: 5 }, bonus: 60 },
+                    SpecBonus { req: Colours { red: 10, green: 0, blue: 10 }, bonus: 60 }
+                ],
+            },
+
+            Spec::SpeedRRPlus => SpecValues {
+                base: 120,
+                bonuses: vec![
+                    SpecBonus { req: Colours { red: 5, green: 0, blue: 0 }, bonus: 120 },
+                    SpecBonus { req: Colours { red: 10, green: 0, blue: 0 }, bonus: 120 },
+                    SpecBonus { req: Colours { red: 20, green: 0, blue: 0 }, bonus: 120 }
+                ],
+            },
+
+            Spec::SpeedGGPlus => SpecValues {
+                base: 120,
+                bonuses: vec![
+                    SpecBonus { req: Colours { red: 0, green: 5, blue: 0 }, bonus: 120 },
+                    SpecBonus { req: Colours { red: 0, green: 10, blue: 0 }, bonus: 120 },
+                    SpecBonus { req: Colours { red: 0, green: 20, blue: 0 }, bonus: 120 }
+                ],
+            },
+
+            Spec::SpeedBBPlus => SpecValues {
+                base: 120,
+                bonuses: vec![
+                    SpecBonus { req: Colours { red: 0, green: 0, blue: 5 }, bonus: 120 },
+                    SpecBonus { req: Colours { red: 0, green: 0, blue: 10 }, bonus: 120 },
+                    SpecBonus { req: Colours { red: 0, green: 0, blue: 20 }, bonus: 120 }
+                ],
+            },
+
+            Spec::SpeedRGPlus => SpecValues {
+                base: 80,
+                bonuses: vec![
+                    SpecBonus { req: Colours { red: 2, green: 2, blue: 0 }, bonus: 80 },
+                    SpecBonus { req: Colours { red: 5, green: 5, blue: 0 }, bonus: 80 },
+                    SpecBonus { req: Colours { red: 10, green: 10, blue: 0 }, bonus: 80 }
+                ],
+            },
+
+            Spec::SpeedGBPlus => SpecValues {
+                base: 80,
+                bonuses: vec![
+                    SpecBonus { req: Colours { red: 0, green: 2, blue: 2 }, bonus: 80 },
+                    SpecBonus { req: Colours { red: 0, green: 5, blue: 5 }, bonus: 80 },
+                    SpecBonus { req: Colours { red: 0, green: 10, blue: 10 }, bonus: 80 }
+                ],
+            },
+
+            Spec::SpeedRBPlus => SpecValues {
+                base: 80,
+                bonuses: vec![
+                    SpecBonus { req: Colours { red: 2, green: 0, blue: 2 }, bonus: 80 },
+                    SpecBonus { req: Colours { red: 5, green: 0, blue: 5 }, bonus: 80 },
+                    SpecBonus { req: Colours { red: 10, green: 0, blue: 10 }, bonus: 80 }
+                ],
+            },
+
+            Spec::SpeedRRPlusPlus => SpecValues {
+                base: 160,
+                bonuses: vec![
+                    SpecBonus { req: Colours { red: 5, green: 0, blue: 0 }, bonus: 160 },
+                    SpecBonus { req: Colours { red: 10, green: 0, blue: 0 }, bonus: 160 },
+                    SpecBonus { req: Colours { red: 20, green: 0, blue: 0 }, bonus: 160 }
+                ],
+            },
+
+            Spec::SpeedGGPlusPlus => SpecValues {
+                base: 160,
+                bonuses: vec![
+                    SpecBonus { req: Colours { red: 0, green: 5, blue: 0 }, bonus: 160 },
+                    SpecBonus { req: Colours { red: 0, green: 10, blue: 0 }, bonus: 160 },
+                    SpecBonus { req: Colours { red: 0, green: 20, blue: 0 }, bonus: 160 }
+                ],
+            },
+
+            Spec::SpeedBBPlusPlus => SpecValues {
+                base: 160,
+                bonuses: vec![
+                    SpecBonus { req: Colours { red: 0, green: 0, blue: 5 }, bonus: 160 },
+                    SpecBonus { req: Colours { red: 0, green: 0, blue: 10 }, bonus: 160 },
+                    SpecBonus { req: Colours { red: 0, green: 0, blue: 20 }, bonus: 160 }
+                ],
+            },
+
+            Spec::SpeedRGPlusPlus => SpecValues {
+                base: 120,
+                bonuses: vec![
+                    SpecBonus { req: Colours { red: 2, green: 2, blue: 0 }, bonus: 120 },
+                    SpecBonus { req: Colours { red: 5, green: 5, blue: 0 }, bonus: 120 },
+                    SpecBonus { req: Colours { red: 10, green: 10, blue: 0 }, bonus: 120 }
+                ],
+            },
+
+            Spec::SpeedGBPlusPlus => SpecValues {
+                base: 120,
+                bonuses: vec![
+                    SpecBonus { req: Colours { red: 0, green: 2, blue: 2 }, bonus: 120 },
+                    SpecBonus { req: Colours { red: 0, green: 5, blue: 5 }, bonus: 120 },
+                    SpecBonus { req: Colours { red: 0, green: 10, blue: 10 }, bonus: 120 }
+                ],
+            },
+
+            Spec::SpeedRBPlusPlus => SpecValues {
+                base: 120,
+                bonuses: vec![
+                    SpecBonus { req: Colours { red: 2, green: 0, blue: 2 }, bonus: 120 },
+                    SpecBonus { req: Colours { red: 5, green: 0, blue: 5 }, bonus: 120 },
+                    SpecBonus { req: Colours { red: 10, green: 0, blue: 10 }, bonus: 120 }
+                ],
+            },
+
+            Spec::Life => SpecValues {
+                base: 125,
+                bonuses: vec![]},
+
+            Spec::LifeRR=> SpecValues {
+                base: 275,
+                bonuses: vec![
+                    SpecBonus { req: Colours { red: 5, green: 0, blue: 0 }, bonus: 75 },
+                    SpecBonus { req: Colours { red: 10, green: 0, blue: 0 }, bonus: 125 },
+                    SpecBonus { req: Colours { red: 20, green: 0, blue: 0 }, bonus: 175 }
+                ],
+            },
+
+            Spec::LifeGG=> SpecValues {
+                base: 225,
+                bonuses: vec![
+                    SpecBonus { req: Colours { red: 0, green: 5, blue: 0 }, bonus: 50 },
+                    SpecBonus { req: Colours { red: 0, green: 10, blue: 0 }, bonus: 75 },
+                    SpecBonus { req: Colours { red: 0, green: 20, blue: 0 }, bonus: 125 }
+                ],
+            },
+
+            Spec::LifeBB=> SpecValues {
+                base: 275,
+                bonuses: vec![
+                    SpecBonus { req: Colours { red: 0, green: 0, blue: 5 }, bonus: 75 },
+                    SpecBonus { req: Colours { red: 0, green: 0, blue: 10 }, bonus: 125 },
+                    SpecBonus { req: Colours { red: 0, green: 0, blue: 20 }, bonus: 175 }
+                ],
+            },
+
+            Spec::LifeRG=> SpecValues {
+                base: 125,
+                bonuses: vec![
+                    SpecBonus { req: Colours { red: 2, green: 2, blue: 0 }, bonus: 50 },
+                    SpecBonus { req: Colours { red: 5, green: 5, blue: 0 }, bonus: 75 },
+                    SpecBonus { req: Colours { red: 10, green: 10, blue: 0 }, bonus: 125 }
+                ],
+            },
+
+            Spec::LifeGB=> SpecValues {
+                base: 125,
+                bonuses: vec![
+                    SpecBonus { req: Colours { red: 0, green: 2, blue: 2 }, bonus: 50 },
+                    SpecBonus { req: Colours { red: 0, green: 5, blue: 5 }, bonus: 75 },
+                    SpecBonus { req: Colours { red: 0, green: 10, blue: 10 }, bonus: 125 }
+                ],
+            },
+
+            Spec::LifeRB=> SpecValues {
+                base: 175,
+                bonuses: vec![
+                    SpecBonus { req: Colours { red: 2, green: 0, blue: 2 },  bonus: 50 },
+                    SpecBonus { req: Colours { red: 5, green: 0, blue: 5 }, bonus: 75 },
+                    SpecBonus { req: Colours { red: 10, green: 0, blue: 10 }, bonus: 125 }
+                ],
+            },
+
+            Spec::LifeRRPlus => SpecValues {
+                base: 500,
+                bonuses: vec![
+                    SpecBonus { req: Colours { red: 5, green: 0, blue: 0 }, bonus: 125 },
+                    SpecBonus { req: Colours { red: 10, green: 0, blue: 0 }, bonus: 225 },
+                    SpecBonus { req: Colours { red: 20, green: 0, blue: 0 }, bonus: 300 }
+                ],
+            },
+
+            Spec::LifeGGPlus => SpecValues {
+                base: 400,
+                bonuses: vec![
+                    SpecBonus { req: Colours { red: 0, green: 5, blue: 0 }, bonus: 90 },
+                    SpecBonus { req: Colours { red: 0, green: 10, blue: 0 }, bonus: 130 },
+                    SpecBonus { req: Colours { red: 0, green: 20, blue: 0 }, bonus: 225 }
+                ],
+            },
+
+            Spec::LifeBBPlus => SpecValues {
+                base: 500,
+                bonuses: vec![
+                    SpecBonus { req: Colours { red: 0, green: 0, blue: 5 }, bonus: 125 },
+                    SpecBonus { req: Colours { red: 0, green: 0, blue: 10 }, bonus: 225 },
+                    SpecBonus { req: Colours { red: 0, green: 0, blue: 20 }, bonus: 300 }
+                ],
+            },
+
+            Spec::LifeRGPlus => SpecValues {
+                base: 225,
+                bonuses: vec![
+                    SpecBonus { req: Colours { red: 2, green: 2, blue: 0 }, bonus: 100 },
+                    SpecBonus { req: Colours { red: 5, green: 5, blue: 0 }, bonus: 150 },
+                    SpecBonus { req: Colours { red: 10, green: 10, blue: 0 }, bonus: 225 }
+                ],
+            },
+
+            Spec::LifeGBPlus => SpecValues {
+                base: 225,
+                bonuses: vec![
+                    SpecBonus { req: Colours { red: 0, green: 2, blue: 2 }, bonus: 100 },
+                    SpecBonus { req: Colours { red: 0, green: 5, blue: 5 }, bonus: 150 },
+                    SpecBonus { req: Colours { red: 0, green: 10, blue: 10 }, bonus: 225 }
+                ],
+            },
+
+            Spec::LifeRBPlus => SpecValues {
+                base: 350,
+                bonuses: vec![
+                    SpecBonus { req: Colours { red: 2, green: 0, blue: 2 },  bonus: 100 },
+                    SpecBonus { req: Colours { red: 5, green: 0, blue: 5 }, bonus: 150 },
+                    SpecBonus { req: Colours { red: 10, green: 0, blue: 10 }, bonus: 225 }
+                ],
+            },
+            Spec::LifeRRPlusPlus => SpecValues {
+                base: 875,
+                bonuses: vec![
+                    SpecBonus { req: Colours { red: 5, green: 0, blue: 0 }, bonus: 225 },
+                    SpecBonus { req: Colours { red: 10, green: 0, blue: 0 }, bonus: 400 },
+                    SpecBonus { req: Colours { red: 20, green: 0, blue: 0 }, bonus: 525 }
+                ],
+            },
+
+            Spec::LifeGGPlusPlus => SpecValues {
+                base: 475,
+                bonuses: vec![
+                    SpecBonus { req: Colours { red: 0, green: 5, blue: 0 }, bonus: 130 },
+                    SpecBonus { req: Colours { red: 0, green: 10, blue: 0 }, bonus: 225 },
+                    SpecBonus { req: Colours { red: 0, green: 20, blue: 0 }, bonus: 300 }
+                ],
+            },
+
+            Spec::LifeBBPlusPlus => SpecValues {
+                base: 875,
+                bonuses: vec![
+                    SpecBonus { req: Colours { red: 0, green: 0, blue: 5 }, bonus: 225 },
+                    SpecBonus { req: Colours { red: 0, green: 0, blue: 10 }, bonus: 400 },
+                    SpecBonus { req: Colours { red: 0, green: 0, blue: 20 }, bonus: 525 }
+                ],
+            },
+
+            Spec::LifeRGPlusPlus => SpecValues {
+                base: 400,
+                bonuses: vec![
+                    SpecBonus { req: Colours { red: 2, green: 2, blue: 0 }, bonus: 175 },
+                    SpecBonus { req: Colours { red: 5, green: 5, blue: 0 }, bonus: 275 },
+                    SpecBonus { req: Colours { red: 10, green: 10, blue: 0 }, bonus: 400 }
+                ],
+            },
+
+            Spec::LifeGBPlusPlus => SpecValues {
+                base: 625,
+                bonuses: vec![
+                    SpecBonus { req: Colours { red: 0, green: 2, blue: 2 }, bonus: 175 },
+                    SpecBonus { req: Colours { red: 0, green: 5, blue: 5 }, bonus: 275 },
+                    SpecBonus { req: Colours { red: 0, green: 10, blue: 10 }, bonus: 400 }
+                ],
+            },
+
+            Spec::LifeRBPlusPlus => SpecValues {
+                base: 400,
+                bonuses: vec![
+                    SpecBonus { req: Colours { red: 2, green: 0, blue: 2 },  bonus: 175 },
+                    SpecBonus { req: Colours { red: 5, green: 0, blue: 5 }, bonus: 275 },
+                    SpecBonus { req: Colours { red: 10, green: 0, blue: 10 }, bonus: 400 }
+                ],
+            },
+        }
+    }
+
+    pub fn apply(&self, modified: u64, base: u64, player_colours: &Colours) -> u64 {
+        match *self {
+            // Percentage multipliers based on base value
+            Spec::Power |
+            Spec::Speed  => modified + base.pct(self.values().base),
+            Spec::PowerRR|
+            Spec::PowerGG|
+            Spec::PowerBB|
+            Spec::PowerRG|
+            Spec::PowerGB|
+            Spec::PowerRB|
+            Spec::PowerRRPlus |
+            Spec::PowerGGPlus |
+            Spec::PowerBBPlus |
+            Spec::PowerRGPlus |
+            Spec::PowerGBPlus |
+            Spec::PowerRBPlus |
+            Spec::PowerRRPlusPlus |
+            Spec::PowerGGPlusPlus |
+            Spec::PowerBBPlusPlus |
+            Spec::PowerRGPlusPlus |
+            Spec::PowerGBPlusPlus |
+            Spec::PowerRBPlusPlus |
+
+            Spec::SpeedRR|
+            Spec::SpeedGG|
+            Spec::SpeedBB|
+            Spec::SpeedRG|
+            Spec::SpeedGB|
+            Spec::SpeedRB|
+            Spec::SpeedRRPlus |
+            Spec::SpeedGGPlus |
+            Spec::SpeedBBPlus |
+            Spec::SpeedRGPlus |
+            Spec::SpeedGBPlus |
+            Spec::SpeedRBPlus |
+            Spec::SpeedRRPlusPlus |
+            Spec::SpeedGGPlusPlus |
+            Spec::SpeedBBPlusPlus |
+            Spec::SpeedRGPlusPlus |
+            Spec::SpeedGBPlusPlus |
+            Spec::SpeedRBPlusPlus => modified + base.pct(self.values().max_value(player_colours)),
+
+            // Flat bonus
+            Spec::Life => modified + self.values().base,
+            Spec::LifeRR|
+            Spec::LifeGG|
+            Spec::LifeBB|
+            Spec::LifeRG|
+            Spec::LifeGB|
+            Spec::LifeRB|
+            Spec::LifeRRPlus |
+            Spec::LifeGGPlus |
+            Spec::LifeBBPlus |
+            Spec::LifeRGPlus |
+            Spec::LifeGBPlus |
+            Spec::LifeRBPlus |
+            Spec::LifeRRPlusPlus |
+            Spec::LifeGGPlusPlus |
+            Spec::LifeBBPlusPlus |
+            Spec::LifeRGPlusPlus |
+            Spec::LifeGBPlusPlus |
+            Spec::LifeRBPlusPlus => modified + self.values().max_value(player_colours),
+        }
+    }
+}

core/src/util.rs

@@ -0,0 +1,40 @@
+// use net::Db;
+// Db Commons
+// use failure::Error;
+
+// pub fn startup(db: Db) -> Result<(), Error> {
+//     let tx = db.transaction()?;
+
+//     info!("running startup fns");
+
+//     match tx.commit() {
+//         Ok(_) => {
+//             info!("startup processes completed");
+//             Ok(())
+//         },
+//         Err(e) => Err(format_err!("failed to commit startup tx {:?}", e)),
+//     }
+// }
+
+pub trait IntPct {
+    fn pct(self, pct: u64) -> u64;
+}
+
+impl IntPct for u64 {
+    fn pct(self, pct: u64) -> u64 {
+        self * pct / 100
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn int_pct_test() {
+        assert_eq!(100.pct(110), 110);
+        assert_eq!(100.pct(50), 50);
+        assert_eq!(1.pct(200), 2);
+        assert_eq!(1.pct(50), 0);
+    }
+}

core/src/vbox.rs

@@ -0,0 +1,305 @@
+use uuid::Uuid;
+
+use std::iter;
+use std::collections::HashMap;
+
+// refunds
+use rand::prelude::*;
+use rand::{thread_rng};
+use rand::distributions::{WeightedIndex};
+
+use failure::Error;
+use failure::err_msg;
+
+use instance::{Instance};
+use construct::{Colours};
+
+use item::*;
+
+pub type VboxIndices = Option<HashMap<ItemType, Vec<String>>>;
+
+#[derive(Debug,Clone,Serialize,Deserialize)]
+pub struct Vbox {
+    pub bits: usize,
+    pub store: HashMap<ItemType, HashMap<String, Item>>,
+    pub stash: HashMap<String, Item>,
+}
+
+#[derive(Debug,Copy,Clone,Serialize,Deserialize,Hash,PartialEq,Eq)]
+pub enum ItemType {
+    Colours,
+    Skills,
+    Specs,
+}
+
+const STORE_COLOURS_CAPACITY: usize = 6;
+const STORE_SKILLS_CAPACITY: usize = 3;
+const STORE_SPECS_CAPACITY: usize = 3;
+const STASH_CAPACITY: usize = 6;
+const STARTING_ATTACK_COUNT: usize = 3;
+
+impl Vbox {
+    pub fn new() -> Vbox {
+        let mut colours: HashMap<String, Item> = HashMap::new();
+        let mut skills: HashMap<String, Item> = HashMap::new();
+        let mut specs: HashMap<String, Item> = HashMap::new();
+
+        let store = [
+            (ItemType::Colours, colours),
+            (ItemType::Skills, skills),
+            (ItemType::Colours, specs),
+        ].iter().cloned().collect();
+
+        let mut stash = HashMap::new();
+        for i in 0..STARTING_ATTACK_COUNT {
+            stash.insert(i.to_string(), Item::Attack);
+        }
+
+        Vbox {
+            store,
+            stash,
+            bits: 30,
+        }
+    }
+
+    pub fn balance_sub(&mut self, amount: usize) -> Result<&mut Vbox, Error> {
+        let new_balance = self.bits
+            .checked_sub(amount)
+            .ok_or(format_err!("insufficient balance: {:?}", self.bits))?;
+
+        self.bits = new_balance;
+
+        Ok(self)
+    }
+
+    pub fn balance_add(&mut self, amount: usize) -> &mut Vbox {
+        self.bits = self.bits.saturating_add(amount);
+        self
+    }
+
+    pub fn fill(&mut self) -> &mut Vbox {
+        let mut rng = thread_rng();
+
+        let colours = vec![
+            (Item::Red, 1),
+            (Item::Green, 1),
+            (Item::Blue, 1),
+        ];
+        let colour_dist = WeightedIndex::new(colours.iter().map(|item| item.1)).unwrap();
+
+        let skills = vec![
+            (Item::Attack, 1),
+            (Item::Block, 1),
+            (Item::Buff, 1),
+            (Item::Debuff, 1),
+            (Item::Stun, 1),
+        ];
+        let skill_dist = WeightedIndex::new(skills.iter().map(|item| item.1)).unwrap();
+
+        let specs = vec![
+            (Item::Power, 1),
+            (Item::Life, 1),
+            (Item::Speed, 1),
+        ];
+        let spec_dist = WeightedIndex::new(specs.iter().map(|item| item.1)).unwrap();
+
+        for item_type in [ItemType::Colours, ItemType::Skills, ItemType::Specs].iter() {
+            let (items, num, dist) = match item_type {
+                ItemType::Colours => (&colours, STORE_COLOURS_CAPACITY, &colour_dist),
+                ItemType::Skills => (&skills, STORE_SKILLS_CAPACITY, &skill_dist),
+                ItemType::Specs => (&specs, STORE_SPECS_CAPACITY, &spec_dist),
+            };
+
+            let drops = iter::repeat_with(|| items[dist.sample(&mut rng)].0)
+                .take(num)
+                .enumerate()
+                .map(|(i, item)| (i.to_string(), item))
+                .collect::<HashMap<String, Item>>();
+
+            self.store.insert(*item_type, drops);
+        }
+
+        self
+    }
+
+    pub fn buy(&mut self, item: ItemType, i: &String) -> Result<Item, Error> {
+        // check item exists
+        let selection = self.store
+            .get_mut(&item).ok_or(format_err!("no item group {:?}", item))?
+            .remove(i).ok_or(format_err!("no item at index {:?} {:}", self, i))?;
+
+        self.balance_sub(selection.cost())?;
+
+        Ok(selection)
+    }
+
+    pub fn stash_add(&mut self, item: Item, index: Option<&String>) -> Result<String, Error> {
+        if self.stash.len() >= STASH_CAPACITY {
+            return Err(err_msg("stash full"));
+        }
+
+        if let Some(index) = index {
+            if self.stash.contains_key(index) {
+                return Err(format_err!("slot occupied {:?}", index));
+            }
+            self.stash.insert(index.clone(), item);
+            return Ok(index.to_string());
+        }
+
+        for i in (0..STASH_CAPACITY).map(|i| i.to_string()) {
+            if !self.stash.contains_key(&i) {
+                self.stash.insert(i.clone(), item);
+                return Ok(i);
+            }
+        }
+
+        return Err(err_msg("stash full"));
+    }
+
+    pub fn bot_buy(&mut self, item: ItemType) -> Result<Item, Error> {
+        let buy_index = self.store[&item]
+            .keys()
+            .next()
+            .ok_or(format_err!("no item in group {:?}", item))?
+            .clone();
+
+        self.buy(item, &buy_index)
+    }
+
+    pub fn refund(&mut self, i: String) -> Result<&mut Vbox, Error> {
+        let refunded = self.stash.remove(&i)
+            .ok_or(format_err!("no item at index {:?} {:?}", self.stash, i))?;
+
+        let refund = refunded.cost();
+        // info!("refunding {:?} for {:?}", refund, refunded);
+        self.balance_add(refund);
+        Ok(self)
+    }
+
+    pub fn combine(&mut self, stash_indices: Vec<String>, store_indices: Option<HashMap<ItemType, Vec<String>>>) -> Result<&mut Vbox, Error> {
+        // find base item for index to insert into
+        let base_index = stash_indices.iter()
+            .find(|i| match self.stash.get(i.clone()) {
+                Some(item) => item.into_skill().is_some(),
+                None => false,
+            });
+
+        let mut input = stash_indices
+            .iter()
+            .map(|i| self.stash.remove(i)
+                .ok_or(format_err!("no item at index {:?} {:?}", self.stash, i)))
+            .collect::<Result<Vec<Item>, Error>>()?;
+
+        if let Some(store_indices) = store_indices {
+            let mut purchased = store_indices.iter()
+                .map(|(g, list)|
+                    list.iter()
+                        .map(|i| self.buy(*g, i))
+                        .collect::<Result<Vec<Item>, Error>>()
+                )
+                .collect::<Result<Vec<Vec<Item>>, Error>>()?
+                .into_iter()
+                .flatten()
+                .collect();
+
+            input.append(&mut purchased);
+        }
+
+        // sort the input to align with the combinations
+        // combos are sorted when created
+        input.sort_unstable();
+        let combos = get_combos();
+        let combo = combos.iter().find(|c| c.components == input).ok_or(err_msg("not a combo"))?;
+
+        self.stash_add(combo.item, base_index)?;
+
+        Ok(self)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn combine_test() {
+        let mut vbox = Vbox::new();
+        vbox.stash.insert(0.to_string(), Item::Attack);
+        vbox.stash.insert(1.to_string(), Item::Green);
+        vbox.stash.insert(2.to_string(), Item::Green);
+        vbox.combine(vec![0.to_string(), 1.to_string(), 2.to_string()], None).unwrap();
+        assert_eq!(vbox.stash["0"], Item::Heal);
+    }
+
+    #[test]
+    fn buy_test() {
+        let mut vbox = Vbox::new();
+        vbox.fill();
+
+        // cannot rebuy same
+        vbox.buy(ItemType::Skills, &0.to_string()).unwrap();
+        assert!(vbox.store[&ItemType::Skills].get(&0.to_string()).is_none());
+        assert!(vbox.buy(ItemType::Skills, &0.to_string()).is_err());
+    }
+
+    #[test]
+    fn capacity_test() {
+        let mut vbox = Vbox::new();
+        vbox.fill();
+        vbox.stash_add(Item::Red, None).unwrap();
+        vbox.stash_add(Item::Red, None).unwrap();
+        vbox.stash_add(Item::Red, None).unwrap();
+        assert!(vbox.stash_add(Item::Red, None).is_err());
+    }
+
+    #[test]
+    fn store_and_stash_combine_test() {
+        let mut vbox = Vbox::new();
+        vbox.fill();
+
+        let mut skill_combine_args = HashMap::new();
+        skill_combine_args.insert(ItemType::Colours, vec![0.to_string(), 1.to_string()]);
+        skill_combine_args.insert(ItemType::Skills, vec![0.to_string()]);
+
+        let mut spec_combine_args = HashMap::new();
+        spec_combine_args.insert(ItemType::Colours, vec![2.to_string(), 3.to_string()]);
+        spec_combine_args.insert(ItemType::Specs, vec![0.to_string()]);
+
+        vbox.combine(vec![], Some(skill_combine_args)).unwrap();
+        vbox.combine(vec![], Some(spec_combine_args)).unwrap();
+    }
+
+    #[test]
+    fn combos_test() {
+        let mut input = vec![Item::Green, Item::Attack, Item::Green];
+        let combos = get_combos();
+
+        // sort input so they align
+        input.sort_unstable();
+
+        let combo = combos.iter().find(|c| c.components == input);
+        assert!(combo.is_some());
+    }
+
+    #[test]
+    fn refund_test() {
+        let mut vbox = Vbox::new();
+        vbox.stash.insert(0.to_string(), Item::Strike);
+        vbox.refund(0.to_string()).unwrap();
+        assert_eq!(vbox.bits, 32);
+    }
+
+    #[test]
+    fn colours_count_test() {
+        let strike = Item::Strike;
+
+        let mut count = Colours::new();
+        strike.colours(&mut count);
+        assert_eq!(count.red, 2);
+    }
+
+    // #[test]
+    // fn item_info_test() {
+    //     info!("{:#?}", item_info());
+    // }
+}