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 = {
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: {

6
server/src/cryp.rs
View File

@ -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);
}

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 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<Instance, Error> {
pub fn vbox_unequip(mut self, account: Uuid, target: Item, cryp_id: Uuid) -> Result<Instance, Error> {
self.vbox_action_allowed(account)?;
self.account_player(account)?
.vbox_unequip(target, cryp_id)?;

42
server/src/player.rs
View File

@ -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 {

4
server/src/rpc.rs
View File

@ -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)]

14
server/src/skill.rs
View File

@ -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(),
}
}

510
server/src/vbox.rs
View File

@ -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<VarEffect> {
pub fn effect(&self) -> Option<ItemEffect> {
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<Skill> {
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<Spec> {
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<Skill> for Var {
fn from(skill: Skill) -> Var {
impl From<Skill> 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<Spec> for Var {
fn from(spec: Spec) -> Var {
impl From<Spec> 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<Spec> for Var {
#[derive(Debug,Clone,Serialize,Deserialize)]
pub struct Combo {
var: Var,
units: Vec<Var>,
item: Item,
units: Vec<Item>,
}
fn get_combos() -> Vec<Combo> {
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<Combo> {
}
#[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<Combo>,
pub vars: Vec<VarInfo>,
pub items: Vec<ItemInfo>,
}
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::<Vec<Var>>();
.collect::<Vec<Item>>();
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::<Vec<VarInfo>>();
.collect::<Vec<ItemInfo>>();
let combos = get_combos();
return VboxInfo {
combos,
vars,
items,
};
}
#[derive(Debug,Clone,Serialize,Deserialize)]
pub struct Vbox {
pub bits: u16,
pub free: Vec<Vec<Var>>,
pub bound: Vec<Var>,
pub free: Vec<Vec<Item>>,
pub bound: Vec<Item>,
}
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::<Vec<Var>>()
.collect::<Vec<Item>>()
})
.collect::<Vec<Vec<Var>>>();
.collect::<Vec<Vec<Item>>>();
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::<Vec<Var>>();
.collect::<Vec<Item>>();
// 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);