533 lines
20 KiB
Rust
533 lines
20 KiB
Rust
use skill::{Skill};
|
|
use spec::{Spec};
|
|
use cryp::{Colours};
|
|
|
|
#[derive(Debug,Copy,Clone,Serialize,Deserialize,PartialEq,PartialOrd,Ord,Eq)]
|
|
pub enum Item {
|
|
// colours
|
|
Blue,
|
|
Green,
|
|
Red,
|
|
|
|
// base skills
|
|
Attack,
|
|
Block,
|
|
Stun,
|
|
Buff,
|
|
Debuff,
|
|
|
|
// specs
|
|
// Base
|
|
Damage,
|
|
Life,
|
|
Speed,
|
|
|
|
// Lifes Upgrades
|
|
GreenLifeI,
|
|
RedLifeI,
|
|
BlueLifeI,
|
|
GRLI,
|
|
GBLI,
|
|
RBLI,
|
|
|
|
// Damage Upgrades
|
|
RedDamageI,
|
|
BlueDamageI,
|
|
GreenDamageI,
|
|
GRDI,
|
|
GBDI,
|
|
RBDI,
|
|
|
|
// Speed Upgrades
|
|
RedSpeedI,
|
|
BlueSpeedI,
|
|
GreenSpeedI,
|
|
GRSpeedI,
|
|
GBSpeedI,
|
|
RBSpeedI,
|
|
|
|
Amplify,
|
|
Banish,
|
|
Blast,
|
|
Chaos,
|
|
Clutch,
|
|
Corrupt,
|
|
Curse,
|
|
Decay,
|
|
Hostility,
|
|
Haste,
|
|
Heal,
|
|
Hex,
|
|
Impurity,
|
|
Invert,
|
|
Parry,
|
|
Purge,
|
|
Purify,
|
|
Reflect,
|
|
Recharge,
|
|
Ruin,
|
|
Scatter,
|
|
Silence,
|
|
Slay,
|
|
Sleep,
|
|
Snare,
|
|
Strangle,
|
|
Strike,
|
|
StrikeII,
|
|
StrikeIII,
|
|
Siphon,
|
|
Taunt,
|
|
Throw,
|
|
Triage,
|
|
|
|
|
|
TestTouch,
|
|
TestStun,
|
|
TestBlock,
|
|
TestParry,
|
|
TestSiphon,
|
|
}
|
|
|
|
pub enum ItemEffect {
|
|
Skill,
|
|
Spec,
|
|
}
|
|
|
|
impl Item {
|
|
pub fn colours(&self, count: &mut Colours) {
|
|
let combos = get_combos();
|
|
let combo = combos.iter().find(|c| c.item == *self);
|
|
match combo {
|
|
Some(c) => c.units.iter().for_each(|unit| match unit {
|
|
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);
|
|
count.red += combo_count.red;
|
|
count.blue += combo_count.blue;
|
|
count.green += combo_count.green;
|
|
}
|
|
}),
|
|
None => (),
|
|
}
|
|
}
|
|
|
|
pub fn cost(&self) -> u16 {
|
|
match self {
|
|
Item::Red => 1,
|
|
Item::Green => 1,
|
|
Item::Blue => 1,
|
|
|
|
Item::Attack => 2,
|
|
Item::Block => 2,
|
|
Item::Buff => 2,
|
|
Item::Debuff => 2,
|
|
Item::Stun => 2,
|
|
|
|
Item::Damage => 3,
|
|
Item::Life => 3,
|
|
Item::Speed => 3,
|
|
|
|
_ => {
|
|
let combos = get_combos();
|
|
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());
|
|
},
|
|
}
|
|
}
|
|
|
|
pub fn speed(&self) -> u8 {
|
|
match self {
|
|
Item::Red => 3,
|
|
Item::Green => 2,
|
|
Item::Blue => 1,
|
|
|
|
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.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<ItemEffect> {
|
|
if let Some(_skill) = self.into_skill() {
|
|
return Some(ItemEffect::Skill);
|
|
}
|
|
if let Some(_spec) = self.into_spec() {
|
|
return Some(ItemEffect::Spec);
|
|
}
|
|
return None;
|
|
}
|
|
|
|
pub fn into_skill(&self) -> Option<Skill> {
|
|
match self {
|
|
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 {
|
|
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),
|
|
|
|
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),
|
|
|
|
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,
|
|
}
|
|
}
|
|
|
|
pub fn into_description(&self) -> String {
|
|
match self {
|
|
// colours
|
|
Item::Blue => format!("Combine with skills and specs to create upgraded items. \n Deterrents and destruction."),
|
|
Item::Green => format!("Combine with skills and specs to create upgraded items.\n Protection and trickery."),
|
|
Item::Red => format!("Combine with skills and specs to create upgraded items. \n Speed and chaos."),
|
|
|
|
// base skills
|
|
Item::Attack => format!("Deal {:?}% RedDamage", self.into_skill().unwrap().multiplier()),
|
|
Item::Block => format!("description"),
|
|
Item::Stun => format!("description"),
|
|
Item::Buff => format!("description"),
|
|
Item::Debuff => format!("description"),
|
|
|
|
// specs
|
|
// Base
|
|
Item::Damage => format!("description"),
|
|
Item::Life => format!("description"),
|
|
Item::Speed => format!("description"),
|
|
|
|
// Lifes Upgrades
|
|
Item::GreenLifeI => format!("description"),
|
|
Item::RedLifeI => format!("description"),
|
|
Item::BlueLifeI => format!("description"),
|
|
Item::GRLI => format!("description"),
|
|
Item::GBLI => format!("description"),
|
|
Item::RBLI => format!("description"),
|
|
|
|
// Damage Upgrades
|
|
Item::RedDamageI => format!("description"),
|
|
Item::BlueDamageI => format!("description"),
|
|
Item::GreenDamageI => format!("description"),
|
|
Item::GRDI => format!("description"),
|
|
Item::GBDI => format!("description"),
|
|
Item::RBDI => format!("description"),
|
|
|
|
// Speed Upgrades
|
|
Item::RedSpeedI => format!("description"),
|
|
Item::BlueSpeedI => format!("description"),
|
|
Item::GreenSpeedI => format!("description"),
|
|
Item::GRSpeedI => format!("description"),
|
|
Item::GBSpeedI => format!("description"),
|
|
Item::RBSpeedI => format!("description"),
|
|
|
|
Item::Amplify => format!("description"),
|
|
Item::Banish => format!("description"),
|
|
Item::Blast => format!("description"),
|
|
Item::Chaos => format!("description"),
|
|
Item::Clutch => format!("description"),
|
|
Item::Corrupt => format!("description"),
|
|
Item::Curse => format!("description"),
|
|
Item::Decay => format!("description"),
|
|
Item::Hostility => format!("description"),
|
|
Item::Haste => format!("description"),
|
|
Item::Heal => format!("description"),
|
|
Item::Hex => format!("description"),
|
|
Item::Impurity => format!("description"),
|
|
Item::Invert => format!("description"),
|
|
Item::Parry => format!("description"),
|
|
Item::Purge => format!("description"),
|
|
Item::Purify => format!(
|
|
"Remove debuffs and heal for {:?}% GreenDamage per debuff removed.",
|
|
self.into_skill().unwrap().multiplier()),
|
|
Item::Reflect => format!("description"),
|
|
Item::Recharge => format!("description"),
|
|
Item::Ruin => format!("description"),
|
|
Item::Scatter => format!("description"),
|
|
Item::Silence => format!("description"),
|
|
Item::Slay => format!("description"),
|
|
Item::Sleep => format!("description"),
|
|
Item::Snare => format!("description"),
|
|
Item::Strangle => format!("description"),
|
|
Item::Strike => format!("description"),
|
|
Item::StrikeII => format!("description"),
|
|
Item::StrikeIII => format!("description"),
|
|
Item::Siphon => format!("description"),
|
|
Item::Taunt => format!("description"),
|
|
Item::Throw => format!("description"),
|
|
Item::Triage => format!("description"),
|
|
|
|
_ => format!("..."),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<Skill> for Item {
|
|
fn from(skill: Skill) -> Item {
|
|
match skill {
|
|
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 => 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 Item {
|
|
fn from(spec: Spec) -> Item {
|
|
match spec {
|
|
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 => 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 => 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),
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
#[derive(Debug,Clone,Serialize,Deserialize)]
|
|
pub struct Combo {
|
|
pub item: Item,
|
|
pub units: Vec<Item>,
|
|
}
|
|
|
|
pub fn get_combos() -> Vec<Combo> {
|
|
let mut combinations = vec![
|
|
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![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![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![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![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![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![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![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![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 },
|
|
|
|
];
|
|
|
|
combinations.iter_mut().for_each(|set| set.units.sort_unstable());
|
|
|
|
return combinations;
|
|
}
|
|
|
|
#[derive(Debug,Clone,Serialize,Deserialize)]
|
|
pub struct ItemInfo {
|
|
pub item: Item,
|
|
pub spec: bool,
|
|
pub skill: bool,
|
|
pub description: String,
|
|
}
|
|
|
|
|
|
#[derive(Debug,Clone,Serialize,Deserialize)]
|
|
pub struct ItemInfoCtr {
|
|
pub combos: Vec<Combo>,
|
|
pub items: Vec<ItemInfo>,
|
|
}
|
|
|
|
pub fn item_info() -> ItemInfoCtr {
|
|
let combos = get_combos();
|
|
let mut items = combos
|
|
.into_iter()
|
|
.flat_map(|mut c| {
|
|
c.units.push(c.item);
|
|
c.units
|
|
})
|
|
.collect::<Vec<Item>>();
|
|
|
|
items.sort_unstable();
|
|
items.dedup();
|
|
|
|
let items = items
|
|
.into_iter()
|
|
.map(|v| ItemInfo {
|
|
item: v,
|
|
spec: v.into_spec().is_some(),
|
|
skill: v.into_skill().is_some(),
|
|
description: v.into_description(),
|
|
})
|
|
.collect::<Vec<ItemInfo>>();
|
|
|
|
let combos = get_combos();
|
|
|
|
return ItemInfoCtr {
|
|
combos,
|
|
items,
|
|
};
|
|
}
|