1417 lines
66 KiB
Rust
1417 lines
66 KiB
Rust
use skill::{Skill};
|
|
use spec::{Spec, SpecValues};
|
|
use construct::{Colours};
|
|
use effect::{Colour};
|
|
|
|
#[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
|
|
Power,
|
|
Life,
|
|
Speed,
|
|
|
|
// Lifes Upgrades
|
|
LifeGGI,
|
|
LifeRRI,
|
|
LifeBBI,
|
|
LifeRGI,
|
|
LifeGBI,
|
|
LifeRBI,
|
|
LifeGGII,
|
|
LifeRRII,
|
|
LifeBBII,
|
|
LifeRGII,
|
|
LifeGBII,
|
|
LifeRBII,
|
|
LifeGGIII,
|
|
LifeRRIII,
|
|
LifeBBIII,
|
|
LifeRGIII,
|
|
LifeGBIII,
|
|
LifeRBIII,
|
|
|
|
// Power Upgrades
|
|
PowerRRI,
|
|
PowerBBI,
|
|
PowerGGI,
|
|
PowerRGI,
|
|
PowerGBI,
|
|
PowerRBI,
|
|
PowerRRII,
|
|
PowerGGII,
|
|
PowerBBII,
|
|
PowerRGII,
|
|
PowerGBII,
|
|
PowerRBII,
|
|
PowerRRIII,
|
|
PowerBBIII,
|
|
PowerGGIII,
|
|
PowerRGIII,
|
|
PowerGBIII,
|
|
PowerRBIII,
|
|
|
|
// Speed Upgrades
|
|
SpeedRRI,
|
|
SpeedBBI,
|
|
SpeedGGI,
|
|
SpeedRGI,
|
|
SpeedGBI,
|
|
SpeedRBI,
|
|
|
|
SpeedRRII,
|
|
SpeedBBII,
|
|
SpeedGGII,
|
|
SpeedRGII,
|
|
SpeedGBII,
|
|
SpeedRBII,
|
|
|
|
SpeedRRIII,
|
|
SpeedBBIII,
|
|
SpeedGGIII,
|
|
SpeedRGIII,
|
|
SpeedGBIII,
|
|
SpeedRBIII,
|
|
|
|
AmplifyI,
|
|
AmplifyII,
|
|
AmplifyIII,
|
|
BanishI,
|
|
BanishII,
|
|
BanishIII,
|
|
BashI,
|
|
BashII,
|
|
BashIII,
|
|
BlastI,
|
|
BlastII,
|
|
BlastIII,
|
|
ChaosI,
|
|
ChaosII,
|
|
ChaosIII,
|
|
ClutchI,
|
|
ClutchII,
|
|
ClutchIII,
|
|
ElectrifyI,
|
|
ElectrifyII,
|
|
ElectrifyIII,
|
|
CurseI,
|
|
CurseII,
|
|
CurseIII,
|
|
DecayI,
|
|
DecayII,
|
|
DecayIII,
|
|
HostilityI,
|
|
HostilityII,
|
|
HostilityIII,
|
|
HasteI,
|
|
HasteII,
|
|
HasteIII,
|
|
HealI,
|
|
HealII,
|
|
HealIII,
|
|
HexI,
|
|
HexII,
|
|
HexIII,
|
|
HybridI,
|
|
HybridII,
|
|
HybridIII,
|
|
InvertI,
|
|
InvertII,
|
|
InvertIII,
|
|
CounterI,
|
|
CounterII,
|
|
CounterIII,
|
|
PurgeI,
|
|
PurgeII,
|
|
PurgeIII,
|
|
PurifyI,
|
|
PurifyII,
|
|
PurifyIII,
|
|
ReflectI,
|
|
ReflectII,
|
|
ReflectIII,
|
|
RechargeI,
|
|
RechargeII,
|
|
RechargeIII,
|
|
RuinI,
|
|
RuinII,
|
|
RuinIII,
|
|
ScatterI,
|
|
ScatterII,
|
|
ScatterIII,
|
|
SilenceI,
|
|
SilenceII,
|
|
SilenceIII,
|
|
SlayI,
|
|
SlayII,
|
|
SlayIII,
|
|
SleepI,
|
|
SleepII,
|
|
SleepIII,
|
|
RestrictI,
|
|
RestrictII,
|
|
RestrictIII,
|
|
StrikeI,
|
|
StrikeII,
|
|
StrikeIII,
|
|
SiphonI,
|
|
SiphonII,
|
|
SiphonIII,
|
|
InterceptI,
|
|
InterceptII,
|
|
InterceptIII,
|
|
ThrowI,
|
|
ThrowII,
|
|
ThrowIII,
|
|
TriageI,
|
|
TriageII,
|
|
TriageIII,
|
|
}
|
|
|
|
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.components.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 components(&self) -> Vec<Item> {
|
|
let combos = get_combos();
|
|
let combo = combos.iter().find(|c| c.item == *self);
|
|
|
|
match combo {
|
|
Some(c) => c.components.iter().flat_map(|c| c.components()).collect::<Vec<Item>>(),
|
|
None => vec![*self],
|
|
}
|
|
}
|
|
|
|
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::Power => 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.components.iter().fold(0, |acc, c| acc + c.cost());
|
|
},
|
|
}
|
|
}
|
|
|
|
pub fn speed(&self) -> u64 {
|
|
match self {
|
|
Item::Attack => 1,
|
|
Item::Stun => 2,
|
|
Item::Block => 3,
|
|
Item::Buff |
|
|
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));
|
|
|
|
let mut colour_speed = 0;
|
|
let mut skill_speed = 0;
|
|
let mut component_speed = 0;
|
|
|
|
combo.components.iter().for_each(|unit| {
|
|
colour_speed += match unit {
|
|
Item::Red => 3,
|
|
Item::Green => 2,
|
|
Item::Blue => 1,
|
|
_ => 0,
|
|
};
|
|
skill_speed += match unit {
|
|
Item::Attack => 1,
|
|
Item::Stun => 2,
|
|
Item::Block => 3,
|
|
Item::Buff |
|
|
Item::Debuff => 4,
|
|
_ => 0,
|
|
};
|
|
if colour_speed == 0 && skill_speed == 0 {
|
|
component_speed = unit.speed();
|
|
}
|
|
});
|
|
if component_speed > 0 { return component_speed };
|
|
return 24 + colour_speed * skill_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::AmplifyI => Some(Skill::AmplifyI),
|
|
Item::AmplifyII => Some(Skill::AmplifyII),
|
|
Item::AmplifyIII => Some(Skill::AmplifyIII),
|
|
Item::BanishI => Some(Skill::BanishI),
|
|
Item::BanishII => Some(Skill::BanishII),
|
|
Item::BanishIII => Some(Skill::BanishIII),
|
|
Item::BlastI => Some(Skill::BlastI),
|
|
Item::BlastII => Some(Skill::BlastII),
|
|
Item::BlastIII => Some(Skill::BlastIII),
|
|
Item::Block => Some(Skill::Block),
|
|
Item::Buff => Some(Skill::Buff),
|
|
Item::ChaosI => Some(Skill::ChaosI),
|
|
Item::ChaosII => Some(Skill::ChaosII),
|
|
Item::ChaosIII => Some(Skill::ChaosIII),
|
|
Item::CurseI => Some(Skill::CurseI),
|
|
Item::CurseII => Some(Skill::CurseII),
|
|
Item::CurseIII => Some(Skill::CurseIII),
|
|
Item::Debuff => Some(Skill::Debuff),
|
|
Item::DecayI => Some(Skill::DecayI),
|
|
Item::DecayII => Some(Skill::DecayII),
|
|
Item::DecayIII => Some(Skill::DecayIII),
|
|
Item::HasteI => Some(Skill::HasteI),
|
|
Item::HasteII => Some(Skill::HasteII),
|
|
Item::HasteIII => Some(Skill::HasteIII),
|
|
Item::HealI => Some(Skill::HealI),
|
|
Item::HealII => Some(Skill::HealII),
|
|
Item::HealIII => Some(Skill::HealIII),
|
|
Item::HexI => Some(Skill::HexI),
|
|
Item::HexII => Some(Skill::HexII),
|
|
Item::HexIII => Some(Skill::HexIII),
|
|
Item::HostilityI => Some(Skill::HostilityI),
|
|
Item::HostilityII => Some(Skill::HostilityII),
|
|
Item::HostilityIII=> Some(Skill::HostilityIII),
|
|
Item::HybridI => Some(Skill::HybridI),
|
|
Item::HybridII => Some(Skill::HybridII),
|
|
Item::HybridIII => Some(Skill::HybridIII),
|
|
Item::InvertI => Some(Skill::InvertI),
|
|
Item::InvertII => Some(Skill::InvertII),
|
|
Item::InvertIII => Some(Skill::InvertIII),
|
|
Item::CounterI => Some(Skill::CounterI),
|
|
Item::CounterII => Some(Skill::CounterII),
|
|
Item::CounterIII => Some(Skill::CounterIII),
|
|
Item::PurgeI => Some(Skill::PurgeI),
|
|
Item::PurgeII => Some(Skill::PurgeII),
|
|
Item::PurgeIII => Some(Skill::PurgeIII),
|
|
Item::PurifyI => Some(Skill::PurifyI),
|
|
Item::PurifyII => Some(Skill::PurifyII),
|
|
Item::PurifyIII => Some(Skill::PurifyIII),
|
|
Item::RechargeI => Some(Skill::RechargeI),
|
|
Item::RechargeII => Some(Skill::RechargeII),
|
|
Item::RechargeIII => Some(Skill::RechargeIII),
|
|
Item::ReflectI => Some(Skill::ReflectI),
|
|
Item::ReflectII => Some(Skill::ReflectII),
|
|
Item::ReflectIII => Some(Skill::ReflectIII),
|
|
Item::RuinI => Some(Skill::RuinI),
|
|
Item::RuinII => Some(Skill::RuinII),
|
|
Item::RuinIII => Some(Skill::RuinIII),
|
|
Item::ScatterI => Some(Skill::ScatterI),
|
|
Item::ScatterII => Some(Skill::ScatterII),
|
|
Item::ScatterIII => Some(Skill::ScatterIII),
|
|
Item::SilenceI => Some(Skill::SilenceI),
|
|
Item::SilenceII => Some(Skill::SilenceII),
|
|
Item::SilenceIII => Some(Skill::SilenceIII),
|
|
Item::SlayI => Some(Skill::SlayI),
|
|
Item::SlayII => Some(Skill::SlayII),
|
|
Item::SlayIII => Some(Skill::SlayIII),
|
|
Item::SleepI => Some(Skill::SleepI),
|
|
Item::SleepII => Some(Skill::SleepII),
|
|
Item::SleepIII => Some(Skill::SleepIII),
|
|
Item::SiphonI => Some(Skill::SiphonI),
|
|
Item::SiphonII => Some(Skill::SiphonII),
|
|
Item::SiphonIII => Some(Skill::SiphonIII),
|
|
Item::RestrictI => Some(Skill::RestrictI),
|
|
Item::RestrictII => Some(Skill::RestrictII),
|
|
Item::RestrictIII => Some(Skill::RestrictIII),
|
|
Item::BashI => Some(Skill::BashI),
|
|
Item::BashII => Some(Skill::BashII),
|
|
Item::BashIII => Some(Skill::BashIII),
|
|
Item::Stun => Some(Skill::Stun),
|
|
Item::StrikeI => Some(Skill::StrikeI),
|
|
Item::StrikeII => Some(Skill::StrikeII),
|
|
Item::StrikeIII => Some(Skill::StrikeIII),
|
|
Item::ClutchI => Some(Skill::ClutchI),
|
|
Item::ClutchII => Some(Skill::ClutchII),
|
|
Item::ClutchIII => Some(Skill::ClutchIII),
|
|
Item::InterceptI => Some(Skill::InterceptI),
|
|
Item::InterceptII => Some(Skill::InterceptII),
|
|
Item::InterceptIII => Some(Skill::InterceptIII),
|
|
Item::ThrowI => Some(Skill::ThrowI),
|
|
Item::ThrowII => Some(Skill::ThrowII),
|
|
Item::ThrowIII => Some(Skill::ThrowIII),
|
|
Item::ElectrifyI => Some(Skill::ElectrifyI),
|
|
Item::ElectrifyII => Some(Skill::ElectrifyII),
|
|
Item::ElectrifyIII => Some(Skill::ElectrifyIII),
|
|
Item::TriageI => Some(Skill::TriageI),
|
|
Item::TriageII => Some(Skill::TriageII),
|
|
Item::TriageIII => Some(Skill::TriageIII),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
pub fn into_spec(&self) -> Option<Spec> {
|
|
match *self {
|
|
Item::Speed => Some(Spec::Speed),
|
|
Item::SpeedRRI => Some(Spec::SpeedRRI),
|
|
Item::SpeedBBI => Some(Spec::SpeedBBI),
|
|
Item::SpeedGGI => Some(Spec::SpeedGGI),
|
|
Item::SpeedRGI => Some(Spec::SpeedRGI),
|
|
Item::SpeedGBI => Some(Spec::SpeedGBI),
|
|
Item::SpeedRBI => Some(Spec::SpeedRBI),
|
|
|
|
Item::SpeedRRII => Some(Spec::SpeedRRII),
|
|
Item::SpeedBBII => Some(Spec::SpeedBBII),
|
|
Item::SpeedGGII => Some(Spec::SpeedGGII),
|
|
Item::SpeedRGII => Some(Spec::SpeedRGII),
|
|
Item::SpeedGBII => Some(Spec::SpeedGBII),
|
|
Item::SpeedRBII => Some(Spec::SpeedRBII),
|
|
|
|
Item::SpeedRRIII => Some(Spec::SpeedRRIII),
|
|
Item::SpeedBBIII => Some(Spec::SpeedBBIII),
|
|
Item::SpeedGGIII => Some(Spec::SpeedGGIII),
|
|
Item::SpeedRGIII => Some(Spec::SpeedRGIII),
|
|
Item::SpeedGBIII => Some(Spec::SpeedGBIII),
|
|
Item::SpeedRBIII => Some(Spec::SpeedRBIII),
|
|
|
|
Item::Power => Some(Spec::Power),
|
|
Item::PowerRRI => Some(Spec::PowerRRI),
|
|
Item::PowerBBI => Some(Spec::PowerBBI),
|
|
Item::PowerGGI => Some(Spec::PowerGGI),
|
|
Item::PowerRGI => Some(Spec::PowerRGI),
|
|
Item::PowerGBI => Some(Spec::PowerGBI),
|
|
Item::PowerRBI => Some(Spec::PowerRBI),
|
|
Item::PowerRRII => Some(Spec::PowerRRII),
|
|
Item::PowerBBII => Some(Spec::PowerBBII),
|
|
Item::PowerGGII => Some(Spec::PowerGGII),
|
|
Item::PowerRGII => Some(Spec::PowerRGII),
|
|
Item::PowerGBII => Some(Spec::PowerGBII),
|
|
Item::PowerRBII => Some(Spec::PowerRBII),
|
|
Item::PowerRRIII => Some(Spec::PowerRRIII),
|
|
Item::PowerBBIII => Some(Spec::PowerBBIII),
|
|
Item::PowerGGIII => Some(Spec::PowerGGIII),
|
|
Item::PowerRGIII => Some(Spec::PowerRGIII),
|
|
Item::PowerGBIII => Some(Spec::PowerGBIII),
|
|
Item::PowerRBIII => Some(Spec::PowerRBIII),
|
|
|
|
Item::Life => Some(Spec::Life),
|
|
Item::LifeRGI => Some(Spec::LifeRGI),
|
|
Item::LifeGBI => Some(Spec::LifeGBI),
|
|
Item::LifeRBI => Some(Spec::LifeRBI),
|
|
Item::LifeGGI => Some(Spec::LifeGGI),
|
|
Item::LifeRRI => Some(Spec::LifeRRI),
|
|
Item::LifeBBI => Some(Spec::LifeBBI),
|
|
Item::LifeRGII => Some(Spec::LifeRGII),
|
|
Item::LifeGBII => Some(Spec::LifeGBII),
|
|
Item::LifeRBII => Some(Spec::LifeRBII),
|
|
Item::LifeGGII => Some(Spec::LifeGGII),
|
|
Item::LifeRRII => Some(Spec::LifeRRII),
|
|
Item::LifeBBII => Some(Spec::LifeBBII),
|
|
Item::LifeRGIII => Some(Spec::LifeRGIII),
|
|
Item::LifeGBIII => Some(Spec::LifeGBIII),
|
|
Item::LifeRBIII => Some(Spec::LifeRBIII),
|
|
Item::LifeGGIII => Some(Spec::LifeGGIII),
|
|
Item::LifeRRIII => Some(Spec::LifeRRIII),
|
|
Item::LifeBBIII => Some(Spec::LifeBBIII),
|
|
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
pub fn into_colour(&self) -> Colour {
|
|
match *self {
|
|
Item::Red => Colour::Red,
|
|
Item::Green => Colour::Green,
|
|
Item::Blue => Colour::Blue,
|
|
_ => panic!("{:?} is not a colour", self),
|
|
}
|
|
}
|
|
|
|
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 based on {:?}% RedPower",
|
|
self.into_skill().unwrap().multiplier()),
|
|
Item::Block => format!("Reduce incoming RedDamage by {:?}%",
|
|
100 - self.into_skill().unwrap().effect()[0].get_multiplier()),
|
|
|
|
|
|
Item::Stun => format!("Stun target construct for {:?}T",
|
|
self.into_skill().unwrap().effect()[0].get_duration()),
|
|
Item::Buff => format!("Increase target construct RedPower and speed by {:?}%",
|
|
self.into_skill().unwrap().effect()[0].get_multiplier() - 100),
|
|
Item::Debuff => format!("Slow target construct speed by {:?}%",
|
|
100 - self.into_skill().unwrap().effect()[0].get_multiplier()),
|
|
// specs
|
|
// Base
|
|
Item::Power => format!("Base ITEM for increased Power. Power determines the damage caused by your SKILLS."),
|
|
Item::Life => format!("Base ITEM for increased LIFE.
|
|
When your CONSTRUCT reaches 0 GreenLife it becomes KO and cannot cast SKILLS."),
|
|
Item::Speed => format!("Base ITEM for increased SPEED.
|
|
SPEED determines the order in which skills resolve.
|
|
Some SKILLS (such as STRIKE) have their damage increased by SPEED."),
|
|
|
|
// Lifes Upgrades
|
|
Item::LifeGGI => format!("Increases CONSTRUCT GreenLife.
|
|
When your CONSTRUCT reaches 0 GreenLife it becomes KO and cannot cast SKILLS."),
|
|
Item::LifeRRI => format!("Increases CONSTRUCT RedLife.
|
|
RedDamage dealt to your construct reduces RedLife before GreenLife."),
|
|
Item::LifeBBI => format!("Increases CONSTRUCT BlueLife.
|
|
BlueDamage dealt to your construct reduces BlueLife before GreenLife."),
|
|
Item::LifeRGI => format!("Increases CONSTRUCT GreenLife + RedLife"),
|
|
Item::LifeGBI => format!("Increases CONSTRUCT GreenLife + BlueLife"),
|
|
Item::LifeRBI => format!("Increases CONSTRUCT RedLife + BlueLife"),
|
|
Item::LifeGGII => format!("Increases CONSTRUCT GreenLife.
|
|
When your CONSTRUCT reaches 0 GreenLife it becomes KO and cannot cast SKILLS."),
|
|
Item::LifeRRII => format!("Increases CONSTRUCT RedLife.
|
|
RedDamage dealt to your construct reduces RedLife before GreenLife."),
|
|
Item::LifeBBII => format!("Increases CONSTRUCT BlueLife.
|
|
BlueDamage dealt to your construct reduces BlueLife before GreenLife."),
|
|
Item::LifeRGII => format!("Increases CONSTRUCT GreenLife + RedLife"),
|
|
Item::LifeGBII => format!("Increases CONSTRUCT GreenLife + BlueLife"),
|
|
Item::LifeRBII => format!("Increases CONSTRUCT RedLife + BlueLife"),
|
|
Item::LifeGGIII => format!("Increases CONSTRUCT GreenLife.
|
|
When your CONSTRUCT reaches 0 GreenLife it becomes KO and cannot cast SKILLS."),
|
|
Item::LifeRRIII => format!("Increases CONSTRUCT RedLife.
|
|
RedDamage dealt to your construct reduces RedLife before GreenLife."),
|
|
Item::LifeBBIII => format!("Increases CONSTRUCT BlueLife.
|
|
BlueDamage dealt to your construct reduces BlueLife before GreenLife."),
|
|
Item::LifeRGIII => format!("Increases CONSTRUCT GreenLife + RedLife"),
|
|
Item::LifeGBIII => format!("Increases CONSTRUCT GreenLife + BlueLife"),
|
|
Item::LifeRBIII => format!("Increases CONSTRUCT RedLife + BlueLife"),
|
|
|
|
// Power Upgrades
|
|
Item::PowerRRI => format!("Increases CONSTRUCT RedPower."),
|
|
Item::PowerBBI => format!("Increases CONSTRUCT BluePower."),
|
|
Item::PowerGGI => format!("Increases CONSTRUCT GreenPower."),
|
|
Item::PowerRGI => format!("Increases CONSTRUCT GreenPower + RedPower."),
|
|
Item::PowerGBI => format!("Increases CONSTRUCT GreenPower + BluePower."),
|
|
Item::PowerRBI => format!("Increases CONSTRUCT RedPower + BluePower."),
|
|
Item::PowerRRII => format!("Increases CONSTRUCT RedPower."),
|
|
Item::PowerBBII => format!("Increases CONSTRUCT BluePower."),
|
|
Item::PowerGGII => format!("Increases CONSTRUCT GreenPower."),
|
|
Item::PowerRGII => format!("Increases CONSTRUCT GreenPower + RedPower."),
|
|
Item::PowerGBII => format!("Increases CONSTRUCT GreenPower + BluePower."),
|
|
Item::PowerRBII => format!("Increases CONSTRUCT RedPower + BluePower."),
|
|
Item::PowerRRIII => format!("Increases CONSTRUCT RedPower."),
|
|
Item::PowerBBIII => format!("Increases CONSTRUCT BluePower."),
|
|
Item::PowerGGIII => format!("Increases CONSTRUCT GreenPower."),
|
|
Item::PowerRGIII => format!("Increases CONSTRUCT GreenPower + RedPower."),
|
|
Item::PowerGBIII => format!("Increases CONSTRUCT GreenPower + BluePower."),
|
|
Item::PowerRBIII => format!("Increases CONSTRUCT RedPower + BluePower."),
|
|
|
|
// Speed Upgrades
|
|
Item::SpeedRRI |
|
|
Item::SpeedBBI |
|
|
Item::SpeedGGI |
|
|
Item::SpeedRGI |
|
|
Item::SpeedGBI |
|
|
Item::SpeedRBI |
|
|
Item::SpeedRRII |
|
|
Item::SpeedBBII |
|
|
Item::SpeedGGII |
|
|
Item::SpeedRGII |
|
|
Item::SpeedGBII |
|
|
Item::SpeedRBII |
|
|
Item::SpeedRRIII |
|
|
Item::SpeedBBIII |
|
|
Item::SpeedGGIII |
|
|
Item::SpeedRGIII |
|
|
Item::SpeedGBIII |
|
|
Item::SpeedRBIII => format!("Increases CONSTRUCT SPEED and provides COLOUR BONUSES"),
|
|
|
|
// Skills <- need to move effect mulltipliers into skills
|
|
Item::AmplifyI |
|
|
Item::AmplifyII |
|
|
Item::AmplifyIII => format!("Increase red and blue power by {:?}%. Lasts {:?}T",
|
|
self.into_skill().unwrap().effect()[0].get_multiplier() - 100,
|
|
self.into_skill().unwrap().effect()[0].get_duration()),
|
|
|
|
Item::BanishI |
|
|
Item::BanishII |
|
|
Item::BanishIII => format!("Banish target for {:?}T.
|
|
Banished constructs are immune to all skills and effects.",
|
|
self.into_skill().unwrap().effect()[0].get_duration()),
|
|
|
|
Item::BlastI |
|
|
Item::BlastII |
|
|
Item::BlastIII => format!("Deals Blue Damage {:?}% Blue Power.", self.into_skill().unwrap().multiplier()),
|
|
|
|
Item::ChaosI |
|
|
Item::ChaosII |
|
|
Item::ChaosIII => format!(
|
|
"Hits twice for red and blue damage. Damage {:?}% red and blue power. Randomly deals 0 to 30% more damage",
|
|
self.into_skill().unwrap().multiplier()),
|
|
|
|
Item::ClutchI |
|
|
Item::ClutchII |
|
|
Item::ClutchIII => format!("Construct cannot be KO'd while active. Additionally provides immunity to disables. \
|
|
Lasts {:?}T",
|
|
self.into_skill().unwrap().effect()[0].get_duration()),
|
|
|
|
Item::ElectrifyI |
|
|
Item::ElectrifyII |
|
|
Item::ElectrifyIII => format!(
|
|
"Self targetting defensive for {:?}T. Applies Electric to attackers dealing BlueDamage {:?}% \
|
|
BluePower per turn for {:?}T.",
|
|
self.into_skill().unwrap().effect()[0].get_duration(),
|
|
self.into_skill().unwrap().effect()[0].get_skill().unwrap().effect()[0].get_skill().unwrap().multiplier(),
|
|
self.into_skill().unwrap().effect()[0].get_skill().unwrap().effect()[0].get_duration()),
|
|
|
|
Item::CurseI |
|
|
Item::CurseII |
|
|
Item::CurseIII => format!(
|
|
"Increases red and blue damage taken by {:?}%. Lasts {:?}T",
|
|
self.into_skill().unwrap().effect()[0].get_multiplier() - 100,
|
|
self.into_skill().unwrap().effect()[0].get_duration()),
|
|
|
|
Item::DecayI |
|
|
Item::DecayII |
|
|
Item::DecayIII => format!(
|
|
"Reduces healing taken by {:?}% for {:?}T. Deals blue damage {:?}% blue power each turn for {:?}T",
|
|
100 - self.into_skill().unwrap().effect()[0].get_multiplier(),
|
|
self.into_skill().unwrap().effect()[0].get_duration(),
|
|
self.into_skill().unwrap().effect()[1].get_skill().unwrap().multiplier(),
|
|
self.into_skill().unwrap().effect()[1].get_duration()),
|
|
|
|
Item::HostilityI |
|
|
Item::HostilityII |
|
|
Item::HostilityIII => format!(
|
|
"Gain Hostility for {:?}T. {} Hatred lasts {:?}T",
|
|
self.into_skill().unwrap().effect()[0].get_duration(),
|
|
"When attacked by Hostility you gain Hatred which increased red and blue power based on Damage taken.",
|
|
self.into_skill().unwrap().effect()[0].get_skill().unwrap().effect()[0].get_duration()),
|
|
|
|
Item::HasteI |
|
|
Item::HasteII |
|
|
Item::HasteIII => format!(
|
|
"Haste increases Speed by {:?}%, Red based Attack skills will strike again dealing {:?}{}. Lasts {:?}T",
|
|
self.into_skill().unwrap().effect()[0].get_multiplier() - 100,
|
|
Skill::HasteStrike.multiplier(),
|
|
"% Speed as RedDamage",
|
|
self.into_skill().unwrap().effect()[0].get_duration()),
|
|
|
|
Item::HealI |
|
|
Item::HealII |
|
|
Item::HealIII => format!("Heals for {:?}% green power.", self.into_skill().unwrap().multiplier()),
|
|
|
|
Item::HexI |
|
|
Item::HexII |
|
|
Item::HexIII => format!("Blue based skill that applies Hex for {:?}T. \
|
|
Hexed targets cannot cast any skills.",
|
|
self.into_skill().unwrap().effect()[0].get_duration()),
|
|
|
|
Item::HybridI |
|
|
Item::HybridII |
|
|
Item::HybridIII => format!(
|
|
"Hybrid increases Green Power by {:?}%, Blue based Attack skills will blast again dealing {:?}{}. Lasts {:?}T",
|
|
self.into_skill().unwrap().effect()[0].get_multiplier() - 100,
|
|
Skill::HybridBlast.multiplier(),
|
|
"% GreenPower as BluePower",
|
|
self.into_skill().unwrap().effect()[0].get_duration()),
|
|
|
|
Item::InvertI |
|
|
Item::InvertII |
|
|
Item::InvertIII => format!(
|
|
"Reverse healing into damage and damage into healing.
|
|
Any excess red or blue damage is converted into shield recharge."),
|
|
|
|
Item::CounterI |
|
|
Item::CounterII |
|
|
Item::CounterIII => format!("{} {:?}% red power and blocks red skills for {:?}T. {} {:?}% red power.",
|
|
"Self targetting skill. Recharges RedLife for",
|
|
self.into_skill().unwrap().multiplier(),
|
|
self.into_skill().unwrap().effect()[0].get_duration(),
|
|
"If a red skill is parried the construct will riposte the source dealing red damage",
|
|
self.into_skill().unwrap().effect()[0].get_skill().unwrap().multiplier()),
|
|
|
|
Item::PurgeI |
|
|
Item::PurgeII |
|
|
Item::PurgeIII => format!("Remove buffs from target construct"),
|
|
|
|
Item::PurifyI |
|
|
Item::PurifyII |
|
|
Item::PurifyIII => format!(
|
|
"Remove debuffs and heals for {:?}% green power per debuff removed.",
|
|
self.into_skill().unwrap().multiplier()),
|
|
|
|
Item::ReflectI |
|
|
Item::ReflectII |
|
|
Item::ReflectIII => format!(
|
|
"Reflect incoming blue skills to source. Lasts {:?}T",
|
|
self.into_skill().unwrap().effect()[0].get_duration()),
|
|
|
|
Item::RechargeI |
|
|
Item::RechargeII |
|
|
Item::RechargeIII => format!(
|
|
"Recharge Red and Blue Life based on {:?} RedPower and BluePower",
|
|
self.into_skill().unwrap().multiplier()),
|
|
|
|
Item::RuinI |
|
|
Item::RuinII |
|
|
Item::RuinIII => format!(
|
|
"Team wide Stun for {:?}T. Stunned constructs are unable to cast skills.",
|
|
self.into_skill().unwrap().effect()[0].get_duration()),
|
|
|
|
Item::ScatterI |
|
|
Item::ScatterII |
|
|
Item::ScatterIII => format!(
|
|
"Caster links with target. Linked constructs split incoming Damage evenly. Recharges target Blue Life {:?}% of BluePower",
|
|
self.into_skill().unwrap().multiplier()),
|
|
|
|
Item::SilenceI |
|
|
Item::SilenceII |
|
|
Item::SilenceIII => format!(
|
|
"Block the target from using blue skills for {:?}T and deals blue damage {:?}% blue power. {}",
|
|
self.into_skill().unwrap().effect()[0].get_duration(),
|
|
self.into_skill().unwrap().multiplier(),
|
|
"Deals 45% more Damage per blue skill on target"),
|
|
|
|
Item::SlayI |
|
|
Item::SlayII |
|
|
Item::SlayIII => format!(
|
|
"Deals RedDamage {:?}% RedPower and provides self healing based on damage dealt.",
|
|
self.into_skill().unwrap().multiplier()),
|
|
|
|
Item::SleepI |
|
|
Item::SleepII |
|
|
Item::SleepIII => format!(
|
|
"Stun for {:?}T and heal for {:?}% GreenPower.",
|
|
self.into_skill().unwrap().effect()[0].get_duration(),
|
|
self.into_skill().unwrap().multiplier()),
|
|
|
|
Item::RestrictI |
|
|
Item::RestrictII |
|
|
Item::RestrictIII => format!(
|
|
"Block the target from using red skills for {:?}T and deals RedDamage {:?}% RedPower. {}",
|
|
self.into_skill().unwrap().effect()[0].get_duration(),
|
|
self.into_skill().unwrap().multiplier(),
|
|
"Deals 35% more Damage per red skill on target"),
|
|
|
|
Item::BashI |
|
|
Item::BashII |
|
|
Item::BashIII => format!(
|
|
"Bash the target increasing the cooldowns of their skills.
|
|
Deals {:?}% RedPower per cooldown increased. Lasts {:?}T.",
|
|
self.into_skill().unwrap().effect()[0].get_skill().unwrap().multiplier(),
|
|
self.into_skill().unwrap().effect()[0].get_duration()),
|
|
|
|
Item::StrikeI |
|
|
Item::StrikeII |
|
|
Item::StrikeIII => format!(
|
|
"Hits at maximum speed dealing RedDamage {:?}% RedPower",
|
|
self.into_skill().unwrap().multiplier()),
|
|
|
|
Item::SiphonI |
|
|
Item::SiphonII |
|
|
Item::SiphonIII => format!(
|
|
"Deals BlueDamage {:?}% BluePower each turn and heals caster based on Damage dealt. Lasts {:?}T",
|
|
self.into_skill().unwrap().effect()[0].get_skill().unwrap().multiplier(),
|
|
self.into_skill().unwrap().effect()[0].get_duration()),
|
|
|
|
Item::InterceptI |
|
|
Item::InterceptII |
|
|
Item::InterceptIII => format!("Intercept redirects skills against the team to target, lasts {:?}T.\
|
|
Recharges RedLife for {:?} RedPower.",
|
|
self.into_skill().unwrap().effect()[0].get_duration(),
|
|
self.into_skill().unwrap().multiplier()),
|
|
|
|
Item::ThrowI |
|
|
Item::ThrowII |
|
|
Item::ThrowIII => format!(
|
|
"Stun the target for {:?}T and applies Vulnerable increasing RedDamage taken by {:?}% for {:?}T",
|
|
self.into_skill().unwrap().effect()[0].get_duration(),
|
|
self.into_skill().unwrap().effect()[1].get_multiplier() - 100,
|
|
self.into_skill().unwrap().effect()[1].get_duration()),
|
|
|
|
Item::TriageI |
|
|
Item::TriageII |
|
|
Item::TriageIII => format!(
|
|
"Heals target for {:?}% GreenPower each turn. Lasts {:?}T",
|
|
self.into_skill().unwrap().effect()[0].get_skill().unwrap().multiplier(),
|
|
self.into_skill().unwrap().effect()[0].get_duration()),
|
|
}
|
|
}
|
|
|
|
fn combo(&self) -> Vec<Item> {
|
|
match self {
|
|
Item::InterceptI => vec![Item::Buff, Item::Red, Item::Red],
|
|
Item::InterceptII => vec![Item::InterceptI, Item::InterceptI, Item::InterceptI],
|
|
Item::InterceptIII => vec![Item::InterceptII, Item::InterceptII, Item::InterceptII],
|
|
Item::TriageI => vec![Item::Buff, Item::Green, Item::Green],
|
|
Item::TriageII => vec![Item::TriageI, Item::TriageI, Item::TriageI],
|
|
Item::TriageIII => vec![Item::TriageII, Item::TriageII, Item::TriageII],
|
|
Item::ScatterI => vec![Item::Buff, Item::Blue, Item::Blue],
|
|
Item::ScatterII => vec![Item::ScatterI, Item::ScatterI, Item::ScatterI],
|
|
Item::ScatterIII => vec![Item::ScatterIII, Item::ScatterIII, Item::ScatterIII],
|
|
Item::HasteI => vec![Item::Buff, Item::Red, Item::Green],
|
|
Item::HasteII => vec![Item::HasteI, Item::HasteI, Item::HasteI],
|
|
Item::HasteIII => vec![Item::HasteII, Item::HasteII, Item::HasteII],
|
|
Item::HybridI => vec![Item::Buff, Item::Green, Item::Blue],
|
|
Item::HybridII => vec![Item::HybridI, Item::HybridI, Item::HybridI],
|
|
Item::HybridIII => vec![Item::HybridII, Item::HybridII, Item::HybridII],
|
|
Item::AmplifyI => vec![Item::Buff, Item::Red, Item::Blue],
|
|
Item::AmplifyII => vec![Item::AmplifyI, Item::AmplifyI, Item::AmplifyI],
|
|
Item::AmplifyIII => vec![Item::AmplifyII, Item::AmplifyII, Item::AmplifyII],
|
|
|
|
Item::RestrictI => vec![Item::Debuff, Item::Red, Item::Red],
|
|
Item::RestrictII => vec![Item::RestrictI, Item::RestrictI, Item::RestrictI],
|
|
Item::RestrictIII => vec![Item::RestrictII, Item::RestrictII, Item::RestrictII],
|
|
Item::PurgeI => vec![Item::Debuff, Item::Green, Item::Green], // Needs flavour
|
|
Item::PurgeII => vec![Item::PurgeI, Item::PurgeI, Item::PurgeI], // Needs flavour
|
|
Item::PurgeIII => vec![Item::PurgeII, Item::PurgeII, Item::PurgeII], // Needs flavour
|
|
Item::SilenceI => vec![Item::Debuff, Item::Blue, Item::Blue],
|
|
Item::SilenceII => vec![Item::SilenceI, Item::SilenceI, Item::SilenceI],
|
|
Item::SilenceIII => vec![Item::SilenceII, Item::SilenceII, Item::SilenceII],
|
|
Item::CurseI => vec![Item::Debuff, Item::Red, Item::Green],
|
|
Item::CurseII => vec![Item::CurseI, Item::CurseI, Item::CurseI],
|
|
Item::CurseIII => vec![Item::CurseII, Item::CurseII, Item::CurseII],
|
|
Item::DecayI => vec![Item::Debuff, Item::Green, Item::Blue],
|
|
Item::DecayII => vec![Item::DecayI, Item::DecayI, Item::DecayI],
|
|
Item::DecayIII => vec![Item::DecayII, Item::DecayII, Item::DecayII],
|
|
Item::InvertI => vec![Item::Debuff, Item::Red, Item::Blue],
|
|
Item::InvertII => vec![Item::InvertI, Item::InvertI, Item::InvertI],
|
|
Item::InvertIII => vec![Item::InvertII, Item::InvertII, Item::InvertII],
|
|
|
|
Item::CounterI => vec![Item::Block, Item::Red, Item::Red],
|
|
Item::CounterII => vec![Item::CounterI, Item::CounterI, Item::CounterI],
|
|
Item::CounterIII => vec![Item::CounterII, Item::CounterII, Item::CounterII], // Add red recharge
|
|
Item::PurifyI => vec![Item::Block, Item::Green, Item::Green],
|
|
Item::PurifyII => vec![Item::PurifyI, Item::PurifyI, Item::PurifyI],
|
|
Item::PurifyIII => vec![Item::PurifyII, Item::PurifyII, Item::PurifyII],
|
|
Item::ElectrifyI => vec![Item::Block, Item::Blue, Item::Blue],
|
|
Item::ElectrifyII => vec![Item::ElectrifyI, Item::ElectrifyI, Item::ElectrifyI],
|
|
Item::ElectrifyIII => vec![Item::ElectrifyII, Item::ElectrifyII, Item::ElectrifyII],
|
|
Item::ClutchI => vec![Item::Block, Item::Red, Item::Green],
|
|
Item::ClutchII => vec![Item::ClutchI, Item::ClutchI, Item::ClutchI],
|
|
Item::ClutchIII => vec![Item::ClutchII, Item::ClutchII, Item::ClutchII],
|
|
Item::ReflectI => vec![Item::Block, Item::Green, Item::Blue],
|
|
Item::ReflectII => vec![Item::ReflectI, Item::ReflectI, Item::ReflectI],
|
|
Item::ReflectIII => vec![Item::ReflectII, Item::ReflectII, Item::ReflectII],
|
|
Item::RechargeI => vec![Item::Block, Item::Red, Item::Blue],
|
|
Item::RechargeII => vec![Item::RechargeI, Item::RechargeI, Item::RechargeI],
|
|
Item::RechargeIII => vec![Item::RechargeII, Item::RechargeII, Item::RechargeII],
|
|
|
|
Item::BashI => vec![Item::Stun, Item::Red, Item::Red],
|
|
Item::BashII => vec![Item::BashI, Item::BashI, Item::BashI],
|
|
Item::BashIII => vec![Item::BashII, Item::BashII, Item::BashII],
|
|
Item::SleepI => vec![Item::Stun, Item::Green, Item::Green],
|
|
Item::SleepII => vec![Item::SleepI, Item::SleepI, Item::SleepI],
|
|
Item::SleepIII => vec![Item::SleepII, Item::SleepII, Item::SleepII],
|
|
Item::RuinI => vec![Item::Stun, Item::Blue, Item::Blue],
|
|
Item::RuinII => vec![Item::RuinI, Item::RuinI, Item::RuinI],
|
|
Item::RuinIII => vec![Item::RuinII, Item::RuinII, Item::RuinII],
|
|
Item::ThrowI => vec![Item::Stun, Item::Red, Item::Green],
|
|
Item::ThrowII => vec![Item::ThrowI, Item::ThrowI, Item::ThrowI],
|
|
Item::ThrowIII => vec![Item::ThrowII, Item::ThrowII, Item::ThrowII],
|
|
Item::HexI => vec![Item::Stun, Item::Green, Item::Blue],
|
|
Item::HexII => vec![Item::HexI, Item::HexI, Item::HexI],
|
|
Item::HexIII => vec![Item::HexII, Item::HexII, Item::HexII],
|
|
Item::BanishI => vec![Item::Stun, Item::Red, Item::Blue],
|
|
Item::BanishII => vec![Item::BanishI, Item::BanishI, Item::BanishI],
|
|
Item::BanishIII => vec![Item::BanishII, Item::BanishII, Item::BanishII],
|
|
|
|
Item::StrikeI => vec![Item::Attack, Item::Red, Item::Red],
|
|
Item::StrikeII => vec![Item::StrikeI, Item::StrikeI, Item::StrikeI],
|
|
Item::StrikeIII => vec![Item::StrikeII, Item::StrikeII, Item::StrikeII],
|
|
Item::HealI => vec![Item::Attack, Item::Green, Item::Green],
|
|
Item::HealII => vec![Item::HealI, Item::HealI, Item::HealI],
|
|
Item::HealIII => vec![Item::HealII, Item::HealII, Item::HealII],
|
|
Item::BlastI => vec![Item::Attack, Item::Blue, Item::Blue],
|
|
Item::BlastII => vec![Item::BlastI, Item::BlastI, Item::BlastI],
|
|
Item::BlastIII => vec![Item::BlastII, Item::BlastII, Item::BlastII],
|
|
Item::SlayI => vec![Item::Attack, Item::Red, Item::Green],
|
|
Item::SlayII => vec![Item::SlayI, Item::SlayI, Item::SlayI],
|
|
Item::SlayIII => vec![Item::SlayII, Item::SlayII, Item::SlayII],
|
|
Item::SiphonI => vec![Item::Attack, Item::Green, Item::Blue],
|
|
Item::SiphonII => vec![Item::SiphonI, Item::SiphonI, Item::SiphonI],
|
|
Item::SiphonIII => vec![Item::SiphonII, Item::SiphonII, Item::SiphonII],
|
|
Item::ChaosI => vec![Item::Attack, Item::Red, Item::Blue],
|
|
Item::ChaosII => vec![Item::ChaosI, Item::ChaosI, Item::ChaosI],
|
|
Item::ChaosIII => vec![Item::ChaosII, Item::ChaosII, Item::ChaosII],
|
|
|
|
Item::PowerRRI => vec![Item::Power, Item::Red, Item::Red],
|
|
Item::PowerGGI => vec![Item::Power, Item::Green, Item::Green],
|
|
Item::PowerBBI => vec![Item::Power, Item::Blue, Item::Blue],
|
|
Item::PowerRGI => vec![Item::Power, Item::Red, Item::Green],
|
|
Item::PowerGBI => vec![Item::Power, Item::Green, Item::Blue],
|
|
Item::PowerRBI => vec![Item::Power, Item::Red, Item::Blue],
|
|
Item::PowerRRII => vec![Item::PowerRRI, Item::PowerRRI, Item::PowerRRI],
|
|
Item::PowerGGII => vec![Item::PowerGGI, Item::PowerGGI, Item::PowerGGI],
|
|
Item::PowerBBII => vec![Item::PowerBBI, Item::PowerBBI, Item::PowerBBI],
|
|
Item::PowerRGII => vec![Item::PowerRGI, Item::PowerRGI, Item::PowerRGI],
|
|
Item::PowerGBII => vec![Item::PowerGBI, Item::PowerGBI, Item::PowerGBI],
|
|
Item::PowerRBII => vec![Item::PowerRBI, Item::PowerRBI, Item::PowerRBI],
|
|
Item::PowerRRIII => vec![Item::PowerRRII, Item::PowerRRII, Item::PowerRRII],
|
|
Item::PowerGGIII => vec![Item::PowerGGII, Item::PowerGGII, Item::PowerGGII],
|
|
Item::PowerBBIII => vec![Item::PowerBBII, Item::PowerBBII, Item::PowerBBII],
|
|
Item::PowerRGIII => vec![Item::PowerRGII, Item::PowerRGII, Item::PowerRGII],
|
|
Item::PowerGBIII => vec![Item::PowerGBII, Item::PowerGBII, Item::PowerGBII],
|
|
Item::PowerRBIII => vec![Item::PowerRBII, Item::PowerRBII, Item::PowerRBII],
|
|
|
|
Item::LifeRRI => vec![Item::Life, Item::Red, Item::Red],
|
|
Item::LifeGGI => vec![Item::Life, Item::Green, Item::Green],
|
|
Item::LifeBBI => vec![Item::Life, Item::Blue, Item::Blue],
|
|
Item::LifeRGI => vec![Item::Life, Item::Red, Item::Green],
|
|
Item::LifeGBI => vec![Item::Life, Item::Green, Item::Blue],
|
|
Item::LifeRBI => vec![Item::Life, Item::Red, Item::Blue],
|
|
Item::LifeRRII => vec![Item::LifeRRI, Item::LifeRRI, Item::LifeRRI],
|
|
Item::LifeGGII => vec![Item::LifeGGI, Item::LifeGGI, Item::LifeGGI],
|
|
Item::LifeBBII => vec![Item::LifeBBI, Item::LifeBBI, Item::LifeBBI],
|
|
Item::LifeRGII => vec![Item::LifeRGI, Item::LifeRGI, Item::LifeRGI],
|
|
Item::LifeGBII => vec![Item::LifeGBI, Item::LifeGBI, Item::LifeGBI],
|
|
Item::LifeRBII => vec![Item::LifeRBI, Item::LifeRBI, Item::LifeRBI],
|
|
Item::LifeRRIII => vec![Item::LifeRRII, Item::LifeRRII, Item::LifeRRII],
|
|
Item::LifeGGIII => vec![Item::LifeGGII, Item::LifeGGII, Item::LifeGGII],
|
|
Item::LifeBBIII => vec![Item::LifeBBII, Item::LifeBBII, Item::LifeBBII],
|
|
Item::LifeRGIII => vec![Item::LifeRGII, Item::LifeRGII, Item::LifeRGII],
|
|
Item::LifeGBIII => vec![Item::LifeGBII, Item::LifeGBII, Item::LifeGBII],
|
|
Item::LifeRBIII => vec![Item::LifeRBII, Item::LifeRBII, Item::LifeRBII],
|
|
|
|
|
|
|
|
Item::SpeedRRI => vec![Item::Speed, Item::Red, Item::Red],
|
|
Item::SpeedGGI => vec![Item::Speed, Item::Green, Item::Green],
|
|
Item::SpeedBBI => vec![Item::Speed, Item::Blue, Item::Blue],
|
|
Item::SpeedRGI => vec![Item::Speed, Item::Red, Item::Green],
|
|
Item::SpeedGBI => vec![Item::Speed, Item::Green, Item::Blue],
|
|
Item::SpeedRBI => vec![Item::Speed, Item::Red, Item::Blue],
|
|
|
|
Item::SpeedRRII => vec![Item::SpeedRRI, Item::SpeedRRI, Item::SpeedRRI],
|
|
Item::SpeedGGII => vec![Item::SpeedGGI, Item::SpeedGGI, Item::SpeedGGI],
|
|
Item::SpeedBBII => vec![Item::SpeedBBI, Item::SpeedBBI, Item::SpeedBBI],
|
|
Item::SpeedRGII => vec![Item::SpeedRGI, Item::SpeedRGI, Item::SpeedRGI],
|
|
Item::SpeedGBII => vec![Item::SpeedGBI, Item::SpeedGBI, Item::SpeedGBI],
|
|
Item::SpeedRBII => vec![Item::SpeedRBI, Item::SpeedRBI, Item::SpeedRBI],
|
|
|
|
Item::SpeedRRIII => vec![Item::SpeedRRII, Item::SpeedRRII, Item::SpeedRRII],
|
|
Item::SpeedGGIII => vec![Item::SpeedGGII, Item::SpeedGGII, Item::SpeedGGII],
|
|
Item::SpeedBBIII => vec![Item::SpeedBBII, Item::SpeedBBII, Item::SpeedBBII],
|
|
Item::SpeedRGIII => vec![Item::SpeedRGII, Item::SpeedRGII, Item::SpeedRGII],
|
|
Item::SpeedGBIII => vec![Item::SpeedGBII, Item::SpeedGBII, Item::SpeedGBII],
|
|
Item::SpeedRBIII => vec![Item::SpeedRBII, Item::SpeedRBII, Item::SpeedRBII],
|
|
|
|
_ => vec![*self],
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<Skill> for Item {
|
|
fn from(skill: Skill) -> Item {
|
|
match skill {
|
|
Skill::AmplifyI => Item::AmplifyI,
|
|
Skill::AmplifyII => Item::AmplifyII,
|
|
Skill::AmplifyIII => Item::AmplifyIII,
|
|
Skill::Attack => Item::Attack,
|
|
Skill::BanishI => Item::BanishI,
|
|
Skill::BanishII => Item::BanishII,
|
|
Skill::BanishIII => Item::BanishIII,
|
|
Skill::BlastI => Item::BlastI,
|
|
Skill::BlastII => Item::BlastII,
|
|
Skill::BlastIII => Item::BlastIII,
|
|
Skill::Block => Item::Block,
|
|
Skill::Buff => Item::Buff,
|
|
Skill::ChaosI => Item::ChaosI,
|
|
Skill::ChaosII => Item::ChaosII,
|
|
Skill::ChaosIII => Item::ChaosIII,
|
|
Skill::ElectrifyI => Item::ElectrifyI,
|
|
Skill::ElectrifyII => Item::ElectrifyII,
|
|
Skill::ElectrifyIII => Item::ElectrifyIII,
|
|
Skill::ClutchI => Item::ClutchI,
|
|
Skill::ClutchII => Item::ClutchII,
|
|
Skill::ClutchIII => Item::ClutchIII,
|
|
Skill::CurseI => Item::CurseI,
|
|
Skill::CurseII => Item::CurseII,
|
|
Skill::CurseIII => Item::CurseIII,
|
|
Skill::DecayI => Item::DecayI,
|
|
Skill::DecayII => Item::DecayII,
|
|
Skill::DecayIII => Item::DecayIII,
|
|
Skill::Debuff => Item::Debuff,
|
|
Skill::HasteI => Item::HasteI,
|
|
Skill::HasteII => Item::HasteII,
|
|
Skill::HasteIII => Item::HasteIII,
|
|
Skill::HostilityI => Item::HostilityI,
|
|
Skill::HostilityII => Item::HostilityII,
|
|
Skill::HostilityIII => Item::HostilityIII,
|
|
Skill::HealI => Item::HealI,
|
|
Skill::HealII => Item::HealII,
|
|
Skill::HealIII => Item::HealIII,
|
|
Skill::HexI => Item::HexI,
|
|
Skill::HexII => Item::HexII,
|
|
Skill::HexIII => Item::HexIII,
|
|
Skill::HybridI => Item::HybridI,
|
|
Skill::HybridII => Item::HybridII,
|
|
Skill::HybridIII => Item::HybridIII,
|
|
Skill::InvertI => Item::InvertI,
|
|
Skill::InvertII => Item::InvertII,
|
|
Skill::InvertIII => Item::InvertIII,
|
|
Skill::CounterI => Item::CounterI,
|
|
Skill::CounterII => Item::CounterII,
|
|
Skill::CounterIII => Item::CounterIII,
|
|
Skill::PurgeI => Item::PurgeI,
|
|
Skill::PurgeII => Item::PurgeII,
|
|
Skill::PurgeIII => Item::PurgeIII,
|
|
Skill::PurifyI => Item::PurifyI,
|
|
Skill::PurifyII => Item::PurifyII,
|
|
Skill::PurifyIII => Item::PurifyIII,
|
|
Skill::RechargeI => Item::RechargeI,
|
|
Skill::RechargeII => Item::RechargeII,
|
|
Skill::RechargeIII => Item::RechargeIII,
|
|
Skill::ReflectI => Item::ReflectI,
|
|
Skill::ReflectII => Item::ReflectII,
|
|
Skill::ReflectIII => Item::ReflectIII,
|
|
Skill::RuinI => Item::RuinI,
|
|
Skill::RuinII => Item::RuinII,
|
|
Skill::RuinIII => Item::RuinIII,
|
|
Skill::ScatterI => Item::ScatterI,
|
|
Skill::ScatterII => Item::ScatterII,
|
|
Skill::ScatterIII => Item::ScatterIII,
|
|
Skill::SilenceI => Item::SilenceI,
|
|
Skill::SilenceII => Item::SilenceII,
|
|
Skill::SilenceIII => Item::SilenceIII,
|
|
Skill::SiphonI => Item::SiphonI,
|
|
Skill::SiphonII => Item::SiphonII,
|
|
Skill::SiphonIII => Item::SiphonIII,
|
|
Skill::SlayI => Item::SlayI,
|
|
Skill::SlayII => Item::SlayII,
|
|
Skill::SlayIII => Item::SlayIII,
|
|
Skill::SleepI => Item::SleepI,
|
|
Skill::SleepII => Item::SleepII,
|
|
Skill::SleepIII => Item::SleepIII,
|
|
Skill::RestrictI => Item::RestrictI,
|
|
Skill::RestrictII => Item::RestrictII,
|
|
Skill::RestrictIII => Item::RestrictIII,
|
|
Skill::BashI => Item::BashI,
|
|
Skill::BashII => Item::BashII,
|
|
Skill::BashIII => Item::BashIII,
|
|
Skill::StrikeI => Item::StrikeI,
|
|
Skill::StrikeII => Item::StrikeII,
|
|
Skill::StrikeIII => Item::StrikeIII,
|
|
Skill::Stun => Item::Stun,
|
|
Skill::InterceptI => Item::InterceptI,
|
|
Skill::InterceptII => Item::InterceptII,
|
|
Skill::InterceptIII => Item::InterceptIII,
|
|
Skill::ThrowI => Item::ThrowI,
|
|
Skill::ThrowII => Item::ThrowII,
|
|
Skill::ThrowIII => Item::ThrowIII,
|
|
Skill::TriageI => Item::TriageI,
|
|
Skill::TriageII => Item::TriageII,
|
|
Skill::TriageIII => Item::TriageIII,
|
|
|
|
// Convert subskills into parent skills
|
|
Skill::ElectrocuteI => Item::ElectrifyI,
|
|
Skill::ElectrocuteII => Item::ElectrifyII,
|
|
Skill::ElectrocuteIII => Item::ElectrifyIII,
|
|
Skill::ElectrocuteTickI => Item::ElectrifyI,
|
|
Skill::ElectrocuteTickII => Item::ElectrifyII,
|
|
Skill::ElectrocuteTickIII => Item::ElectrifyII,
|
|
Skill::DecayTickI => Item::DecayI,
|
|
Skill::DecayTickII => Item::DecayII,
|
|
Skill::DecayTickIII => Item::DecayIII,
|
|
Skill::HatredI => Item::HostilityI,
|
|
Skill::HatredII => Item::HostilityII,
|
|
Skill::HatredIII => Item::HostilityIII,
|
|
Skill::HasteStrike => Item::HasteI,
|
|
Skill::HybridBlast => Item::HybridI,
|
|
Skill::CounterAttackI => Item::CounterI,
|
|
Skill::CounterAttackII => Item::CounterII,
|
|
Skill::CounterAttackIII => Item::CounterIII,
|
|
Skill::SiphonTickI => Item::SiphonI,
|
|
Skill::SiphonTickII => Item::SiphonII,
|
|
Skill::SiphonTickIII => Item::SiphonIII,
|
|
Skill::TriageTickI => Item::TriageI,
|
|
Skill::TriageTickII => Item::TriageII,
|
|
Skill::TriageTickIII => Item::TriageIII,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<Spec> for Item {
|
|
fn from(spec: Spec) -> Item {
|
|
match spec {
|
|
Spec::Speed => Item::Speed,
|
|
Spec::SpeedRRI => Item::SpeedRRI,
|
|
Spec::SpeedBBI => Item::SpeedBBI,
|
|
Spec::SpeedGGI => Item::SpeedGGI,
|
|
Spec::SpeedRGI => Item::SpeedRGI,
|
|
Spec::SpeedGBI => Item::SpeedGBI,
|
|
Spec::SpeedRBI => Item::SpeedRBI,
|
|
|
|
Spec::SpeedRRII => Item::SpeedRRII,
|
|
Spec::SpeedBBII => Item::SpeedBBII,
|
|
Spec::SpeedGGII => Item::SpeedGGII,
|
|
Spec::SpeedRGII => Item::SpeedRGII,
|
|
Spec::SpeedGBII => Item::SpeedGBII,
|
|
Spec::SpeedRBII => Item::SpeedRBII,
|
|
|
|
Spec::SpeedRRIII => Item::SpeedRRIII,
|
|
Spec::SpeedBBIII => Item::SpeedBBIII,
|
|
Spec::SpeedGGIII => Item::SpeedGGIII,
|
|
Spec::SpeedRGIII => Item::SpeedRGIII,
|
|
Spec::SpeedGBIII => Item::SpeedGBIII,
|
|
Spec::SpeedRBIII => Item::SpeedRBIII,
|
|
|
|
Spec::Power => Item::Power,
|
|
Spec::PowerRRI => Item::PowerRRI,
|
|
Spec::PowerBBI => Item::PowerBBI,
|
|
Spec::PowerGGI => Item::PowerGGI,
|
|
Spec::PowerRGI => Item::PowerRGI,
|
|
Spec::PowerGBI => Item::PowerGBI,
|
|
Spec::PowerRBI => Item::PowerRBI,
|
|
Spec::PowerRRII => Item::PowerRRII,
|
|
Spec::PowerBBII => Item::PowerBBII,
|
|
Spec::PowerGGII => Item::PowerGGII,
|
|
Spec::PowerRGII => Item::PowerRGII,
|
|
Spec::PowerGBII => Item::PowerGBII,
|
|
Spec::PowerRBII => Item::PowerRBII,
|
|
Spec::PowerRRIII => Item::PowerRRIII,
|
|
Spec::PowerBBIII => Item::PowerBBIII,
|
|
Spec::PowerGGIII => Item::PowerGGIII,
|
|
Spec::PowerRGIII => Item::PowerRGIII,
|
|
Spec::PowerGBIII => Item::PowerGBIII,
|
|
Spec::PowerRBIII => Item::PowerRBIII,
|
|
|
|
Spec::Life => Item::Life,
|
|
Spec::LifeRGI => Item::LifeRGI,
|
|
Spec::LifeGBI => Item::LifeGBI,
|
|
Spec::LifeRBI => Item::LifeRBI,
|
|
Spec::LifeGGI => Item::LifeGGI,
|
|
Spec::LifeRRI => Item::LifeRRI,
|
|
Spec::LifeBBI => Item::LifeBBI,
|
|
Spec::LifeRGII => Item::LifeRGII,
|
|
Spec::LifeGBII => Item::LifeGBII,
|
|
Spec::LifeRBII => Item::LifeRBII,
|
|
Spec::LifeGGII => Item::LifeGGII,
|
|
Spec::LifeRRII => Item::LifeRRII,
|
|
Spec::LifeBBII => Item::LifeBBII,
|
|
Spec::LifeRGIII => Item::LifeRGIII,
|
|
Spec::LifeGBIII => Item::LifeGBIII,
|
|
Spec::LifeRBIII => Item::LifeRBIII,
|
|
Spec::LifeGGIII => Item::LifeGGIII,
|
|
Spec::LifeRRIII => Item::LifeRRIII,
|
|
Spec::LifeBBIII => Item::LifeBBIII,
|
|
|
|
// _ => panic!("{:?} not implemented as a item", spec),
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
#[derive(Debug,Clone,Serialize,Deserialize)]
|
|
pub struct Combo {
|
|
pub item: Item,
|
|
pub components: Vec<Item>,
|
|
}
|
|
|
|
pub fn get_combos() -> Vec<Combo> {
|
|
let mut combinations = vec![
|
|
Combo { components: Item::InterceptI.combo(), item: Item::InterceptI },
|
|
Combo { components: Item::InterceptII.combo(), item: Item::InterceptII },
|
|
Combo { components: Item::InterceptIII.combo(), item: Item::InterceptIII },
|
|
|
|
Combo { components: Item::TriageI.combo(), item: Item::TriageI },
|
|
Combo { components: Item::TriageII.combo(), item: Item::TriageII },
|
|
Combo { components: Item::TriageIII.combo(), item: Item::TriageIII },
|
|
|
|
Combo { components: Item::ScatterI.combo(), item: Item::ScatterI },
|
|
Combo { components: Item::ScatterII.combo(), item: Item::ScatterII },
|
|
Combo { components: Item::ScatterIII.combo(), item: Item::ScatterIII },
|
|
|
|
Combo { components: Item::HasteI.combo(), item: Item::HasteI },
|
|
Combo { components: Item::HasteII.combo(), item: Item::HasteII },
|
|
Combo { components: Item::HasteIII.combo(), item: Item::HasteIII },
|
|
Combo { components: Item::HostilityI.combo(), item: Item::HostilityI },
|
|
Combo { components: Item::HostilityII.combo(), item: Item::HostilityII },
|
|
Combo { components: Item::HostilityIII.combo(), item: Item::HostilityIII },
|
|
Combo { components: Item::HybridI.combo(), item: Item::HybridI },
|
|
Combo { components: Item::HybridII.combo(), item: Item::HybridII },
|
|
Combo { components: Item::HybridIII.combo(), item: Item::HybridIII },
|
|
|
|
Combo { components: Item::AmplifyI.combo(), item: Item::AmplifyI },
|
|
Combo { components: Item::AmplifyII.combo(), item: Item::AmplifyII },
|
|
Combo { components: Item::AmplifyIII.combo(), item: Item::AmplifyIII },
|
|
|
|
Combo { components: Item::RestrictI.combo(), item: Item::RestrictI },
|
|
Combo { components: Item::RestrictII.combo(), item: Item::RestrictII },
|
|
Combo { components: Item::RestrictIII.combo(), item: Item::RestrictIII },
|
|
Combo { components: Item::PurgeI.combo(), item: Item::PurgeI }, // Needs flavour
|
|
Combo { components: Item::PurgeII.combo(), item: Item::PurgeII },
|
|
Combo { components: Item::PurgeIII.combo(), item: Item::PurgeIII },
|
|
|
|
Combo { components: Item::SilenceI.combo(), item: Item::SilenceI },
|
|
Combo { components: Item::SilenceII.combo(), item: Item::SilenceII },
|
|
Combo { components: Item::SilenceIII.combo(), item: Item::SilenceIII },
|
|
|
|
|
|
Combo { components: Item::CurseI.combo(), item: Item::CurseI },
|
|
Combo { components: Item::CurseII.combo(), item: Item::CurseII },
|
|
Combo { components: Item::CurseIII.combo(), item: Item::CurseIII },
|
|
Combo { components: Item::DecayI.combo(), item: Item::DecayI },
|
|
Combo { components: Item::DecayII.combo(), item: Item::DecayII },
|
|
Combo { components: Item::DecayIII.combo(), item: Item::DecayIII },
|
|
Combo { components: Item::InvertI.combo(), item: Item::InvertI },
|
|
Combo { components: Item::InvertII.combo(), item: Item::InvertII },
|
|
Combo { components: Item::InvertIII.combo(), item: Item::InvertIII },
|
|
|
|
Combo { components: Item::CounterI.combo(), item: Item::CounterI },
|
|
Combo { components: Item::CounterII.combo(), item: Item::CounterII },
|
|
Combo { components: Item::CounterIII.combo(), item: Item::CounterIII },
|
|
Combo { components: Item::PurifyI.combo(), item: Item::PurifyI },
|
|
Combo { components: Item::PurifyII.combo(), item: Item::PurifyII },
|
|
Combo { components: Item::PurifyIII.combo(), item: Item::PurifyIII },
|
|
|
|
Combo { components: Item::ElectrifyI.combo(), item: Item::ElectrifyI },
|
|
Combo { components: Item::ElectrifyII.combo(), item: Item::ElectrifyII },
|
|
Combo { components: Item::ElectrifyIII.combo(), item: Item::ElectrifyIII },
|
|
|
|
Combo { components: Item::ClutchI.combo(), item: Item::ClutchI },
|
|
Combo { components: Item::ClutchII.combo(), item: Item::ClutchII },
|
|
Combo { components: Item::ClutchIII.combo(), item: Item::ClutchIII },
|
|
Combo { components: Item::ReflectI.combo(), item: Item::ReflectI },
|
|
Combo { components: Item::ReflectII.combo(), item: Item::ReflectII },
|
|
Combo { components: Item::ReflectIII.combo(), item: Item::ReflectIII },
|
|
|
|
|
|
Combo { components: Item::RechargeI.combo(), item: Item::RechargeI },
|
|
Combo { components: Item::RechargeII.combo(), item: Item::RechargeII },
|
|
Combo { components: Item::RechargeIII.combo(), item: Item::RechargeIII },
|
|
|
|
Combo { components: Item::BashI.combo(), item: Item::BashI },
|
|
Combo { components: Item::BashII.combo(), item: Item::BashII },
|
|
Combo { components: Item::BashIII.combo(), item: Item::BashIII },
|
|
Combo { components: Item::SleepI.combo(), item: Item::SleepI },
|
|
Combo { components: Item::SleepII.combo(), item: Item::SleepII },
|
|
Combo { components: Item::SleepIII.combo(), item: Item::SleepIII },
|
|
Combo { components: Item::RuinI.combo(), item: Item::RuinI },
|
|
Combo { components: Item::RuinII.combo(), item: Item::RuinII },
|
|
Combo { components: Item::RuinIII.combo(), item: Item::RuinIII },
|
|
|
|
Combo { components: Item::ThrowI.combo(), item: Item::ThrowI },
|
|
Combo { components: Item::ThrowII.combo(), item: Item::ThrowII },
|
|
Combo { components: Item::ThrowIII.combo(), item: Item::ThrowIII },
|
|
Combo { components: Item::HexI.combo(), item: Item::HexI },
|
|
Combo { components: Item::HexII.combo(), item: Item::HexII },
|
|
Combo { components: Item::HexIII.combo(), item: Item::HexIII },
|
|
Combo { components: Item::BanishI.combo(), item: Item::BanishI },
|
|
Combo { components: Item::BanishII.combo(), item: Item::BanishII },
|
|
Combo { components: Item::BanishIII.combo(), item: Item::BanishIII },
|
|
|
|
Combo { components: Item::StrikeI.combo(), item: Item::StrikeI },
|
|
Combo { components: Item::StrikeII.combo(), item: Item::StrikeII },
|
|
Combo { components: Item::StrikeIII.combo(), item: Item::StrikeIII },
|
|
|
|
Combo { components: Item::HealI.combo(), item: Item::HealI },
|
|
Combo { components: Item::HealII.combo(), item: Item::HealII },
|
|
Combo { components: Item::HealIII.combo(), item: Item::HealIII },
|
|
Combo { components: Item::BlastI.combo(), item: Item::BlastI },
|
|
Combo { components: Item::BlastII.combo(), item: Item::BlastII },
|
|
Combo { components: Item::BlastIII.combo(), item: Item::BlastIII },
|
|
Combo { components: Item::SlayI.combo(), item: Item::SlayI },
|
|
Combo { components: Item::SlayII.combo(), item: Item::SlayII },
|
|
Combo { components: Item::SlayIII.combo(), item: Item::SlayIII },
|
|
Combo { components: Item::SiphonI.combo(), item: Item::SiphonI },
|
|
Combo { components: Item::SiphonII.combo(), item: Item::SiphonII },
|
|
Combo { components: Item::SiphonIII.combo(), item: Item::SiphonIII },
|
|
Combo { components: Item::ChaosI.combo(), item: Item::ChaosI },
|
|
Combo { components: Item::ChaosII.combo(), item: Item::ChaosII },
|
|
Combo { components: Item::ChaosIII.combo(), item: Item::ChaosIII },
|
|
|
|
Combo { components: Item::PowerRRI.combo(), item: Item::PowerRRI },
|
|
Combo { components: Item::PowerGGI.combo(), item: Item::PowerGGI },
|
|
Combo { components: Item::PowerBBI.combo(), item: Item::PowerBBI },
|
|
Combo { components: Item::PowerRGI.combo(), item: Item::PowerRGI },
|
|
Combo { components: Item::PowerGBI.combo(), item: Item::PowerGBI },
|
|
Combo { components: Item::PowerRBI.combo(), item: Item::PowerRBI },
|
|
Combo { components: Item::PowerRRII.combo(), item: Item::PowerRRII },
|
|
Combo { components: Item::PowerGGII.combo(), item: Item::PowerGGII },
|
|
Combo { components: Item::PowerBBII.combo(), item: Item::PowerBBII },
|
|
Combo { components: Item::PowerRGII.combo(), item: Item::PowerRGII },
|
|
Combo { components: Item::PowerGBII.combo(), item: Item::PowerGBII },
|
|
Combo { components: Item::PowerRBII.combo(), item: Item::PowerRBII },
|
|
Combo { components: Item::PowerRRIII.combo(), item: Item::PowerRRIII },
|
|
Combo { components: Item::PowerGGIII.combo(), item: Item::PowerGGIII },
|
|
Combo { components: Item::PowerBBIII.combo(), item: Item::PowerBBIII },
|
|
Combo { components: Item::PowerRGIII.combo(), item: Item::PowerRGIII },
|
|
Combo { components: Item::PowerGBIII.combo(), item: Item::PowerGBIII },
|
|
Combo { components: Item::PowerRBIII.combo(), item: Item::PowerRBIII },
|
|
|
|
Combo { components: Item::LifeRRI.combo(), item: Item::LifeRRI },
|
|
Combo { components: Item::LifeGGI.combo(), item: Item::LifeGGI },
|
|
Combo { components: Item::LifeBBI.combo(), item: Item::LifeBBI },
|
|
Combo { components: Item::LifeRGI.combo(), item: Item::LifeRGI },
|
|
Combo { components: Item::LifeGBI.combo(), item: Item::LifeGBI },
|
|
Combo { components: Item::LifeRBI.combo(), item: Item::LifeRBI },
|
|
Combo { components: Item::LifeRRII.combo(), item: Item::LifeRRII },
|
|
Combo { components: Item::LifeGGII.combo(), item: Item::LifeGGII },
|
|
Combo { components: Item::LifeBBII.combo(), item: Item::LifeBBII },
|
|
Combo { components: Item::LifeRGII.combo(), item: Item::LifeRGII },
|
|
Combo { components: Item::LifeGBII.combo(), item: Item::LifeGBII },
|
|
Combo { components: Item::LifeRBII.combo(), item: Item::LifeRBII },
|
|
Combo { components: Item::LifeRRIII.combo(), item: Item::LifeRRIII },
|
|
Combo { components: Item::LifeGGIII.combo(), item: Item::LifeGGIII },
|
|
Combo { components: Item::LifeBBIII.combo(), item: Item::LifeBBIII },
|
|
Combo { components: Item::LifeRGIII.combo(), item: Item::LifeRGIII },
|
|
Combo { components: Item::LifeGBIII.combo(), item: Item::LifeGBIII },
|
|
Combo { components: Item::LifeRBIII.combo(), item: Item::LifeRBIII },
|
|
|
|
Combo { components: Item::SpeedRRI.combo(), item: Item::SpeedRRI },
|
|
Combo { components: Item::SpeedGGI.combo(), item: Item::SpeedGGI },
|
|
Combo { components: Item::SpeedBBI.combo(), item: Item::SpeedBBI },
|
|
Combo { components: Item::SpeedRGI.combo(), item: Item::SpeedRGI },
|
|
Combo { components: Item::SpeedGBI.combo(), item: Item::SpeedGBI },
|
|
Combo { components: Item::SpeedRBI.combo(), item: Item::SpeedRBI },
|
|
Combo { components: Item::SpeedRRII.combo(), item: Item::SpeedRRII },
|
|
Combo { components: Item::SpeedGGII.combo(), item: Item::SpeedGGII },
|
|
Combo { components: Item::SpeedBBII.combo(), item: Item::SpeedBBII },
|
|
Combo { components: Item::SpeedRGII.combo(), item: Item::SpeedRGII },
|
|
Combo { components: Item::SpeedGBII.combo(), item: Item::SpeedGBII },
|
|
Combo { components: Item::SpeedRBII.combo(), item: Item::SpeedRBII },
|
|
Combo { components: Item::SpeedRRIII.combo(), item: Item::SpeedRRIII },
|
|
Combo { components: Item::SpeedGGIII.combo(), item: Item::SpeedGGIII },
|
|
Combo { components: Item::SpeedBBIII.combo(), item: Item::SpeedBBIII },
|
|
Combo { components: Item::SpeedRGIII.combo(), item: Item::SpeedRGIII },
|
|
Combo { components: Item::SpeedGBIII.combo(), item: Item::SpeedGBIII },
|
|
Combo { components: Item::SpeedRBIII.combo(), item: Item::SpeedRBIII },
|
|
];
|
|
|
|
combinations.iter_mut().for_each(|set| set.components.sort_unstable());
|
|
|
|
return combinations;
|
|
}
|
|
|
|
#[derive(Debug,Clone,Serialize,Deserialize)]
|
|
pub struct ItemInfo {
|
|
pub item: Item,
|
|
pub spec: bool,
|
|
pub skill: bool,
|
|
pub values: Option<SpecValues>,
|
|
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.components.push(c.item);
|
|
c.components
|
|
})
|
|
.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(),
|
|
values: match v.into_spec() {
|
|
Some(s) => Some(s.values()),
|
|
None => None
|
|
},
|
|
})
|
|
.collect::<Vec<ItemInfo>>();
|
|
|
|
let combos = get_combos();
|
|
|
|
return ItemInfoCtr {
|
|
combos,
|
|
items,
|
|
};
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn item_components_test() {
|
|
assert_eq!(Item::StrikeI.components(), vec![Item::Red, Item::Red, Item::Attack]);
|
|
assert_eq!(Item::StrikeII.components(), vec![
|
|
Item::Red, Item::Red, Item::Attack,
|
|
Item::Red, Item::Red, Item::Attack,
|
|
Item::Red, Item::Red, Item::Attack,
|
|
]);
|
|
assert_eq!(Item::StrikeIII.components(), vec![
|
|
Item::Red, Item::Red, Item::Attack,
|
|
Item::Red, Item::Red, Item::Attack,
|
|
Item::Red, Item::Red, Item::Attack,
|
|
|
|
Item::Red, Item::Red, Item::Attack,
|
|
Item::Red, Item::Red, Item::Attack,
|
|
Item::Red, Item::Red, Item::Attack,
|
|
|
|
Item::Red, Item::Red, Item::Attack,
|
|
Item::Red, Item::Red, Item::Attack,
|
|
Item::Red, Item::Red, Item::Attack,
|
|
]);
|
|
|
|
}
|
|
|
|
#[test]
|
|
fn item_info_test() {
|
|
item_info();
|
|
}
|
|
} |