966 lines
43 KiB
Rust
966 lines
43 KiB
Rust
use skill::{Skill, Colour};
|
|
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,
|
|
|
|
AmplifyI,
|
|
AmplifyII,
|
|
AmplifyIII,
|
|
Banish,
|
|
BlastI,
|
|
BlastII,
|
|
BlastIII,
|
|
ChaosI,
|
|
ChaosII,
|
|
ChaosIII,
|
|
ClutchI,
|
|
ClutchII,
|
|
ClutchIII,
|
|
Corrupt,
|
|
CurseI,
|
|
CurseII,
|
|
CurseIII,
|
|
Decay,
|
|
Hostility,
|
|
Haste,
|
|
HealI,
|
|
HealII,
|
|
HealIII,
|
|
HexI,
|
|
HexII,
|
|
HexIII,
|
|
Impurity,
|
|
InvertI,
|
|
InvertII,
|
|
InvertIII,
|
|
Parry,
|
|
PurgeI,
|
|
PurgeII,
|
|
PurgeIII,
|
|
PurifyI,
|
|
PurifyII,
|
|
PurifyIII,
|
|
ReflectI,
|
|
ReflectII,
|
|
ReflectIII,
|
|
RechargeI,
|
|
RechargeII,
|
|
RechargeIII,
|
|
RuinI,
|
|
RuinII,
|
|
RuinIII,
|
|
ScatterI,
|
|
ScatterII,
|
|
ScatterIII,
|
|
SilenceI,
|
|
SilenceII,
|
|
SilenceIII,
|
|
Slay,
|
|
Sleep,
|
|
Snare,
|
|
Strangle,
|
|
StrikeI,
|
|
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.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::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.components.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.components.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::AmplifyI => Some(Skill::AmplifyI),
|
|
Item::AmplifyII => Some(Skill::AmplifyII),
|
|
Item::AmplifyIII => Some(Skill::AmplifyIII),
|
|
Item::Banish => Some(Skill::Banish),
|
|
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::Decay => Some(Skill::Decay),
|
|
Item::Haste => Some(Skill::Haste),
|
|
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::Hostility => Some(Skill::Hostility),
|
|
Item::Impurity => Some(Skill::Impurity),
|
|
Item::InvertI => Some(Skill::InvertI),
|
|
Item::InvertII => Some(Skill::InvertII),
|
|
Item::InvertIII => Some(Skill::InvertIII),
|
|
Item::Parry => Some(Skill::Parry),
|
|
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::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::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::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_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 red damage based on {:?}% red power",
|
|
self.into_skill().unwrap().multiplier()),
|
|
Item::Block => format!("Reduce incoming red damage by {:?}%",
|
|
100 - self.into_skill().unwrap().effect().first().unwrap().get_multiplier()),
|
|
|
|
|
|
Item::Stun => format!("Stun target cryp for {:?}T",
|
|
self.into_skill().unwrap().effect().first().unwrap().get_duration()),
|
|
Item::Buff => format!("Increase target cryp red damage and speed by {:?}%",
|
|
self.into_skill().unwrap().effect().first().unwrap().get_multiplier() - 100),
|
|
Item::Debuff => format!("Slow target cryp speed by {:?}%",
|
|
100 - self.into_skill().unwrap().effect().first().unwrap().get_multiplier()),
|
|
// specs
|
|
// Base
|
|
Item::Damage => format!("Base ITEM for increased DAMAGE. DAMAGE determines the power of your SKILLS."),
|
|
Item::Life => format!("Base ITEM for increased LIFE.
|
|
When your CRYP 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."),
|
|
|
|
// Lifes Upgrades
|
|
Item::GreenLifeI => format!("Increases CRYP GreenLife.
|
|
When your CRYP reaches 0 GreenLife it becomes KO and cannot cast SKILLS."),
|
|
Item::RedLifeI => format!("Increases CRYP RedLife.
|
|
Red damage dealt to your cryp reduces RedLife before GreenLife."),
|
|
Item::BlueLifeI => format!("Increases CRYP BlueLife.
|
|
Blue damage dealt to your cryp reduces BlueLife before GreenLife."),
|
|
Item::GRLI => format!("Increases CRYP GreenLife + RedLife"),
|
|
Item::GBLI => format!("Increases CRYP GreenLife + BlueLife"),
|
|
Item::RBLI => format!("Increases CRYP RedLife + BlueLife"),
|
|
|
|
// Damage Upgrades
|
|
Item::RedDamageI => format!("Increases CRYP RedDamage."),
|
|
Item::BlueDamageI => format!("Increases CRYP BlueDamage."),
|
|
Item::GreenDamageI => format!("Increases CRYP GreenDamage."),
|
|
Item::GRDI => format!("Increases CRYP GreenDamage + RedDamage."),
|
|
Item::GBDI => format!("Increases CRYP GreenDamage + BlueDamage."),
|
|
Item::RBDI => format!("Increases CRYP RedDamage + BlueDamage."),
|
|
|
|
// Speed Upgrades
|
|
Item::RedSpeedI => format!("Increases CRYP SPEED and provides COLOUR BONUSES"),
|
|
Item::BlueSpeedI => format!("Increases CRYP SPEED and provides COLOUR BONUSES"),
|
|
Item::GreenSpeedI => format!("Increases CRYP SPEED and provides COLOUR BONUSES"),
|
|
Item::GRSpeedI => format!("Increases CRYP SPEED and provides COLOUR BONUSES"),
|
|
Item::GBSpeedI => format!("Increases CRYP SPEED and provides COLOUR BONUSES"),
|
|
Item::RBSpeedI => format!("Increases CRYP 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().first().unwrap().get_multiplier() - 100,
|
|
self.into_skill().unwrap().effect().first().unwrap().get_duration()),
|
|
|
|
Item::Banish => format!("Banish target for {:?}T.
|
|
Banished cryps are immune to all skills and effects.",
|
|
self.into_skill().unwrap().effect().first().unwrap().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 is random 0 to 30% + {:?}% red and blue power.",
|
|
self.into_skill().unwrap().multiplier()),
|
|
|
|
Item::ClutchI |
|
|
Item::ClutchII |
|
|
Item::ClutchIII => format!("Cryp cannot be KO'd while active.
|
|
Additionally provides immunity to disables."),
|
|
|
|
Item::Corrupt => format!(
|
|
"Self targetting defensive for {:?}T. Applies corrupt to attackers dealing blue damage {:?}% blue power per turn for {:?}T.",
|
|
self.into_skill().unwrap().effect().first().unwrap().get_duration(),
|
|
Skill::Corrupt.multiplier(),
|
|
self.into_skill().unwrap().effect().last().unwrap().get_duration()),
|
|
|
|
|
|
Item::CurseI |
|
|
Item::CurseII |
|
|
Item::CurseIII => format!(
|
|
"Increases red and blue damage taken by {:?}%. Lasts {:?}T",
|
|
self.into_skill().unwrap().effect().first().unwrap().get_multiplier() - 100,
|
|
self.into_skill().unwrap().effect().first().unwrap().get_duration()),
|
|
|
|
Item::Decay => format!(
|
|
"Reduces healing taken by {:?}% and deals blue damage {:?}% blue power each turn. Lasts {:?}T",
|
|
100 - self.into_skill().unwrap().effect().first().unwrap().get_multiplier(),
|
|
self.into_skill().unwrap().multiplier(),
|
|
self.into_skill().unwrap().effect().first().unwrap().get_duration()),
|
|
|
|
Item::Hostility => format!(
|
|
"Gain Hostility for {:?}T. {} Hatred lasts {:?}T",
|
|
self.into_skill().unwrap().effect().first().unwrap().get_duration(),
|
|
"When attacked by Hostility you gain Hatred which increased red and blue power based on damage taken.",
|
|
self.into_skill().unwrap().effect().last().unwrap().get_duration()),
|
|
|
|
Item::Haste => format!(
|
|
"Haste increases Speed by {:?}%, Red based Attack skills will strike again dealing {:?}{}. Lasts {:?}T",
|
|
self.into_skill().unwrap().effect().first().unwrap().get_multiplier() - 100,
|
|
Skill::HasteStrike.multiplier(),
|
|
"% Speed as Red Damage",
|
|
self.into_skill().unwrap().effect().first().unwrap().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().first().unwrap().get_duration()),
|
|
|
|
|
|
Item::Impurity => format!(
|
|
"Impurity increases Green Power by {:?}%, Blue based Attack skills will blast again dealing {:?}{}. Lasts {:?}T",
|
|
self.into_skill().unwrap().effect().first().unwrap().get_multiplier() - 100,
|
|
Skill::ImpureBlast.multiplier(),
|
|
"% Green Power as Blue Damage",
|
|
self.into_skill().unwrap().effect().first().unwrap().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::Parry => 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().first().unwrap().get_duration(),
|
|
"If a red skill is parried the cryp will riposte the source dealing red damage",
|
|
Skill::Riposte.multiplier()),
|
|
|
|
Item::PurgeI |
|
|
Item::PurgeII |
|
|
Item::PurgeIII => format!("Remove buffs from target cryp"),
|
|
|
|
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 skills to source. Lasts {:?}T",
|
|
self.into_skill().unwrap().effect().first().unwrap().get_duration()),
|
|
Item::RechargeI |
|
|
Item::RechargeII |
|
|
Item::RechargeIII => format!(
|
|
"Recharge red and blue shield based on {:?} red and blue power",
|
|
self.into_skill().unwrap().multiplier()),
|
|
|
|
Item::RuinI |
|
|
Item::RuinII |
|
|
Item::RuinIII => format!(
|
|
"Team wide Stun for {:?}T. Stunned cryps are unable to cast skills.",
|
|
self.into_skill().unwrap().effect().first().unwrap().get_duration()),
|
|
|
|
Item::ScatterI |
|
|
Item::ScatterII |
|
|
Item::ScatterIII => format!(
|
|
"Caster links with target. Linked cryps split incoming damage evenly. Recharges target blue shield {:?}% of blue power",
|
|
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().first().unwrap().get_duration(),
|
|
self.into_skill().unwrap().multiplier(),
|
|
"Deals 45% more damage per blue skill on target"),
|
|
|
|
Item::Slay => format!(
|
|
"Deals red damage {:?}% red power and provides self healing based on damage dealt.",
|
|
self.into_skill().unwrap().multiplier()),
|
|
|
|
Item::Sleep => format!(
|
|
"Stun for {:?}T and heal for {:?}% green power.",
|
|
self.into_skill().unwrap().effect().first().unwrap().get_duration(),
|
|
self.into_skill().unwrap().multiplier()),
|
|
|
|
Item::Snare => format!(
|
|
"Block the target from using red skills for {:?}T and deals red damage {:?}% red power. {}",
|
|
self.into_skill().unwrap().effect().first().unwrap().get_duration(),
|
|
self.into_skill().unwrap().multiplier(),
|
|
"Deals 35% more damage per red skill on target"),
|
|
|
|
Item::Strangle => format!(
|
|
"Strangle the target disabling skills from both the caster and the target.
|
|
While strangling deal red damage each turn {:?}% red power. Lasts {:?}T.",
|
|
self.into_skill().unwrap().multiplier(),
|
|
self.into_skill().unwrap().effect().first().unwrap().get_duration()),
|
|
|
|
Item::StrikeI |
|
|
Item::StrikeII |
|
|
Item::StrikeIII => format!(
|
|
"Hits at maximum speed dealing red damage {:?}% red power",
|
|
self.into_skill().unwrap().multiplier()),
|
|
|
|
Item::Siphon => format!(
|
|
"Deals blue damage {:?}% blue power each turn and heals caster based on damage dealt. Lasts {:?}T",
|
|
self.into_skill().unwrap().multiplier(),
|
|
self.into_skill().unwrap().effect().first().unwrap().get_duration()),
|
|
|
|
Item::Taunt => format!("{} {:?}T. Recharges RedLife for {:?} red power.",
|
|
"Taunt redirects skills against the team to target, lasts",
|
|
self.into_skill().unwrap().effect().first().unwrap().get_duration(),
|
|
self.into_skill().unwrap().multiplier()),
|
|
|
|
Item::Throw => format!(
|
|
"Stun the target for {:?}T and applies Vulnerable increasing red damage taken by {:?}% for {:?}T",
|
|
self.into_skill().unwrap().effect().first().unwrap().get_duration(),
|
|
self.into_skill().unwrap().effect().first().unwrap().get_multiplier() - 100,
|
|
self.into_skill().unwrap().effect().last().unwrap().get_duration()),
|
|
|
|
Item::Triage => format!(
|
|
"Heals target for {:?}% green power each turn. Lasts {:?}T",
|
|
self.into_skill().unwrap().multiplier(),
|
|
self.into_skill().unwrap().effect().first().unwrap().get_duration()),
|
|
|
|
|
|
|
|
_ => format!("..."),
|
|
}
|
|
}
|
|
|
|
fn combo(&self) -> Vec<Item> {
|
|
match self {
|
|
Item::Taunt => vec![Item::Buff, Item::Red, Item::Red],
|
|
Item::Triage => vec![Item::Buff, Item::Green, Item::Green],
|
|
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::Haste => vec![Item::Buff, Item::Red, Item::Green],
|
|
Item::Impurity => vec![Item::Buff, Item::Green, Item::Blue],
|
|
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::Snare => vec![Item::Debuff, Item::Red, Item::Red],
|
|
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::Decay => vec![Item::Debuff, Item::Green, Item::Blue],
|
|
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::Parry => vec![Item::Block, Item::Red, Item::Red], // 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::Corrupt => vec![Item::Block, Item::Blue, Item::Blue],
|
|
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::Strangle => vec![Item::Stun, Item::Red, Item::Red],
|
|
Item::Sleep => vec![Item::Stun, Item::Green, Item::Green],
|
|
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::Throw => vec![Item::Stun, Item::Red, Item::Green],
|
|
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::Banish => vec![Item::Stun, Item::Red, Item::Blue],
|
|
|
|
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::Slay => vec![Item::Attack, Item::Red, Item::Green],
|
|
Item::Siphon => vec![Item::Attack, Item::Green, Item::Blue],
|
|
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::RedDamageI => vec![Item::Damage, Item::Red, Item::Red],
|
|
Item::GreenDamageI => vec![Item::Damage, Item::Green, Item::Green],
|
|
Item::BlueDamageI => vec![Item::Damage, Item::Blue, Item::Blue],
|
|
Item::GRDI => vec![Item::Damage, Item::Red, Item::Green],
|
|
Item::GBDI => vec![Item::Damage, Item::Green, Item::Blue],
|
|
Item::RBDI => vec![Item::Damage, Item::Red, Item::Blue],
|
|
|
|
Item::RedLifeI => vec![Item::Life, Item::Red, Item::Red],
|
|
Item::GreenLifeI => vec![Item::Life, Item::Green, Item::Green],
|
|
Item::BlueLifeI => vec![Item::Life, Item::Blue, Item::Blue],
|
|
Item::GRLI => vec![Item::Life, Item::Red, Item::Green],
|
|
Item::GBLI => vec![Item::Life, Item::Green, Item::Blue],
|
|
Item::RBLI => vec![Item::Life, Item::Red, Item::Blue],
|
|
|
|
Item::RedSpeedI => vec![Item::Speed, Item::Red, Item::Red],
|
|
Item::GreenSpeedI => vec![Item::Speed, Item::Green, Item::Green],
|
|
Item::BlueSpeedI => vec![Item::Speed, Item::Blue, Item::Blue],
|
|
Item::GRSpeedI => vec![Item::Speed, Item::Red, Item::Green],
|
|
Item::GBSpeedI => vec![Item::Speed, Item::Green, Item::Blue],
|
|
Item::RBSpeedI => vec![Item::Speed, Item::Red, Item::Blue],
|
|
|
|
_ => 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::Banish => Item::Banish,
|
|
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::ClutchI => Item::ClutchI,
|
|
Skill::ClutchII => Item::ClutchII,
|
|
Skill::ClutchIII => Item::ClutchIII,
|
|
Skill::CurseI => Item::CurseI,
|
|
Skill::CurseII => Item::CurseII,
|
|
Skill::CurseIII => Item::CurseIII,
|
|
Skill::Decay => Item::Decay,
|
|
Skill::Debuff => Item::Debuff,
|
|
Skill::Haste => Item::Haste,
|
|
Skill::Hostility => Item::Hostility,
|
|
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::Impurity => Item::Impurity,
|
|
Skill::InvertI => Item::InvertI,
|
|
Skill::InvertII => Item::InvertII,
|
|
Skill::InvertIII => Item::InvertIII,
|
|
Skill::Parry => Item::Parry,
|
|
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::Siphon => Item::Siphon,
|
|
Skill::Slay => Item::Slay,
|
|
Skill::Sleep => Item::Sleep,
|
|
Skill::Snare => Item::Snare,
|
|
Skill::Strangle => Item::Strangle,
|
|
Skill::StrikeI => Item::StrikeI,
|
|
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::CorruptionTick => Item::Corrupt,
|
|
Skill::DecayTick => Item::Decay,
|
|
Skill::SiphonTick => Item::Siphon,
|
|
Skill::StrangleTick => Item::Strangle,
|
|
Skill::TriageTick => Item::Triage,
|
|
|
|
Skill::TestTouch => Item::TestTouch,
|
|
Skill::TestStun => Item::TestStun,
|
|
Skill::TestBlock => Item::TestBlock,
|
|
Skill::TestParry => Item::TestParry,
|
|
Skill::TestSiphon => Item::TestSiphon,
|
|
_ => panic!("{:?} not implemented with item conversion", 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 components: Vec<Item>,
|
|
}
|
|
|
|
pub fn get_combos() -> Vec<Combo> {
|
|
let mut combinations = vec![
|
|
Combo { components: Item::Taunt.combo(), item: Item::Taunt },
|
|
Combo { components: Item::Triage.combo(), item: Item::Triage },
|
|
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::Haste.combo(), item: Item::Haste },
|
|
Combo { components: Item::Impurity.combo(), item: Item::Impurity },
|
|
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::Snare.combo(), item: Item::Snare },
|
|
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::Decay.combo(), item: Item::Decay },
|
|
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::Parry.combo(), item: Item::Parry }, // Add red recharge
|
|
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::Corrupt.combo(), item: Item::Corrupt },
|
|
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::Strangle.combo(), item: Item::Strangle },
|
|
Combo { components: Item::Sleep.combo(), item: Item::Sleep },
|
|
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::Throw.combo(), item: Item::Throw },
|
|
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::Banish.combo(), item: Item::Banish },
|
|
|
|
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::Slay.combo(), item: Item::Slay },
|
|
Combo { components: Item::Siphon.combo(), item: Item::Siphon },
|
|
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::RedDamageI.combo(), item: Item::RedDamageI },
|
|
Combo { components: Item::GreenDamageI.combo(), item: Item::GreenDamageI },
|
|
Combo { components: Item::BlueDamageI.combo(), item: Item::BlueDamageI },
|
|
Combo { components: Item::GRDI.combo(), item: Item::GRDI },
|
|
Combo { components: Item::GBDI.combo(), item: Item::GBDI },
|
|
Combo { components: Item::RBDI.combo(), item: Item::RBDI },
|
|
|
|
Combo { components: Item::RedLifeI.combo(), item: Item::RedLifeI },
|
|
Combo { components: Item::GreenLifeI.combo(), item: Item::GreenLifeI },
|
|
Combo { components: Item::BlueLifeI.combo(), item: Item::BlueLifeI },
|
|
Combo { components: Item::GRLI.combo(), item: Item::GRLI },
|
|
Combo { components: Item::GBLI.combo(), item: Item::GBLI },
|
|
Combo { components: Item::RBLI.combo(), item: Item::RBLI },
|
|
|
|
Combo { components: Item::RedSpeedI.combo(), item: Item::RedSpeedI },
|
|
Combo { components: Item::GreenSpeedI.combo(), item: Item::GreenSpeedI },
|
|
Combo { components: Item::BlueSpeedI.combo(), item: Item::BlueSpeedI },
|
|
Combo { components: Item::GRSpeedI.combo(), item: Item::GRSpeedI },
|
|
Combo { components: Item::GBSpeedI.combo(), item: Item::GBSpeedI },
|
|
Combo { components: Item::RBSpeedI.combo(), item: Item::RBSpeedI },
|
|
|
|
];
|
|
|
|
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 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(),
|
|
})
|
|
.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,
|
|
]);
|
|
|
|
}
|
|
} |