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

server var -> item

Browse Source
This commit is contained in:
ntr 2019-05-20 12:29:14 +10:00
parent e3a9ba6109
commit ad702c8901
7 changed files with 294 additions and 294 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
client/src/constants.jsx
View File

@ -1,9 +1,9 @@
module.exports = { module.exports = {
TIMES: { TIMES: {
RESOLUTION_TIME_MS: 2000, RESOLUTION_TIME_MS: 1000,
START_SKILL: 1000, START_SKILL: 500,
END_SKILL: 1000, END_SKILL: 500,
POST_SKILL: 1000, POST_SKILL: 500,
}, },
ITEMS: { ITEMS: {

6
server/src/cryp.rs
View File

@ -11,7 +11,7 @@ use account::{Account};
use rpc::{CrypSpawnParams}; use rpc::{CrypSpawnParams};
use skill::{Skill, Cooldown, Effect, Cast, Category, Immunity, Disable, Event}; use skill::{Skill, Cooldown, Effect, Cast, Category, Immunity, Disable, Event};
use spec::{Spec}; use spec::{Spec};
use vbox::Var; use vbox::Item;
#[derive(Debug,Clone,Serialize,Deserialize)] #[derive(Debug,Clone,Serialize,Deserialize)]
pub struct Colours { pub struct Colours {
@ -29,12 +29,12 @@ impl Colours {
let mut count = Colours::new(); let mut count = Colours::new();
for spec in cryp.specs.iter() { for spec in cryp.specs.iter() {
let v = Var::from(*spec); let v = Item::from(*spec);
v.colours(&mut count); v.colours(&mut count);
} }
for cs in cryp.skills.iter() { for cs in cryp.skills.iter() {
let v = Var::from(cs.skill); let v = Item::from(cs.skill);
v.colours(&mut count); v.colours(&mut count);
} }

4
server/src/instance.rs
View File

@ -19,7 +19,7 @@ use player::{Player, player_create, player_get, player_global_update};
use cryp::{Cryp, cryp_get}; use cryp::{Cryp, cryp_get};
use mob::{instance_mobs}; use mob::{instance_mobs};
use game::{Game, Phase, game_get, game_write, game_instance_new}; use game::{Game, Phase, game_get, game_write, game_instance_new};
use vbox::{Var}; use vbox::{Item};
use rpc::{RpcResult}; use rpc::{RpcResult};
use names::{name}; use names::{name};
@ -479,7 +479,7 @@ impl Instance {
Ok(self) Ok(self)
} }
pub fn vbox_unequip(mut self, account: Uuid, target: Var, cryp_id: Uuid) -> Result<Instance, Error> { pub fn vbox_unequip(mut self, account: Uuid, target: Item, cryp_id: Uuid) -> Result<Instance, Error> {
self.vbox_action_allowed(account)?; self.vbox_action_allowed(account)?;
self.account_player(account)? self.account_player(account)?
.vbox_unequip(target, cryp_id)?; .vbox_unequip(target, cryp_id)?;

42
server/src/player.rs
View File

@ -10,7 +10,7 @@ use failure::err_msg;
use account::Account; use account::Account;
use cryp::{Cryp, Colours, cryp_get}; use cryp::{Cryp, Colours, cryp_get};
use vbox::{Vbox, Var, VarEffect}; use vbox::{Vbox, Item, ItemEffect};
use rpc::{PlayerCrypsSetParams}; use rpc::{PlayerCrypsSetParams};
use instance::{Instance, instance_get, instance_update}; use instance::{Instance, instance_get, instance_update};
use skill::{Effect}; use skill::{Effect};
@ -130,7 +130,7 @@ impl Player {
let num_colours = self.vbox.bound let num_colours = self.vbox.bound
.iter() .iter()
.filter(|v| [Var::Red, Var::Green, Var::Blue].contains(v)) .filter(|v| [Item::Red, Item::Green, Item::Blue].contains(v))
.count(); .count();
if self.vbox.bound.len() < 3 || num_colours < 2 { if self.vbox.bound.len() < 3 || num_colours < 2 {
@ -150,7 +150,7 @@ impl Player {
// info!("{:?}", self.vbox.bound); // 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 { let combo_i = match group_i {
1 => self.vbox.bound.iter().position(|v| skills.contains(v)).expect("no skill found"), 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"), 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 // first 2 colours can be whatever
self.vbox_combine(vec![0, 1, combo_i]).ok(); self.vbox_combine(vec![0, 1, combo_i]).ok();
let var_i = self.vbox.bound.len() - 1; let item_i = self.vbox.bound.len() - 1;
self.vbox_apply(var_i, target_cryp_id).ok(); self.vbox_apply(item_i, target_cryp_id).ok();
} }
return self; return self;
@ -188,11 +188,11 @@ impl Player {
} }
pub fn vbox_apply(&mut self, index: usize, cryp_id: Uuid) -> Result<&mut Player, Error> { 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() { match item.effect() {
Some(VarEffect::Skill) => { Some(ItemEffect::Skill) => {
let skill = var.into_skill().ok_or(format_err!("var {:?} has no associated skill", var))?; let skill = item.into_skill().ok_or(format_err!("item {:?} has no associated skill", item))?;
let cryp = self.cryp_get(cryp_id)?; let cryp = self.cryp_get(cryp_id)?;
// done here because i teach them a tonne of skills for tests // done here because i teach them a tonne of skills for tests
let max_skills = 3; let max_skills = 3;
@ -206,16 +206,16 @@ impl Player {
cryp.learn_mut(skill); cryp.learn_mut(skill);
}, },
Some(VarEffect::Spec) => { Some(ItemEffect::Spec) => {
let spec = var.into_spec().ok_or(format_err!("var {:?} has no associated spec", var))?; let spec = item.into_spec().ok_or(format_err!("item {:?} has no associated spec", item))?;
let cryp = self.cryp_get(cryp_id)?; let cryp = self.cryp_get(cryp_id)?;
cryp.spec_add(spec)?; 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 // recalculate the stats of the whole player
let player_colours = self.cryps.iter().fold(Colours::new(), |tc, c| { let player_colours = self.cryps.iter().fold(Colours::new(), |tc, c| {
Colours { Colours {
@ -232,26 +232,26 @@ impl Player {
Ok(self) 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 { 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() { match target.effect() {
Some(VarEffect::Skill) => { Some(ItemEffect::Skill) => {
let skill = target.into_skill().ok_or(format_err!("var {:?} has no associated skill", target))?; let skill = target.into_skill().ok_or(format_err!("item {:?} has no associated skill", target))?;
let cryp = self.cryp_get(cryp_id)?; let cryp = self.cryp_get(cryp_id)?;
cryp.forget(skill)?; cryp.forget(skill)?;
}, },
Some(VarEffect::Spec) => { Some(ItemEffect::Spec) => {
let spec = target.into_spec().ok_or(format_err!("var {:?} has no associated spec", target))?; let spec = target.into_spec().ok_or(format_err!("item {:?} has no associated spec", target))?;
let cryp = self.cryp_get(cryp_id)?; let cryp = self.cryp_get(cryp_id)?;
cryp.spec_remove(spec)?; 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 // recalculate the stats of the whole player
let player_colours = self.cryps.iter().fold(Colours::new(), |tc, c| { let player_colours = self.cryps.iter().fold(Colours::new(), |tc, c| {
Colours { Colours {

4
server/src/rpc.rs
View File

@ -23,7 +23,7 @@ use skill::{Skill};
use spec::{Spec}; use spec::{Spec};
use player::{Score, player_mm_cryps_set}; use player::{Score, player_mm_cryps_set};
use instance::{Instance, instance_state, instance_new, instance_ready, instance_join}; 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; pub struct Rpc;
@ -653,7 +653,7 @@ struct VboxUnequipMsg {
pub struct VboxUnequipParams { pub struct VboxUnequipParams {
pub instance_id: Uuid, pub instance_id: Uuid,
pub cryp_id: Uuid, pub cryp_id: Uuid,
pub target: Var, pub target: Item,
} }
#[derive(Debug,Clone,Serialize,Deserialize)] #[derive(Debug,Clone,Serialize,Deserialize)]

14
server/src/skill.rs
View File

@ -3,7 +3,7 @@ use uuid::Uuid;
use util::{IntPct}; use util::{IntPct};
use cryp::{Cryp, CrypEffect, EffectMeta, Stat}; use cryp::{Cryp, CrypEffect, EffectMeta, Stat};
use vbox::{Var}; use vbox::{Item};
use game::{Game}; use game::{Game};
@ -905,13 +905,13 @@ impl Skill {
Skill::StrikeII => Skill::Strike.speed(), Skill::StrikeII => Skill::Strike.speed(),
Skill::StrikeIII => Skill::Strike.speed(), Skill::StrikeIII => Skill::Strike.speed(),
Skill::SiphonTick => Var::from(Skill::Siphon).speed(), Skill::SiphonTick => Item::from(Skill::Siphon).speed(),
Skill::DecayTick => Var::from(Skill::Decay).speed(), Skill::DecayTick => Item::from(Skill::Decay).speed(),
Skill::TriageTick => Var::from(Skill::Triage).speed(), Skill::TriageTick => Item::from(Skill::Triage).speed(),
Skill::StrangleTick => Var::from(Skill::Strangle).speed(), Skill::StrangleTick => Item::from(Skill::Strangle).speed(),
Skill::CorruptionTick => Var::from(Skill::Corrupt).speed(), Skill::CorruptionTick => Item::from(Skill::Corrupt).speed(),
_ => Var::from(*self).speed(), _ => Item::from(*self).speed(),
} }
} }

510
server/src/vbox.rs
View File

@ -19,7 +19,7 @@ use instance::{Instance, instance_get, instance_update};
use cryp::{Colours}; use cryp::{Colours};
#[derive(Debug,Copy,Clone,Serialize,Deserialize,PartialEq,PartialOrd,Ord,Eq)] #[derive(Debug,Copy,Clone,Serialize,Deserialize,PartialEq,PartialOrd,Ord,Eq)]
pub enum Var { pub enum Item {
// colours // colours
Blue, Blue,
Green, Green,
@ -104,20 +104,20 @@ pub enum Var {
TestSiphon, TestSiphon,
} }
pub enum VarEffect { pub enum ItemEffect {
Skill, Skill,
Spec, Spec,
} }
impl Var { impl Item {
pub fn colours(&self, count: &mut Colours) { pub fn colours(&self, count: &mut Colours) {
let combos = get_combos(); let combos = get_combos();
let combo = combos.iter().find(|c| c.var == *self); let combo = combos.iter().find(|c| c.item == *self);
match combo { match combo {
Some(c) => c.units.iter().for_each(|unit| match unit { Some(c) => c.units.iter().for_each(|unit| match unit {
Var::Red => count.red += 1, Item::Red => count.red += 1,
Var::Blue => count.blue += 1, Item::Blue => count.blue += 1,
Var::Green => count.green += 1, Item::Green => count.green += 1,
_ => { _ => {
let mut combo_count = Colours::new(); let mut combo_count = Colours::new();
unit.colours(&mut combo_count); unit.colours(&mut combo_count);
@ -132,23 +132,23 @@ impl Var {
fn cost(&self) -> u16 { fn cost(&self) -> u16 {
match self { match self {
Var::Red => 1, Item::Red => 1,
Var::Green => 1, Item::Green => 1,
Var::Blue => 1, Item::Blue => 1,
Var::Attack => 2, Item::Attack => 2,
Var::Block => 2, Item::Block => 2,
Var::Buff => 2, Item::Buff => 2,
Var::Debuff => 2, Item::Debuff => 2,
Var::Stun => 2, Item::Stun => 2,
Var::Damage => 3, Item::Damage => 3,
Var::Life => 3, Item::Life => 3,
Var::Speed => 3, Item::Speed => 3,
_ => { _ => {
let combos = get_combos(); 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)); .unwrap_or_else(|| panic!("unable to find components for {:?}", self));
return combo.units.iter().fold(0, |acc, c| acc + c.cost()); return combo.units.iter().fold(0, |acc, c| acc + c.cost());
}, },
@ -157,187 +157,187 @@ impl Var {
pub fn speed(&self) -> u8 { pub fn speed(&self) -> u8 {
match self { match self {
Var::Red => 3, Item::Red => 3,
Var::Green => 2, Item::Green => 2,
Var::Blue => 1, Item::Blue => 1,
Var::Attack => 1, Item::Attack => 1,
Var::Stun => 2, Item::Stun => 2,
Var::Block => 3, Item::Block => 3,
Var::Buff => 4, Item::Buff => 4,
Var::Debuff => 4, Item::Debuff => 4,
_ => { _ => {
let combos = get_combos(); 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)); .unwrap_or_else(|| panic!("unable to find components for {:?}", self));
return combo.units.iter().fold(0, |acc, c| acc + c.speed()); return combo.units.iter().fold(0, |acc, c| acc + c.speed());
}, },
} }
} }
pub fn effect(&self) -> Option<VarEffect> { pub fn effect(&self) -> Option<ItemEffect> {
if let Some(_skill) = self.into_skill() { if let Some(_skill) = self.into_skill() {
return Some(VarEffect::Skill); return Some(ItemEffect::Skill);
} }
if let Some(_spec) = self.into_spec() { if let Some(_spec) = self.into_spec() {
return Some(VarEffect::Spec); return Some(ItemEffect::Spec);
} }
return None; return None;
} }
pub fn into_skill(&self) -> Option<Skill> { pub fn into_skill(&self) -> Option<Skill> {
match self { match self {
Var::Attack => Some(Skill::Attack), Item::Attack => Some(Skill::Attack),
Var::Amplify => Some(Skill::Amplify), Item::Amplify => Some(Skill::Amplify),
Var::Banish => Some(Skill::Banish), Item::Banish => Some(Skill::Banish),
Var::Blast => Some(Skill::Blast), Item::Blast => Some(Skill::Blast),
Var::Block => Some(Skill::Block), Item::Block => Some(Skill::Block),
Var::Chaos => Some(Skill::Chaos), Item::Chaos => Some(Skill::Chaos),
Var::Curse => Some(Skill::Curse), Item::Curse => Some(Skill::Curse),
Var::Debuff => Some(Skill::Debuff), Item::Debuff => Some(Skill::Debuff),
Var::Decay => Some(Skill::Decay), Item::Decay => Some(Skill::Decay),
Var::Haste => Some(Skill::Haste), Item::Haste => Some(Skill::Haste),
Var::Heal => Some(Skill::Heal), Item::Heal => Some(Skill::Heal),
Var::Hex => Some(Skill::Hex), Item::Hex => Some(Skill::Hex),
Var::Hostility => Some(Skill::Hostility), Item::Hostility => Some(Skill::Hostility),
Var::Impurity => Some(Skill::Impurity), Item::Impurity => Some(Skill::Impurity),
Var::Invert => Some(Skill::Invert), Item::Invert => Some(Skill::Invert),
Var::Parry => Some(Skill::Parry), Item::Parry => Some(Skill::Parry),
Var::Purge => Some(Skill::Purge), Item::Purge => Some(Skill::Purge),
Var::Purify => Some(Skill::Purify), Item::Purify => Some(Skill::Purify),
Var::Recharge => Some(Skill::Recharge), Item::Recharge => Some(Skill::Recharge),
Var::Reflect => Some(Skill::Reflect), Item::Reflect => Some(Skill::Reflect),
Var::Ruin => Some(Skill::Ruin), Item::Ruin => Some(Skill::Ruin),
Var::Scatter => Some(Skill::Scatter), Item::Scatter => Some(Skill::Scatter),
Var::Silence => Some(Skill::Silence), Item::Silence => Some(Skill::Silence),
Var::Slay => Some(Skill::Slay), Item::Slay => Some(Skill::Slay),
Var::Sleep => Some(Skill::Sleep), Item::Sleep => Some(Skill::Sleep),
Var::Siphon => Some(Skill::Siphon), Item::Siphon => Some(Skill::Siphon),
Var::Snare => Some(Skill::Snare), Item::Snare => Some(Skill::Snare),
Var::Strangle => Some(Skill::Strangle), Item::Strangle => Some(Skill::Strangle),
Var::Stun => Some(Skill::Stun), Item::Stun => Some(Skill::Stun),
Var::Strike => Some(Skill::Strike), Item::Strike => Some(Skill::Strike),
Var::StrikeII => Some(Skill::StrikeII), Item::StrikeII => Some(Skill::StrikeII),
Var::StrikeIII => Some(Skill::StrikeIII), Item::StrikeIII => Some(Skill::StrikeIII),
Var::Clutch => Some(Skill::Clutch), Item::Clutch => Some(Skill::Clutch),
Var::Taunt => Some(Skill::Taunt), Item::Taunt => Some(Skill::Taunt),
Var::Throw => Some(Skill::Throw), Item::Throw => Some(Skill::Throw),
Var::Corrupt => Some(Skill::Corrupt), Item::Corrupt => Some(Skill::Corrupt),
Var::Triage => Some(Skill::Triage), Item::Triage => Some(Skill::Triage),
_ => None, _ => None,
} }
} }
pub fn into_spec(&self) -> Option<Spec> { pub fn into_spec(&self) -> Option<Spec> {
match *self { match *self {
Var::Speed => Some(Spec::Speed), Item::Speed => Some(Spec::Speed),
Var::RedSpeedI => Some(Spec::RedSpeedI), Item::RedSpeedI => Some(Spec::RedSpeedI),
Var::BlueSpeedI => Some(Spec::BlueSpeedI), Item::BlueSpeedI => Some(Spec::BlueSpeedI),
Var::GreenSpeedI => Some(Spec::GreenSpeedI), Item::GreenSpeedI => Some(Spec::GreenSpeedI),
Var::GRSpeedI => Some(Spec::GRSpeedI), Item::GRSpeedI => Some(Spec::GRSpeedI),
Var::GBSpeedI => Some(Spec::GBSpeedI), Item::GBSpeedI => Some(Spec::GBSpeedI),
Var::RBSpeedI => Some(Spec::RBSpeedI), Item::RBSpeedI => Some(Spec::RBSpeedI),
Var::Damage => Some(Spec::Damage), Item::Damage => Some(Spec::Damage),
Var::RedDamageI => Some(Spec::RedDamageI), Item::RedDamageI => Some(Spec::RedDamageI),
Var::BlueDamageI => Some(Spec::BlueDamageI), Item::BlueDamageI => Some(Spec::BlueDamageI),
Var::GreenDamageI => Some(Spec::GreenDamageI), Item::GreenDamageI => Some(Spec::GreenDamageI),
Var::GRDI => Some(Spec::GRDI), Item::GRDI => Some(Spec::GRDI),
Var::GBDI => Some(Spec::GBDI), Item::GBDI => Some(Spec::GBDI),
Var::RBDI => Some(Spec::RBDI), Item::RBDI => Some(Spec::RBDI),
Var::Life => Some(Spec::Life), Item::Life => Some(Spec::Life),
Var::GRLI => Some(Spec::GRLI), Item::GRLI => Some(Spec::GRLI),
Var::GBLI => Some(Spec::GBLI), Item::GBLI => Some(Spec::GBLI),
Var::RBLI => Some(Spec::RBLI), Item::RBLI => Some(Spec::RBLI),
Var::GreenLifeI => Some(Spec::GreenLifeI), Item::GreenLifeI => Some(Spec::GreenLifeI),
Var::RedLifeI => Some(Spec::RedLifeI), Item::RedLifeI => Some(Spec::RedLifeI),
Var::BlueLifeI => Some(Spec::BlueLifeI), Item::BlueLifeI => Some(Spec::BlueLifeI),
_ => None, _ => None,
} }
} }
} }
impl From<Skill> for Var { impl From<Skill> for Item {
fn from(skill: Skill) -> Var { fn from(skill: Skill) -> Item {
match skill { match skill {
Skill::Amplify => Var::Amplify, Skill::Amplify => Item::Amplify,
Skill::Attack => Var::Attack, Skill::Attack => Item::Attack,
Skill::Banish => Var::Banish, Skill::Banish => Item::Banish,
Skill::Blast => Var::Blast, Skill::Blast => Item::Blast,
Skill::Block => Var::Block, Skill::Block => Item::Block,
Skill::Chaos => Var::Chaos, Skill::Chaos => Item::Chaos,
Skill::Curse => Var::Curse, Skill::Curse => Item::Curse,
Skill::Clutch => Var::Clutch, Skill::Clutch => Item::Clutch,
Skill::Decay => Var::Decay, Skill::Decay => Item::Decay,
Skill::Debuff => Var::Debuff, Skill::Debuff => Item::Debuff,
Skill::Haste => Var::Haste, Skill::Haste => Item::Haste,
Skill::Hostility => Var::Hostility, Skill::Hostility => Item::Hostility,
Skill::Heal => Var::Heal, Skill::Heal => Item::Heal,
Skill::Hex => Var::Hex, Skill::Hex => Item::Hex,
Skill::Impurity => Var::Impurity, Skill::Impurity => Item::Impurity,
Skill::Invert => Var::Invert, Skill::Invert => Item::Invert,
Skill::Parry => Var::Parry, Skill::Parry => Item::Parry,
Skill::Purge => Var::Purge, Skill::Purge => Item::Purge,
Skill::Purify => Var::Purify, Skill::Purify => Item::Purify,
Skill::Recharge => Var::Recharge, Skill::Recharge => Item::Recharge,
Skill::Reflect => Var::Reflect, Skill::Reflect => Item::Reflect,
Skill::Ruin => Var::Ruin, Skill::Ruin => Item::Ruin,
Skill::Scatter => Var::Scatter, Skill::Scatter => Item::Scatter,
Skill::Silence => Var::Silence, Skill::Silence => Item::Silence,
Skill::Siphon => Var::Siphon, Skill::Siphon => Item::Siphon,
Skill::Slay => Var::Slay, Skill::Slay => Item::Slay,
Skill::Sleep => Var::Sleep, Skill::Sleep => Item::Sleep,
Skill::Snare => Var::Snare, Skill::Snare => Item::Snare,
Skill::Strangle => Var::Strangle, Skill::Strangle => Item::Strangle,
Skill::Strike => Var::Strike, Skill::Strike => Item::Strike,
Skill::StrikeII => Var::StrikeII, Skill::StrikeII => Item::StrikeII,
Skill::StrikeIII => Var::StrikeIII, Skill::StrikeIII => Item::StrikeIII,
Skill::Stun => Var::Stun, Skill::Stun => Item::Stun,
Skill::Taunt => Var::Taunt, Skill::Taunt => Item::Taunt,
Skill::Throw => Var::Throw, Skill::Throw => Item::Throw,
Skill::Triage => Var::Triage, Skill::Triage => Item::Triage,
Skill::Corrupt => Var::Corrupt, Skill::Corrupt => Item::Corrupt,
Skill::TestTouch => Var::TestTouch, Skill::TestTouch => Item::TestTouch,
Skill::TestStun => Var::TestStun, Skill::TestStun => Item::TestStun,
Skill::TestBlock => Var::TestBlock, Skill::TestBlock => Item::TestBlock,
Skill::TestParry => Var::TestParry, Skill::TestParry => Item::TestParry,
Skill::TestSiphon => Var::TestSiphon, Skill::TestSiphon => Item::TestSiphon,
_ => panic!("{:?} not implemented as a var", skill), _ => panic!("{:?} not implemented as a item", skill),
} }
} }
} }
impl From<Spec> for Var { impl From<Spec> for Item {
fn from(spec: Spec) -> Var { fn from(spec: Spec) -> Item {
match spec { match spec {
Spec::Speed => Var::Speed, Spec::Speed => Item::Speed,
Spec::RedSpeedI => Var::RedSpeedI, Spec::RedSpeedI => Item::RedSpeedI,
Spec::BlueSpeedI => Var::BlueSpeedI, Spec::BlueSpeedI => Item::BlueSpeedI,
Spec::GreenSpeedI => Var::GreenSpeedI, Spec::GreenSpeedI => Item::GreenSpeedI,
Spec::GRSpeedI => Var::GRSpeedI, Spec::GRSpeedI => Item::GRSpeedI,
Spec::GBSpeedI => Var::GBSpeedI, Spec::GBSpeedI => Item::GBSpeedI,
Spec::RBSpeedI => Var::RBSpeedI, Spec::RBSpeedI => Item::RBSpeedI,
Spec::Damage => Var::Damage, Spec::Damage => Item::Damage,
Spec::RedDamageI => Var::RedDamageI, Spec::RedDamageI => Item::RedDamageI,
Spec::BlueDamageI => Var::BlueDamageI, Spec::BlueDamageI => Item::BlueDamageI,
Spec::GreenDamageI => Var::GreenDamageI, Spec::GreenDamageI => Item::GreenDamageI,
Spec::GRDI => Var::GRDI, Spec::GRDI => Item::GRDI,
Spec::GBDI => Var::GBDI, Spec::GBDI => Item::GBDI,
Spec::RBDI => Var::RBDI, Spec::RBDI => Item::RBDI,
Spec::Life => Var::Life, Spec::Life => Item::Life,
Spec::GRLI => Var::GRLI, Spec::GRLI => Item::GRLI,
Spec::GBLI => Var::GBLI, Spec::GBLI => Item::GBLI,
Spec::RBLI => Var::RBLI, Spec::RBLI => Item::RBLI,
Spec::GreenLifeI => Var::GreenLifeI, Spec::GreenLifeI => Item::GreenLifeI,
Spec::RedLifeI => Var::RedLifeI, Spec::RedLifeI => Item::RedLifeI,
Spec::BlueLifeI => Var::BlueLifeI, Spec::BlueLifeI => Item::BlueLifeI,
// _ => panic!("{:?} not implemented as a var", spec), // _ => panic!("{:?} not implemented as a item", spec),
} }
} }
} }
@ -345,70 +345,70 @@ impl From<Spec> for Var {
#[derive(Debug,Clone,Serialize,Deserialize)] #[derive(Debug,Clone,Serialize,Deserialize)]
pub struct Combo { pub struct Combo {
var: Var, item: Item,
units: Vec<Var>, units: Vec<Item>,
} }
fn get_combos() -> Vec<Combo> { fn get_combos() -> Vec<Combo> {
let mut combinations = vec![ let mut combinations = vec![
Combo { units: vec![Var::Buff, Var::Red, Var::Red], var: Var::Taunt }, Combo { units: vec![Item::Buff, Item::Red, Item::Red], item: Item::Taunt },
Combo { units: vec![Var::Buff, Var::Green, Var::Green], var: Var::Triage }, Combo { units: vec![Item::Buff, Item::Green, Item::Green], item: Item::Triage },
Combo { units: vec![Var::Buff, Var::Blue, Var::Blue], var: Var::Scatter }, //To be impl Combo { units: vec![Item::Buff, Item::Blue, Item::Blue], item: Item::Scatter }, //To be impl
Combo { units: vec![Var::Buff, Var::Red, Var::Green], var: Var::Haste }, Combo { units: vec![Item::Buff, Item::Red, Item::Green], item: Item::Haste },
Combo { units: vec![Var::Buff, Var::Green, Var::Blue], var: Var::Impurity }, Combo { units: vec![Item::Buff, Item::Green, Item::Blue], item: Item::Impurity },
Combo { units: vec![Var::Buff, Var::Red, Var::Blue], var: Var::Amplify }, // Some flavour 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![Item::Debuff, Item::Red, Item::Red], item: Item::Snare },
Combo { units: vec![Var::Debuff, Var::Green, Var::Green], var: Var::Purge }, // Needs flavour Combo { units: vec![Item::Debuff, Item::Green, Item::Green], item: Item::Purge }, // Needs flavour
Combo { units: vec![Var::Debuff, Var::Blue, Var::Blue], var: Var::Silence }, Combo { units: vec![Item::Debuff, Item::Blue, Item::Blue], item: Item::Silence },
Combo { units: vec![Var::Debuff, Var::Red, Var::Green], var: Var::Curse }, // To be reworked Combo { units: vec![Item::Debuff, Item::Red, Item::Green], item: Item::Curse }, // To be reworked
Combo { units: vec![Var::Debuff, Var::Green, Var::Blue], var: Var::Decay }, Combo { units: vec![Item::Debuff, Item::Green, Item::Blue], item: Item::Decay },
Combo { units: vec![Var::Debuff, Var::Red, Var::Blue], var: Var::Invert }, 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![Item::Block, Item::Red, Item::Red], item: Item::Parry }, // Add red recharge
Combo { units: vec![Var::Block, Var::Green, Var::Green], var: Var::Purify }, Combo { units: vec![Item::Block, Item::Green, Item::Green], item: Item::Purify },
Combo { units: vec![Var::Block, Var::Blue, Var::Blue], var: Var::Corrupt }, Combo { units: vec![Item::Block, Item::Blue, Item::Blue], item: Item::Corrupt },
Combo { units: vec![Var::Block, Var::Red, Var::Green], var: Var::Clutch }, Combo { units: vec![Item::Block, Item::Red, Item::Green], item: Item::Clutch },
Combo { units: vec![Var::Block, Var::Green, Var::Blue], var: Var::Reflect }, Combo { units: vec![Item::Block, Item::Green, Item::Blue], item: Item::Reflect },
Combo { units: vec![Var::Block, Var::Red, Var::Blue], var: Var::Recharge }, 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![Item::Stun, Item::Red, Item::Red], item: Item::Strangle },
Combo { units: vec![Var::Stun, Var::Green, Var::Green], var: Var::Sleep }, Combo { units: vec![Item::Stun, Item::Green, Item::Green], item: Item::Sleep },
Combo { units: vec![Var::Stun, Var::Blue, Var::Blue], var: Var::Ruin }, Combo { units: vec![Item::Stun, Item::Blue, Item::Blue], item: Item::Ruin },
Combo { units: vec![Var::Stun, Var::Red, Var::Green], var: Var::Throw }, Combo { units: vec![Item::Stun, Item::Red, Item::Green], item: Item::Throw },
Combo { units: vec![Var::Stun, Var::Green, Var::Blue], var: Var::Hex }, Combo { units: vec![Item::Stun, Item::Green, Item::Blue], item: Item::Hex },
Combo { units: vec![Var::Stun, Var::Red, Var::Blue], var: Var::Banish }, 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![Item::Attack, Item::Red, Item::Red], item: Item::Strike },
Combo { units: vec![Var::Strike, Var::Strike, Var::Strike], var: Var::StrikeII }, Combo { units: vec![Item::Strike, Item::Strike, Item::Strike], item: Item::StrikeII },
Combo { units: vec![Var::StrikeII, Var::StrikeII, Var::StrikeII], var: Var::StrikeIII }, 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![Item::Attack, Item::Green, Item::Green], item: Item::Heal },
Combo { units: vec![Var::Attack, Var::Blue, Var::Blue], var: Var::Blast }, Combo { units: vec![Item::Attack, Item::Blue, Item::Blue], item: Item::Blast },
Combo { units: vec![Var::Attack, Var::Red, Var::Green], var: Var::Slay }, Combo { units: vec![Item::Attack, Item::Red, Item::Green], item: Item::Slay },
Combo { units: vec![Var::Attack, Var::Green, Var::Blue], var: Var::Siphon }, Combo { units: vec![Item::Attack, Item::Green, Item::Blue], item: Item::Siphon },
Combo { units: vec![Var::Attack, Var::Red, Var::Blue], var: Var::Chaos }, 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![Item::Damage, Item::Red, Item::Red], item: Item::RedDamageI },
Combo { units: vec![Var::Damage, Var::Green, Var::Green], var: Var::GreenDamageI }, Combo { units: vec![Item::Damage, Item::Green, Item::Green], item: Item::GreenDamageI },
Combo { units: vec![Var::Damage, Var::Blue, Var::Blue], var: Var::BlueDamageI }, Combo { units: vec![Item::Damage, Item::Blue, Item::Blue], item: Item::BlueDamageI },
Combo { units: vec![Var::Damage, Var::Red, Var::Green], var: Var::GRDI }, Combo { units: vec![Item::Damage, Item::Red, Item::Green], item: Item::GRDI },
Combo { units: vec![Var::Damage, Var::Green, Var::Blue], var: Var::GBDI }, Combo { units: vec![Item::Damage, Item::Green, Item::Blue], item: Item::GBDI },
Combo { units: vec![Var::Damage, Var::Red, Var::Blue], var: Var::RBDI }, 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![Item::Life, Item::Red, Item::Red], item: Item::RedLifeI },
Combo { units: vec![Var::Life, Var::Green, Var::Green], var: Var::GreenLifeI }, Combo { units: vec![Item::Life, Item::Green, Item::Green], item: Item::GreenLifeI },
Combo { units: vec![Var::Life, Var::Blue, Var::Blue], var: Var::BlueLifeI }, Combo { units: vec![Item::Life, Item::Blue, Item::Blue], item: Item::BlueLifeI },
Combo { units: vec![Var::Life, Var::Red, Var::Green], var: Var::GRLI }, Combo { units: vec![Item::Life, Item::Red, Item::Green], item: Item::GRLI },
Combo { units: vec![Var::Life, Var::Green, Var::Blue], var: Var::GBLI }, Combo { units: vec![Item::Life, Item::Green, Item::Blue], item: Item::GBLI },
Combo { units: vec![Var::Life, Var::Red, Var::Blue], var: Var::RBLI }, 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![Item::Speed, Item::Red, Item::Red], item: Item::RedSpeedI },
Combo { units: vec![Var::Speed, Var::Green, Var::Green], var: Var::GreenSpeedI }, Combo { units: vec![Item::Speed, Item::Green, Item::Green], item: Item::GreenSpeedI },
Combo { units: vec![Var::Speed, Var::Blue, Var::Blue], var: Var::BlueSpeedI }, Combo { units: vec![Item::Speed, Item::Blue, Item::Blue], item: Item::BlueSpeedI },
Combo { units: vec![Var::Speed, Var::Red, Var::Green], var: Var::GRSpeedI }, Combo { units: vec![Item::Speed, Item::Red, Item::Green], item: Item::GRSpeedI },
Combo { units: vec![Var::Speed, Var::Green, Var::Blue], var: Var::GBSpeedI }, Combo { units: vec![Item::Speed, Item::Green, Item::Blue], item: Item::GBSpeedI },
Combo { units: vec![Var::Speed, Var::Red, Var::Blue], var: Var::RBSpeedI }, Combo { units: vec![Item::Speed, Item::Red, Item::Blue], item: Item::RBSpeedI },
]; ];
@ -418,8 +418,8 @@ fn get_combos() -> Vec<Combo> {
} }
#[derive(Debug,Clone,Serialize,Deserialize)] #[derive(Debug,Clone,Serialize,Deserialize)]
pub struct VarInfo { pub struct ItemInfo {
pub v: Var, pub v: Item,
pub spec: bool, pub spec: bool,
pub skill: bool, pub skill: bool,
} }
@ -428,52 +428,52 @@ pub struct VarInfo {
#[derive(Debug,Clone,Serialize,Deserialize)] #[derive(Debug,Clone,Serialize,Deserialize)]
pub struct VboxInfo { pub struct VboxInfo {
pub combos: Vec<Combo>, pub combos: Vec<Combo>,
pub vars: Vec<VarInfo>, pub items: Vec<ItemInfo>,
} }
pub fn vbox_info() -> VboxInfo { pub fn vbox_info() -> VboxInfo {
let combos = get_combos(); let combos = get_combos();
let mut vars = combos let mut items = combos
.into_iter() .into_iter()
.flat_map(|mut c| { .flat_map(|mut c| {
c.units.push(c.var); c.units.push(c.item);
c.units c.units
}) })
.collect::<Vec<Var>>(); .collect::<Vec<Item>>();
vars.sort_unstable(); items.sort_unstable();
vars.dedup(); items.dedup();
let vars = vars let items = items
.into_iter() .into_iter()
.map(|v| VarInfo { .map(|v| ItemInfo {
v, v,
spec: v.into_spec().is_some(), spec: v.into_spec().is_some(),
skill: v.into_skill().is_some(), skill: v.into_skill().is_some(),
}) })
.collect::<Vec<VarInfo>>(); .collect::<Vec<ItemInfo>>();
let combos = get_combos(); let combos = get_combos();
return VboxInfo { return VboxInfo {
combos, combos,
vars, items,
}; };
} }
#[derive(Debug,Clone,Serialize,Deserialize)] #[derive(Debug,Clone,Serialize,Deserialize)]
pub struct Vbox { pub struct Vbox {
pub bits: u16, pub bits: u16,
pub free: Vec<Vec<Var>>, pub free: Vec<Vec<Item>>,
pub bound: Vec<Var>, pub bound: Vec<Item>,
} }
impl Vbox { impl Vbox {
pub fn new() -> Vbox { pub fn new() -> Vbox {
let starting_items = vec![ let starting_items = vec![
Var::Attack, Item::Attack,
Var::Attack, Item::Attack,
Var::Attack, Item::Attack,
]; ];
Vbox { Vbox {
@ -500,51 +500,51 @@ impl Vbox {
pub fn fill(&mut self) -> &mut Vbox { pub fn fill(&mut self) -> &mut Vbox {
let colours = vec![ let colours = vec![
(Var::Red, 1), (Item::Red, 1),
(Var::Green, 1), (Item::Green, 1),
(Var::Blue, 1), (Item::Blue, 1),
]; ];
let skills = vec![ let skills = vec![
(Var::Attack, 1), (Item::Attack, 1),
(Var::Block, 1), (Item::Block, 1),
(Var::Buff, 1), (Item::Buff, 1),
(Var::Debuff, 1), (Item::Debuff, 1),
(Var::Stun, 1), (Item::Stun, 1),
]; ];
let specs = vec![ let specs = vec![
(Var::Damage, 1), (Item::Damage, 1),
(Var::Life, 1), (Item::Life, 1),
(Var::Speed, 1), (Item::Speed, 1),
]; ];
let mut rng = thread_rng(); let mut rng = thread_rng();
self.free = [&colours, &skills, &specs].iter() self.free = [&colours, &skills, &specs].iter()
.map(|vars| { .map(|items| {
let dist = WeightedIndex::new(vars.iter().map(|item| item.1)).unwrap(); let dist = WeightedIndex::new(items.iter().map(|item| item.1)).unwrap();
iter::repeat_with(|| { iter::repeat_with(|| {
vars[dist.sample(&mut rng)].0 items[dist.sample(&mut rng)].0
}) })
.take(6) .take(6)
.collect::<Vec<Var>>() .collect::<Vec<Item>>()
}) })
.collect::<Vec<Vec<Var>>>(); .collect::<Vec<Vec<Item>>>();
self self
} }
pub fn accept(&mut self, i: usize, j: usize) -> Result<&mut Vbox, Error> { pub fn accept(&mut self, i: usize, j: usize) -> Result<&mut Vbox, Error> {
if self.bound.len() >= 9 { if self.bound.len() >= 9 {
return Err(err_msg("too many vars bound")); return Err(err_msg("too many items bound"));
} }
// check item exists // check item exists
self.free self.free
.get(i).ok_or(format_err!("no var group at index {:?}", i))? .get(i).ok_or(format_err!("no item group at index {:?}", i))?
.get(j).ok_or(format_err!("no var at index {:?}", j))?; .get(j).ok_or(format_err!("no item at index {:?}", j))?;
// check can purchase // check can purchase
let cost = self.free[i][j].cost(); let cost = self.free[i][j].cost();
@ -558,7 +558,7 @@ impl Vbox {
} }
pub fn reclaim(&mut self, i: usize) -> Result<&mut Vbox, Error> { 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 reclaimed = self.bound.remove(i);
let refund = reclaimed.cost(); let refund = reclaimed.cost();
// info!("reclaiming {:?} for {:?}", refund, reclaimed); // info!("reclaiming {:?} for {:?}", refund, reclaimed);
@ -572,7 +572,7 @@ impl Vbox {
} }
if !indices.iter().all(|i| self.bound.get(*i).is_some()) { 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 // have to sort the indices and keep track of the iteration
@ -584,7 +584,7 @@ impl Vbox {
.map(|(i, index)| { .map(|(i, index)| {
self.bound.remove(index.saturating_sub(i)) self.bound.remove(index.saturating_sub(i))
}) })
.collect::<Vec<Var>>(); .collect::<Vec<Item>>();
// sort the input to align with the combinations // sort the input to align with the combinations
// combos are sorted when created // combos are sorted when created
@ -592,7 +592,7 @@ impl Vbox {
let combos = get_combos(); let combos = get_combos();
let combo = combos.iter().find(|c| c.units == input).ok_or(err_msg("not a combo"))?; 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(); self.bound.sort_unstable();
Ok(self) Ok(self)
@ -642,14 +642,14 @@ mod tests {
#[test] #[test]
fn combine_test() { fn combine_test() {
let mut vbox = Vbox::new(); 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(); vbox.combine(vec![1,2,0]).unwrap();
assert_eq!(vbox.bound[0], Var::Heal); assert_eq!(vbox.bound[0], Item::Heal);
} }
#[test] #[test]
fn combos_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(); let combos = get_combos();
// sort input so they align // sort input so they align
@ -662,14 +662,14 @@ mod tests {
#[test] #[test]
fn reclaim_test() { fn reclaim_test() {
let mut vbox = Vbox::new(); let mut vbox = Vbox::new();
vbox.bound = vec![Var::Strike]; vbox.bound = vec![Item::Strike];
vbox.reclaim(0).unwrap(); vbox.reclaim(0).unwrap();
assert_eq!(vbox.bits, 22); assert_eq!(vbox.bits, 22);
} }
#[test] #[test]
fn colours_count_test() { fn colours_count_test() {
let strike = Var::Strike; let strike = Item::Strike;
let mut count = Colours::new(); let mut count = Colours::new();
strike.colours(&mut count); strike.colours(&mut count);