diff --git a/client/src/constants.jsx b/client/src/constants.jsx index 882d8ce8..4624cebd 100644 --- a/client/src/constants.jsx +++ b/client/src/constants.jsx @@ -1,9 +1,9 @@ module.exports = { TIMES: { - RESOLUTION_TIME_MS: 2000, - START_SKILL: 1000, - END_SKILL: 1000, - POST_SKILL: 1000, + RESOLUTION_TIME_MS: 1000, + START_SKILL: 500, + END_SKILL: 500, + POST_SKILL: 500, }, ITEMS: { diff --git a/server/src/cryp.rs b/server/src/cryp.rs index f673d87d..b4701fce 100644 --- a/server/src/cryp.rs +++ b/server/src/cryp.rs @@ -11,7 +11,7 @@ use account::{Account}; use rpc::{CrypSpawnParams}; use skill::{Skill, Cooldown, Effect, Cast, Category, Immunity, Disable, Event}; use spec::{Spec}; -use vbox::Var; +use vbox::Item; #[derive(Debug,Clone,Serialize,Deserialize)] pub struct Colours { @@ -29,12 +29,12 @@ impl Colours { let mut count = Colours::new(); for spec in cryp.specs.iter() { - let v = Var::from(*spec); + let v = Item::from(*spec); v.colours(&mut count); } for cs in cryp.skills.iter() { - let v = Var::from(cs.skill); + let v = Item::from(cs.skill); v.colours(&mut count); } diff --git a/server/src/instance.rs b/server/src/instance.rs index c5390115..aac7d318 100644 --- a/server/src/instance.rs +++ b/server/src/instance.rs @@ -19,7 +19,7 @@ use player::{Player, player_create, player_get, player_global_update}; use cryp::{Cryp, cryp_get}; use mob::{instance_mobs}; use game::{Game, Phase, game_get, game_write, game_instance_new}; -use vbox::{Var}; +use vbox::{Item}; use rpc::{RpcResult}; use names::{name}; @@ -479,7 +479,7 @@ impl Instance { Ok(self) } - pub fn vbox_unequip(mut self, account: Uuid, target: Var, cryp_id: Uuid) -> Result { + pub fn vbox_unequip(mut self, account: Uuid, target: Item, cryp_id: Uuid) -> Result { self.vbox_action_allowed(account)?; self.account_player(account)? .vbox_unequip(target, cryp_id)?; diff --git a/server/src/player.rs b/server/src/player.rs index 24cba37f..3f0e67ed 100644 --- a/server/src/player.rs +++ b/server/src/player.rs @@ -10,7 +10,7 @@ use failure::err_msg; use account::Account; use cryp::{Cryp, Colours, cryp_get}; -use vbox::{Vbox, Var, VarEffect}; +use vbox::{Vbox, Item, ItemEffect}; use rpc::{PlayerCrypsSetParams}; use instance::{Instance, instance_get, instance_update}; use skill::{Effect}; @@ -130,7 +130,7 @@ impl Player { let num_colours = self.vbox.bound .iter() - .filter(|v| [Var::Red, Var::Green, Var::Blue].contains(v)) + .filter(|v| [Item::Red, Item::Green, Item::Blue].contains(v)) .count(); if self.vbox.bound.len() < 3 || num_colours < 2 { @@ -150,7 +150,7 @@ impl Player { // info!("{:?}", self.vbox.bound); - let skills = [Var::Attack, Var::Block, Var::Buff, Var::Debuff, Var::Stun]; + let skills = [Item::Attack, Item::Block, Item::Buff, Item::Debuff, Item::Stun]; let combo_i = match group_i { 1 => self.vbox.bound.iter().position(|v| skills.contains(v)).expect("no skill found"), 2 => self.vbox.bound.iter().position(|v| v.into_spec().is_some()).expect("no spec found"), @@ -159,8 +159,8 @@ impl Player { // first 2 colours can be whatever self.vbox_combine(vec![0, 1, combo_i]).ok(); - let var_i = self.vbox.bound.len() - 1; - self.vbox_apply(var_i, target_cryp_id).ok(); + let item_i = self.vbox.bound.len() - 1; + self.vbox_apply(item_i, target_cryp_id).ok(); } return self; @@ -188,11 +188,11 @@ impl Player { } pub fn vbox_apply(&mut self, index: usize, cryp_id: Uuid) -> Result<&mut Player, Error> { - let var = self.vbox.bound.remove(index); + let item = self.vbox.bound.remove(index); - match var.effect() { - Some(VarEffect::Skill) => { - let skill = var.into_skill().ok_or(format_err!("var {:?} has no associated skill", var))?; + match item.effect() { + Some(ItemEffect::Skill) => { + let skill = item.into_skill().ok_or(format_err!("item {:?} has no associated skill", item))?; let cryp = self.cryp_get(cryp_id)?; // done here because i teach them a tonne of skills for tests let max_skills = 3; @@ -206,16 +206,16 @@ impl Player { cryp.learn_mut(skill); }, - Some(VarEffect::Spec) => { - let spec = var.into_spec().ok_or(format_err!("var {:?} has no associated spec", var))?; + Some(ItemEffect::Spec) => { + let spec = item.into_spec().ok_or(format_err!("item {:?} has no associated spec", item))?; let cryp = self.cryp_get(cryp_id)?; cryp.spec_add(spec)?; }, - None => return Err(err_msg("var has no effect on cryps")), + None => return Err(err_msg("item has no effect on cryps")), } - // now the var has been applied + // now the item has been applied // recalculate the stats of the whole player let player_colours = self.cryps.iter().fold(Colours::new(), |tc, c| { Colours { @@ -232,26 +232,26 @@ impl Player { Ok(self) } - pub fn vbox_unequip(&mut self, target: Var, cryp_id: Uuid) -> Result<&mut Player, Error> { + pub fn vbox_unequip(&mut self, target: Item, cryp_id: Uuid) -> Result<&mut Player, Error> { if self.vbox.bound.len() >= 9 { - return Err(err_msg("too many vars bound")); + return Err(err_msg("too many items bound")); } match target.effect() { - Some(VarEffect::Skill) => { - let skill = target.into_skill().ok_or(format_err!("var {:?} has no associated skill", target))?; + Some(ItemEffect::Skill) => { + let skill = target.into_skill().ok_or(format_err!("item {:?} has no associated skill", target))?; let cryp = self.cryp_get(cryp_id)?; cryp.forget(skill)?; }, - Some(VarEffect::Spec) => { - let spec = target.into_spec().ok_or(format_err!("var {:?} has no associated spec", target))?; + Some(ItemEffect::Spec) => { + let spec = target.into_spec().ok_or(format_err!("item {:?} has no associated spec", target))?; let cryp = self.cryp_get(cryp_id)?; cryp.spec_remove(spec)?; }, - None => return Err(err_msg("var has no effect on cryps")), + None => return Err(err_msg("item has no effect on cryps")), } - // now the var has been applied + // now the item has been applied // recalculate the stats of the whole player let player_colours = self.cryps.iter().fold(Colours::new(), |tc, c| { Colours { diff --git a/server/src/rpc.rs b/server/src/rpc.rs index a04c5968..dac72479 100644 --- a/server/src/rpc.rs +++ b/server/src/rpc.rs @@ -23,7 +23,7 @@ use skill::{Skill}; use spec::{Spec}; use player::{Score, player_mm_cryps_set}; use instance::{Instance, instance_state, instance_new, instance_ready, instance_join}; -use vbox::{Var, VboxInfo, vbox_accept, vbox_apply, vbox_discard, vbox_combine, vbox_reclaim, vbox_unequip, vbox_info}; +use vbox::{Item, VboxInfo, vbox_accept, vbox_apply, vbox_discard, vbox_combine, vbox_reclaim, vbox_unequip, vbox_info}; pub struct Rpc; @@ -653,7 +653,7 @@ struct VboxUnequipMsg { pub struct VboxUnequipParams { pub instance_id: Uuid, pub cryp_id: Uuid, - pub target: Var, + pub target: Item, } #[derive(Debug,Clone,Serialize,Deserialize)] diff --git a/server/src/skill.rs b/server/src/skill.rs index aca39f14..6d29aeac 100644 --- a/server/src/skill.rs +++ b/server/src/skill.rs @@ -3,7 +3,7 @@ use uuid::Uuid; use util::{IntPct}; use cryp::{Cryp, CrypEffect, EffectMeta, Stat}; -use vbox::{Var}; +use vbox::{Item}; use game::{Game}; @@ -905,13 +905,13 @@ impl Skill { Skill::StrikeII => Skill::Strike.speed(), Skill::StrikeIII => Skill::Strike.speed(), - Skill::SiphonTick => Var::from(Skill::Siphon).speed(), - Skill::DecayTick => Var::from(Skill::Decay).speed(), - Skill::TriageTick => Var::from(Skill::Triage).speed(), - Skill::StrangleTick => Var::from(Skill::Strangle).speed(), - Skill::CorruptionTick => Var::from(Skill::Corrupt).speed(), + Skill::SiphonTick => Item::from(Skill::Siphon).speed(), + Skill::DecayTick => Item::from(Skill::Decay).speed(), + Skill::TriageTick => Item::from(Skill::Triage).speed(), + Skill::StrangleTick => Item::from(Skill::Strangle).speed(), + Skill::CorruptionTick => Item::from(Skill::Corrupt).speed(), - _ => Var::from(*self).speed(), + _ => Item::from(*self).speed(), } } diff --git a/server/src/vbox.rs b/server/src/vbox.rs index 660902a7..c371107a 100644 --- a/server/src/vbox.rs +++ b/server/src/vbox.rs @@ -19,7 +19,7 @@ use instance::{Instance, instance_get, instance_update}; use cryp::{Colours}; #[derive(Debug,Copy,Clone,Serialize,Deserialize,PartialEq,PartialOrd,Ord,Eq)] -pub enum Var { +pub enum Item { // colours Blue, Green, @@ -104,20 +104,20 @@ pub enum Var { TestSiphon, } -pub enum VarEffect { +pub enum ItemEffect { Skill, Spec, } -impl Var { +impl Item { pub fn colours(&self, count: &mut Colours) { let combos = get_combos(); - let combo = combos.iter().find(|c| c.var == *self); + let combo = combos.iter().find(|c| c.item == *self); match combo { Some(c) => c.units.iter().for_each(|unit| match unit { - Var::Red => count.red += 1, - Var::Blue => count.blue += 1, - Var::Green => count.green += 1, + Item::Red => count.red += 1, + Item::Blue => count.blue += 1, + Item::Green => count.green += 1, _ => { let mut combo_count = Colours::new(); unit.colours(&mut combo_count); @@ -132,23 +132,23 @@ impl Var { fn cost(&self) -> u16 { match self { - Var::Red => 1, - Var::Green => 1, - Var::Blue => 1, + Item::Red => 1, + Item::Green => 1, + Item::Blue => 1, - Var::Attack => 2, - Var::Block => 2, - Var::Buff => 2, - Var::Debuff => 2, - Var::Stun => 2, + Item::Attack => 2, + Item::Block => 2, + Item::Buff => 2, + Item::Debuff => 2, + Item::Stun => 2, - Var::Damage => 3, - Var::Life => 3, - Var::Speed => 3, + Item::Damage => 3, + Item::Life => 3, + Item::Speed => 3, _ => { let combos = get_combos(); - let combo = combos.iter().find(|c| c.var == *self) + let combo = combos.iter().find(|c| c.item == *self) .unwrap_or_else(|| panic!("unable to find components for {:?}", self)); return combo.units.iter().fold(0, |acc, c| acc + c.cost()); }, @@ -157,187 +157,187 @@ impl Var { pub fn speed(&self) -> u8 { match self { - Var::Red => 3, - Var::Green => 2, - Var::Blue => 1, + Item::Red => 3, + Item::Green => 2, + Item::Blue => 1, - Var::Attack => 1, - Var::Stun => 2, - Var::Block => 3, - Var::Buff => 4, - Var::Debuff => 4, + Item::Attack => 1, + Item::Stun => 2, + Item::Block => 3, + Item::Buff => 4, + Item::Debuff => 4, _ => { let combos = get_combos(); - let combo = combos.iter().find(|c| c.var == *self) + let combo = combos.iter().find(|c| c.item == *self) .unwrap_or_else(|| panic!("unable to find components for {:?}", self)); return combo.units.iter().fold(0, |acc, c| acc + c.speed()); }, } } - pub fn effect(&self) -> Option { + pub fn effect(&self) -> Option { if let Some(_skill) = self.into_skill() { - return Some(VarEffect::Skill); + return Some(ItemEffect::Skill); } if let Some(_spec) = self.into_spec() { - return Some(VarEffect::Spec); + return Some(ItemEffect::Spec); } return None; } pub fn into_skill(&self) -> Option { match self { - Var::Attack => Some(Skill::Attack), - Var::Amplify => Some(Skill::Amplify), - Var::Banish => Some(Skill::Banish), - Var::Blast => Some(Skill::Blast), - Var::Block => Some(Skill::Block), - Var::Chaos => Some(Skill::Chaos), - Var::Curse => Some(Skill::Curse), - Var::Debuff => Some(Skill::Debuff), - Var::Decay => Some(Skill::Decay), - Var::Haste => Some(Skill::Haste), - Var::Heal => Some(Skill::Heal), - Var::Hex => Some(Skill::Hex), - Var::Hostility => Some(Skill::Hostility), - Var::Impurity => Some(Skill::Impurity), - Var::Invert => Some(Skill::Invert), - Var::Parry => Some(Skill::Parry), - Var::Purge => Some(Skill::Purge), - Var::Purify => Some(Skill::Purify), - Var::Recharge => Some(Skill::Recharge), - Var::Reflect => Some(Skill::Reflect), - Var::Ruin => Some(Skill::Ruin), - Var::Scatter => Some(Skill::Scatter), - Var::Silence => Some(Skill::Silence), - Var::Slay => Some(Skill::Slay), - Var::Sleep => Some(Skill::Sleep), - Var::Siphon => Some(Skill::Siphon), - Var::Snare => Some(Skill::Snare), - Var::Strangle => Some(Skill::Strangle), - Var::Stun => Some(Skill::Stun), - Var::Strike => Some(Skill::Strike), - Var::StrikeII => Some(Skill::StrikeII), - Var::StrikeIII => Some(Skill::StrikeIII), - Var::Clutch => Some(Skill::Clutch), - Var::Taunt => Some(Skill::Taunt), - Var::Throw => Some(Skill::Throw), - Var::Corrupt => Some(Skill::Corrupt), - Var::Triage => Some(Skill::Triage), + Item::Attack => Some(Skill::Attack), + Item::Amplify => Some(Skill::Amplify), + Item::Banish => Some(Skill::Banish), + Item::Blast => Some(Skill::Blast), + Item::Block => Some(Skill::Block), + Item::Chaos => Some(Skill::Chaos), + Item::Curse => Some(Skill::Curse), + Item::Debuff => Some(Skill::Debuff), + Item::Decay => Some(Skill::Decay), + Item::Haste => Some(Skill::Haste), + Item::Heal => Some(Skill::Heal), + Item::Hex => Some(Skill::Hex), + Item::Hostility => Some(Skill::Hostility), + Item::Impurity => Some(Skill::Impurity), + Item::Invert => Some(Skill::Invert), + Item::Parry => Some(Skill::Parry), + Item::Purge => Some(Skill::Purge), + Item::Purify => Some(Skill::Purify), + Item::Recharge => Some(Skill::Recharge), + Item::Reflect => Some(Skill::Reflect), + Item::Ruin => Some(Skill::Ruin), + Item::Scatter => Some(Skill::Scatter), + Item::Silence => Some(Skill::Silence), + Item::Slay => Some(Skill::Slay), + Item::Sleep => Some(Skill::Sleep), + Item::Siphon => Some(Skill::Siphon), + Item::Snare => Some(Skill::Snare), + Item::Strangle => Some(Skill::Strangle), + Item::Stun => Some(Skill::Stun), + Item::Strike => Some(Skill::Strike), + Item::StrikeII => Some(Skill::StrikeII), + Item::StrikeIII => Some(Skill::StrikeIII), + Item::Clutch => Some(Skill::Clutch), + Item::Taunt => Some(Skill::Taunt), + Item::Throw => Some(Skill::Throw), + Item::Corrupt => Some(Skill::Corrupt), + Item::Triage => Some(Skill::Triage), _ => None, } } pub fn into_spec(&self) -> Option { match *self { - Var::Speed => Some(Spec::Speed), - Var::RedSpeedI => Some(Spec::RedSpeedI), - Var::BlueSpeedI => Some(Spec::BlueSpeedI), - Var::GreenSpeedI => Some(Spec::GreenSpeedI), - Var::GRSpeedI => Some(Spec::GRSpeedI), - Var::GBSpeedI => Some(Spec::GBSpeedI), - Var::RBSpeedI => Some(Spec::RBSpeedI), + Item::Speed => Some(Spec::Speed), + Item::RedSpeedI => Some(Spec::RedSpeedI), + Item::BlueSpeedI => Some(Spec::BlueSpeedI), + Item::GreenSpeedI => Some(Spec::GreenSpeedI), + Item::GRSpeedI => Some(Spec::GRSpeedI), + Item::GBSpeedI => Some(Spec::GBSpeedI), + Item::RBSpeedI => Some(Spec::RBSpeedI), - Var::Damage => Some(Spec::Damage), - Var::RedDamageI => Some(Spec::RedDamageI), - Var::BlueDamageI => Some(Spec::BlueDamageI), - Var::GreenDamageI => Some(Spec::GreenDamageI), - Var::GRDI => Some(Spec::GRDI), - Var::GBDI => Some(Spec::GBDI), - Var::RBDI => Some(Spec::RBDI), + Item::Damage => Some(Spec::Damage), + Item::RedDamageI => Some(Spec::RedDamageI), + Item::BlueDamageI => Some(Spec::BlueDamageI), + Item::GreenDamageI => Some(Spec::GreenDamageI), + Item::GRDI => Some(Spec::GRDI), + Item::GBDI => Some(Spec::GBDI), + Item::RBDI => Some(Spec::RBDI), - Var::Life => Some(Spec::Life), - Var::GRLI => Some(Spec::GRLI), - Var::GBLI => Some(Spec::GBLI), - Var::RBLI => Some(Spec::RBLI), - Var::GreenLifeI => Some(Spec::GreenLifeI), - Var::RedLifeI => Some(Spec::RedLifeI), - Var::BlueLifeI => Some(Spec::BlueLifeI), + Item::Life => Some(Spec::Life), + Item::GRLI => Some(Spec::GRLI), + Item::GBLI => Some(Spec::GBLI), + Item::RBLI => Some(Spec::RBLI), + Item::GreenLifeI => Some(Spec::GreenLifeI), + Item::RedLifeI => Some(Spec::RedLifeI), + Item::BlueLifeI => Some(Spec::BlueLifeI), _ => None, } } } -impl From for Var { - fn from(skill: Skill) -> Var { +impl From for Item { + fn from(skill: Skill) -> Item { match skill { - Skill::Amplify => Var::Amplify, - Skill::Attack => Var::Attack, - Skill::Banish => Var::Banish, - Skill::Blast => Var::Blast, - Skill::Block => Var::Block, - Skill::Chaos => Var::Chaos, - Skill::Curse => Var::Curse, - Skill::Clutch => Var::Clutch, - Skill::Decay => Var::Decay, - Skill::Debuff => Var::Debuff, - Skill::Haste => Var::Haste, - Skill::Hostility => Var::Hostility, - Skill::Heal => Var::Heal, - Skill::Hex => Var::Hex, - Skill::Impurity => Var::Impurity, - Skill::Invert => Var::Invert, - Skill::Parry => Var::Parry, - Skill::Purge => Var::Purge, - Skill::Purify => Var::Purify, - Skill::Recharge => Var::Recharge, - Skill::Reflect => Var::Reflect, - Skill::Ruin => Var::Ruin, - Skill::Scatter => Var::Scatter, - Skill::Silence => Var::Silence, - Skill::Siphon => Var::Siphon, - Skill::Slay => Var::Slay, - Skill::Sleep => Var::Sleep, - Skill::Snare => Var::Snare, - Skill::Strangle => Var::Strangle, - Skill::Strike => Var::Strike, - Skill::StrikeII => Var::StrikeII, - Skill::StrikeIII => Var::StrikeIII, - Skill::Stun => Var::Stun, - Skill::Taunt => Var::Taunt, - Skill::Throw => Var::Throw, - Skill::Triage => Var::Triage, - Skill::Corrupt => Var::Corrupt, + Skill::Amplify => Item::Amplify, + Skill::Attack => Item::Attack, + Skill::Banish => Item::Banish, + Skill::Blast => Item::Blast, + Skill::Block => Item::Block, + Skill::Chaos => Item::Chaos, + Skill::Curse => Item::Curse, + Skill::Clutch => Item::Clutch, + Skill::Decay => Item::Decay, + Skill::Debuff => Item::Debuff, + Skill::Haste => Item::Haste, + Skill::Hostility => Item::Hostility, + Skill::Heal => Item::Heal, + Skill::Hex => Item::Hex, + Skill::Impurity => Item::Impurity, + Skill::Invert => Item::Invert, + Skill::Parry => Item::Parry, + Skill::Purge => Item::Purge, + Skill::Purify => Item::Purify, + Skill::Recharge => Item::Recharge, + Skill::Reflect => Item::Reflect, + Skill::Ruin => Item::Ruin, + Skill::Scatter => Item::Scatter, + Skill::Silence => Item::Silence, + Skill::Siphon => Item::Siphon, + Skill::Slay => Item::Slay, + Skill::Sleep => Item::Sleep, + Skill::Snare => Item::Snare, + Skill::Strangle => Item::Strangle, + Skill::Strike => Item::Strike, + Skill::StrikeII => Item::StrikeII, + Skill::StrikeIII => Item::StrikeIII, + Skill::Stun => Item::Stun, + Skill::Taunt => Item::Taunt, + Skill::Throw => Item::Throw, + Skill::Triage => Item::Triage, + Skill::Corrupt => Item::Corrupt, - Skill::TestTouch => Var::TestTouch, - Skill::TestStun => Var::TestStun, - Skill::TestBlock => Var::TestBlock, - Skill::TestParry => Var::TestParry, - Skill::TestSiphon => Var::TestSiphon, - _ => panic!("{:?} not implemented as a var", skill), + Skill::TestTouch => Item::TestTouch, + Skill::TestStun => Item::TestStun, + Skill::TestBlock => Item::TestBlock, + Skill::TestParry => Item::TestParry, + Skill::TestSiphon => Item::TestSiphon, + _ => panic!("{:?} not implemented as a item", skill), } } } -impl From for Var { - fn from(spec: Spec) -> Var { +impl From for Item { + fn from(spec: Spec) -> Item { match spec { - Spec::Speed => Var::Speed, - Spec::RedSpeedI => Var::RedSpeedI, - Spec::BlueSpeedI => Var::BlueSpeedI, - Spec::GreenSpeedI => Var::GreenSpeedI, - Spec::GRSpeedI => Var::GRSpeedI, - Spec::GBSpeedI => Var::GBSpeedI, - Spec::RBSpeedI => Var::RBSpeedI, + Spec::Speed => Item::Speed, + Spec::RedSpeedI => Item::RedSpeedI, + Spec::BlueSpeedI => Item::BlueSpeedI, + Spec::GreenSpeedI => Item::GreenSpeedI, + Spec::GRSpeedI => Item::GRSpeedI, + Spec::GBSpeedI => Item::GBSpeedI, + Spec::RBSpeedI => Item::RBSpeedI, - Spec::Damage => Var::Damage, - Spec::RedDamageI => Var::RedDamageI, - Spec::BlueDamageI => Var::BlueDamageI, - Spec::GreenDamageI => Var::GreenDamageI, - Spec::GRDI => Var::GRDI, - Spec::GBDI => Var::GBDI, - Spec::RBDI => Var::RBDI, + Spec::Damage => Item::Damage, + Spec::RedDamageI => Item::RedDamageI, + Spec::BlueDamageI => Item::BlueDamageI, + Spec::GreenDamageI => Item::GreenDamageI, + Spec::GRDI => Item::GRDI, + Spec::GBDI => Item::GBDI, + Spec::RBDI => Item::RBDI, - Spec::Life => Var::Life, - Spec::GRLI => Var::GRLI, - Spec::GBLI => Var::GBLI, - Spec::RBLI => Var::RBLI, - Spec::GreenLifeI => Var::GreenLifeI, - Spec::RedLifeI => Var::RedLifeI, - Spec::BlueLifeI => Var::BlueLifeI, - // _ => panic!("{:?} not implemented as a var", spec), + Spec::Life => Item::Life, + Spec::GRLI => Item::GRLI, + Spec::GBLI => Item::GBLI, + Spec::RBLI => Item::RBLI, + Spec::GreenLifeI => Item::GreenLifeI, + Spec::RedLifeI => Item::RedLifeI, + Spec::BlueLifeI => Item::BlueLifeI, + // _ => panic!("{:?} not implemented as a item", spec), } } } @@ -345,70 +345,70 @@ impl From for Var { #[derive(Debug,Clone,Serialize,Deserialize)] pub struct Combo { - var: Var, - units: Vec, + item: Item, + units: Vec, } fn get_combos() -> Vec { let mut combinations = vec![ - Combo { units: vec![Var::Buff, Var::Red, Var::Red], var: Var::Taunt }, - Combo { units: vec![Var::Buff, Var::Green, Var::Green], var: Var::Triage }, - Combo { units: vec![Var::Buff, Var::Blue, Var::Blue], var: Var::Scatter }, //To be impl - Combo { units: vec![Var::Buff, Var::Red, Var::Green], var: Var::Haste }, - Combo { units: vec![Var::Buff, Var::Green, Var::Blue], var: Var::Impurity }, - Combo { units: vec![Var::Buff, Var::Red, Var::Blue], var: Var::Amplify }, // Some flavour + Combo { units: vec![Item::Buff, Item::Red, Item::Red], item: Item::Taunt }, + Combo { units: vec![Item::Buff, Item::Green, Item::Green], item: Item::Triage }, + Combo { units: vec![Item::Buff, Item::Blue, Item::Blue], item: Item::Scatter }, //To be impl + Combo { units: vec![Item::Buff, Item::Red, Item::Green], item: Item::Haste }, + Combo { units: vec![Item::Buff, Item::Green, Item::Blue], item: Item::Impurity }, + Combo { units: vec![Item::Buff, Item::Red, Item::Blue], item: Item::Amplify }, // Some flavour - Combo { units: vec![Var::Debuff, Var::Red, Var::Red], var: Var::Snare }, - Combo { units: vec![Var::Debuff, Var::Green, Var::Green], var: Var::Purge }, // Needs flavour - Combo { units: vec![Var::Debuff, Var::Blue, Var::Blue], var: Var::Silence }, - Combo { units: vec![Var::Debuff, Var::Red, Var::Green], var: Var::Curse }, // To be reworked - Combo { units: vec![Var::Debuff, Var::Green, Var::Blue], var: Var::Decay }, - Combo { units: vec![Var::Debuff, Var::Red, Var::Blue], var: Var::Invert }, + Combo { units: vec![Item::Debuff, Item::Red, Item::Red], item: Item::Snare }, + Combo { units: vec![Item::Debuff, Item::Green, Item::Green], item: Item::Purge }, // Needs flavour + Combo { units: vec![Item::Debuff, Item::Blue, Item::Blue], item: Item::Silence }, + Combo { units: vec![Item::Debuff, Item::Red, Item::Green], item: Item::Curse }, // To be reworked + Combo { units: vec![Item::Debuff, Item::Green, Item::Blue], item: Item::Decay }, + Combo { units: vec![Item::Debuff, Item::Red, Item::Blue], item: Item::Invert }, - Combo { units: vec![Var::Block, Var::Red, Var::Red], var: Var::Parry }, // Add red recharge - Combo { units: vec![Var::Block, Var::Green, Var::Green], var: Var::Purify }, - Combo { units: vec![Var::Block, Var::Blue, Var::Blue], var: Var::Corrupt }, - Combo { units: vec![Var::Block, Var::Red, Var::Green], var: Var::Clutch }, - Combo { units: vec![Var::Block, Var::Green, Var::Blue], var: Var::Reflect }, - Combo { units: vec![Var::Block, Var::Red, Var::Blue], var: Var::Recharge }, + Combo { units: vec![Item::Block, Item::Red, Item::Red], item: Item::Parry }, // Add red recharge + Combo { units: vec![Item::Block, Item::Green, Item::Green], item: Item::Purify }, + Combo { units: vec![Item::Block, Item::Blue, Item::Blue], item: Item::Corrupt }, + Combo { units: vec![Item::Block, Item::Red, Item::Green], item: Item::Clutch }, + Combo { units: vec![Item::Block, Item::Green, Item::Blue], item: Item::Reflect }, + Combo { units: vec![Item::Block, Item::Red, Item::Blue], item: Item::Recharge }, - Combo { units: vec![Var::Stun, Var::Red, Var::Red], var: Var::Strangle }, - Combo { units: vec![Var::Stun, Var::Green, Var::Green], var: Var::Sleep }, - Combo { units: vec![Var::Stun, Var::Blue, Var::Blue], var: Var::Ruin }, - Combo { units: vec![Var::Stun, Var::Red, Var::Green], var: Var::Throw }, - Combo { units: vec![Var::Stun, Var::Green, Var::Blue], var: Var::Hex }, - Combo { units: vec![Var::Stun, Var::Red, Var::Blue], var: Var::Banish }, + Combo { units: vec![Item::Stun, Item::Red, Item::Red], item: Item::Strangle }, + Combo { units: vec![Item::Stun, Item::Green, Item::Green], item: Item::Sleep }, + Combo { units: vec![Item::Stun, Item::Blue, Item::Blue], item: Item::Ruin }, + Combo { units: vec![Item::Stun, Item::Red, Item::Green], item: Item::Throw }, + Combo { units: vec![Item::Stun, Item::Green, Item::Blue], item: Item::Hex }, + Combo { units: vec![Item::Stun, Item::Red, Item::Blue], item: Item::Banish }, - Combo { units: vec![Var::Attack, Var::Red, Var::Red], var: Var::Strike }, - Combo { units: vec![Var::Strike, Var::Strike, Var::Strike], var: Var::StrikeII }, - Combo { units: vec![Var::StrikeII, Var::StrikeII, Var::StrikeII], var: Var::StrikeIII }, + Combo { units: vec![Item::Attack, Item::Red, Item::Red], item: Item::Strike }, + Combo { units: vec![Item::Strike, Item::Strike, Item::Strike], item: Item::StrikeII }, + Combo { units: vec![Item::StrikeII, Item::StrikeII, Item::StrikeII], item: Item::StrikeIII }, - Combo { units: vec![Var::Attack, Var::Green, Var::Green], var: Var::Heal }, - Combo { units: vec![Var::Attack, Var::Blue, Var::Blue], var: Var::Blast }, - Combo { units: vec![Var::Attack, Var::Red, Var::Green], var: Var::Slay }, - Combo { units: vec![Var::Attack, Var::Green, Var::Blue], var: Var::Siphon }, - Combo { units: vec![Var::Attack, Var::Red, Var::Blue], var: Var::Chaos }, + Combo { units: vec![Item::Attack, Item::Green, Item::Green], item: Item::Heal }, + Combo { units: vec![Item::Attack, Item::Blue, Item::Blue], item: Item::Blast }, + Combo { units: vec![Item::Attack, Item::Red, Item::Green], item: Item::Slay }, + Combo { units: vec![Item::Attack, Item::Green, Item::Blue], item: Item::Siphon }, + Combo { units: vec![Item::Attack, Item::Red, Item::Blue], item: Item::Chaos }, - Combo { units: vec![Var::Damage, Var::Red, Var::Red], var: Var::RedDamageI }, - Combo { units: vec![Var::Damage, Var::Green, Var::Green], var: Var::GreenDamageI }, - Combo { units: vec![Var::Damage, Var::Blue, Var::Blue], var: Var::BlueDamageI }, - Combo { units: vec![Var::Damage, Var::Red, Var::Green], var: Var::GRDI }, - Combo { units: vec![Var::Damage, Var::Green, Var::Blue], var: Var::GBDI }, - Combo { units: vec![Var::Damage, Var::Red, Var::Blue], var: Var::RBDI }, + Combo { units: vec![Item::Damage, Item::Red, Item::Red], item: Item::RedDamageI }, + Combo { units: vec![Item::Damage, Item::Green, Item::Green], item: Item::GreenDamageI }, + Combo { units: vec![Item::Damage, Item::Blue, Item::Blue], item: Item::BlueDamageI }, + Combo { units: vec![Item::Damage, Item::Red, Item::Green], item: Item::GRDI }, + Combo { units: vec![Item::Damage, Item::Green, Item::Blue], item: Item::GBDI }, + Combo { units: vec![Item::Damage, Item::Red, Item::Blue], item: Item::RBDI }, - Combo { units: vec![Var::Life, Var::Red, Var::Red], var: Var::RedLifeI }, - Combo { units: vec![Var::Life, Var::Green, Var::Green], var: Var::GreenLifeI }, - Combo { units: vec![Var::Life, Var::Blue, Var::Blue], var: Var::BlueLifeI }, - Combo { units: vec![Var::Life, Var::Red, Var::Green], var: Var::GRLI }, - Combo { units: vec![Var::Life, Var::Green, Var::Blue], var: Var::GBLI }, - Combo { units: vec![Var::Life, Var::Red, Var::Blue], var: Var::RBLI }, + Combo { units: vec![Item::Life, Item::Red, Item::Red], item: Item::RedLifeI }, + Combo { units: vec![Item::Life, Item::Green, Item::Green], item: Item::GreenLifeI }, + Combo { units: vec![Item::Life, Item::Blue, Item::Blue], item: Item::BlueLifeI }, + Combo { units: vec![Item::Life, Item::Red, Item::Green], item: Item::GRLI }, + Combo { units: vec![Item::Life, Item::Green, Item::Blue], item: Item::GBLI }, + Combo { units: vec![Item::Life, Item::Red, Item::Blue], item: Item::RBLI }, - Combo { units: vec![Var::Speed, Var::Red, Var::Red], var: Var::RedSpeedI }, - Combo { units: vec![Var::Speed, Var::Green, Var::Green], var: Var::GreenSpeedI }, - Combo { units: vec![Var::Speed, Var::Blue, Var::Blue], var: Var::BlueSpeedI }, - Combo { units: vec![Var::Speed, Var::Red, Var::Green], var: Var::GRSpeedI }, - Combo { units: vec![Var::Speed, Var::Green, Var::Blue], var: Var::GBSpeedI }, - Combo { units: vec![Var::Speed, Var::Red, Var::Blue], var: Var::RBSpeedI }, + Combo { units: vec![Item::Speed, Item::Red, Item::Red], item: Item::RedSpeedI }, + Combo { units: vec![Item::Speed, Item::Green, Item::Green], item: Item::GreenSpeedI }, + Combo { units: vec![Item::Speed, Item::Blue, Item::Blue], item: Item::BlueSpeedI }, + Combo { units: vec![Item::Speed, Item::Red, Item::Green], item: Item::GRSpeedI }, + Combo { units: vec![Item::Speed, Item::Green, Item::Blue], item: Item::GBSpeedI }, + Combo { units: vec![Item::Speed, Item::Red, Item::Blue], item: Item::RBSpeedI }, ]; @@ -418,8 +418,8 @@ fn get_combos() -> Vec { } #[derive(Debug,Clone,Serialize,Deserialize)] -pub struct VarInfo { - pub v: Var, +pub struct ItemInfo { + pub v: Item, pub spec: bool, pub skill: bool, } @@ -428,52 +428,52 @@ pub struct VarInfo { #[derive(Debug,Clone,Serialize,Deserialize)] pub struct VboxInfo { pub combos: Vec, - pub vars: Vec, + pub items: Vec, } pub fn vbox_info() -> VboxInfo { let combos = get_combos(); - let mut vars = combos + let mut items = combos .into_iter() .flat_map(|mut c| { - c.units.push(c.var); + c.units.push(c.item); c.units }) - .collect::>(); + .collect::>(); - vars.sort_unstable(); - vars.dedup(); + items.sort_unstable(); + items.dedup(); - let vars = vars + let items = items .into_iter() - .map(|v| VarInfo { + .map(|v| ItemInfo { v, spec: v.into_spec().is_some(), skill: v.into_skill().is_some(), }) - .collect::>(); + .collect::>(); let combos = get_combos(); return VboxInfo { combos, - vars, + items, }; } #[derive(Debug,Clone,Serialize,Deserialize)] pub struct Vbox { pub bits: u16, - pub free: Vec>, - pub bound: Vec, + pub free: Vec>, + pub bound: Vec, } impl Vbox { pub fn new() -> Vbox { let starting_items = vec![ - Var::Attack, - Var::Attack, - Var::Attack, + Item::Attack, + Item::Attack, + Item::Attack, ]; Vbox { @@ -500,51 +500,51 @@ impl Vbox { pub fn fill(&mut self) -> &mut Vbox { let colours = vec![ - (Var::Red, 1), - (Var::Green, 1), - (Var::Blue, 1), + (Item::Red, 1), + (Item::Green, 1), + (Item::Blue, 1), ]; let skills = vec![ - (Var::Attack, 1), - (Var::Block, 1), - (Var::Buff, 1), - (Var::Debuff, 1), - (Var::Stun, 1), + (Item::Attack, 1), + (Item::Block, 1), + (Item::Buff, 1), + (Item::Debuff, 1), + (Item::Stun, 1), ]; let specs = vec![ - (Var::Damage, 1), - (Var::Life, 1), - (Var::Speed, 1), + (Item::Damage, 1), + (Item::Life, 1), + (Item::Speed, 1), ]; let mut rng = thread_rng(); self.free = [&colours, &skills, &specs].iter() - .map(|vars| { - let dist = WeightedIndex::new(vars.iter().map(|item| item.1)).unwrap(); + .map(|items| { + let dist = WeightedIndex::new(items.iter().map(|item| item.1)).unwrap(); iter::repeat_with(|| { - vars[dist.sample(&mut rng)].0 + items[dist.sample(&mut rng)].0 }) .take(6) - .collect::>() + .collect::>() }) - .collect::>>(); + .collect::>>(); self } pub fn accept(&mut self, i: usize, j: usize) -> Result<&mut Vbox, Error> { if self.bound.len() >= 9 { - return Err(err_msg("too many vars bound")); + return Err(err_msg("too many items bound")); } // check item exists self.free - .get(i).ok_or(format_err!("no var group at index {:?}", i))? - .get(j).ok_or(format_err!("no var at index {:?}", j))?; + .get(i).ok_or(format_err!("no item group at index {:?}", i))? + .get(j).ok_or(format_err!("no item at index {:?}", j))?; // check can purchase let cost = self.free[i][j].cost(); @@ -558,7 +558,7 @@ impl Vbox { } pub fn reclaim(&mut self, i: usize) -> Result<&mut Vbox, Error> { - self.bound.get(i).ok_or(format_err!("no var at index {:?}", i))?; + self.bound.get(i).ok_or(format_err!("no item at index {:?}", i))?; let reclaimed = self.bound.remove(i); let refund = reclaimed.cost(); // info!("reclaiming {:?} for {:?}", refund, reclaimed); @@ -572,7 +572,7 @@ impl Vbox { } if !indices.iter().all(|i| self.bound.get(*i).is_some()) { - return Err(err_msg("var missing index")); + return Err(err_msg("item missing index")); } // have to sort the indices and keep track of the iteration @@ -584,7 +584,7 @@ impl Vbox { .map(|(i, index)| { self.bound.remove(index.saturating_sub(i)) }) - .collect::>(); + .collect::>(); // sort the input to align with the combinations // combos are sorted when created @@ -592,7 +592,7 @@ impl Vbox { let combos = get_combos(); let combo = combos.iter().find(|c| c.units == input).ok_or(err_msg("not a combo"))?; - self.bound.push(combo.var); + self.bound.push(combo.item); self.bound.sort_unstable(); Ok(self) @@ -642,14 +642,14 @@ mod tests { #[test] fn combine_test() { let mut vbox = Vbox::new(); - vbox.bound = vec![Var::Attack, Var::Green, Var::Green]; + vbox.bound = vec![Item::Attack, Item::Green, Item::Green]; vbox.combine(vec![1,2,0]).unwrap(); - assert_eq!(vbox.bound[0], Var::Heal); + assert_eq!(vbox.bound[0], Item::Heal); } #[test] fn combos_test() { - let mut input = vec![Var::Green, Var::Attack, Var::Green]; + let mut input = vec![Item::Green, Item::Attack, Item::Green]; let combos = get_combos(); // sort input so they align @@ -662,14 +662,14 @@ mod tests { #[test] fn reclaim_test() { let mut vbox = Vbox::new(); - vbox.bound = vec![Var::Strike]; + vbox.bound = vec![Item::Strike]; vbox.reclaim(0).unwrap(); assert_eq!(vbox.bits, 22); } #[test] fn colours_count_test() { - let strike = Var::Strike; + let strike = Item::Strike; let mut count = Colours::new(); strike.colours(&mut count);