From cf3cef3f315424eb8beb4c77f228b6874065fcf9 Mon Sep 17 00:00:00 2001 From: ntr Date: Wed, 22 May 2019 17:22:35 +1000 Subject: [PATCH 1/2] remove categories --- server/src/cryp.rs | 8 +- server/src/game.rs | 22 ++-- server/src/item.rs | 17 ++- server/src/skill.rs | 312 ++++++++++++++++++-------------------------- 4 files changed, 156 insertions(+), 203 deletions(-) diff --git a/server/src/cryp.rs b/server/src/cryp.rs index e21c87a7..ee641d40 100644 --- a/server/src/cryp.rs +++ b/server/src/cryp.rs @@ -9,7 +9,7 @@ use failure::err_msg; use account::{Account}; use rpc::{CrypSpawnParams}; -use skill::{Skill, Cooldown, Effect, Cast, Category, Immunity, Disable, Event}; +use skill::{Skill, Cooldown, Effect, Cast, Colour, Immunity, Disable, Event}; use spec::{Spec}; use item::{Item}; @@ -560,7 +560,7 @@ impl Cryp { skill, amount: delta, mitigation: 0, - colour: Category::GreenDamage, + colour: Colour::Green, }); } } @@ -613,7 +613,7 @@ impl Cryp { skill, amount: delta, mitigation, - colour: Category::RedDamage, + colour: Colour::Red, }); }, true => { @@ -688,7 +688,7 @@ impl Cryp { skill, amount: delta, mitigation, - colour: Category::BlueDamage, + colour: Colour::Blue, }); }, true => { diff --git a/server/src/game.rs b/server/src/game.rs index 3b3a003a..3aa1c6ed 100644 --- a/server/src/game.rs +++ b/server/src/game.rs @@ -17,7 +17,6 @@ use cryp::{Cryp}; use skill::{Skill, Effect, Cast, Resolution, Event, resolution_steps}; use player::{Player}; use instance::{instance_game_finished, global_game_finished}; -use util::{IntPct}; #[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)] pub enum Phase { @@ -906,26 +905,27 @@ pub fn game_instance_new(tx: &mut Transaction, players: Vec, game_id: Uu Ok(game) } -pub fn game_instance_join(tx: &mut Transaction, player: Player, game_id: Uuid) -> Result { - let mut game = game_get(tx, game_id)?; +// pub fn game_instance_join(tx: &mut Transaction, player: Player, game_id: Uuid) -> Result { +// let mut game = game_get(tx, game_id)?; - game.player_add(player)?; +// game.player_add(player)?; - if game.can_start() { - game = game.start(); - } +// if game.can_start() { +// game = game.start(); +// } - info!("{:?} game joined", game.id); +// info!("{:?} game joined", game.id); - game_update(tx, &game)?; +// game_update(tx, &game)?; - Ok(game) -} +// Ok(game) +// } #[cfg(test)] mod tests { use game::*; use cryp::*; + use util::IntPct; fn create_test_game() -> Game { let mut x = Cryp::new() diff --git a/server/src/item.rs b/server/src/item.rs index 2bdab2c8..d0079ee0 100644 --- a/server/src/item.rs +++ b/server/src/item.rs @@ -1,4 +1,4 @@ -use skill::{Skill, Effect}; +use skill::{Skill, Effect, Colour}; use spec::{Spec}; use cryp::{Colours}; @@ -254,6 +254,15 @@ impl Item { } } + 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 @@ -502,6 +511,12 @@ impl From for Item { 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, diff --git a/server/src/skill.rs b/server/src/skill.rs index 5a1b9b45..7c1c47d5 100644 --- a/server/src/skill.rs +++ b/server/src/skill.rs @@ -32,7 +32,7 @@ pub fn pre_resolve(cast: &Cast, game: &mut Game, mut resolutions: Resolutions) - let mut target = game.cryp_by_id(target_id).unwrap().clone(); // bail out on ticks that have been removed - if cast.is_tick && target.effects.iter().find(|ce| match ce.tick { + if skill.is_tick() && target.effects.iter().find(|ce| match ce.tick { Some(t) => t.id == cast.id, None => false, }).is_none() { @@ -101,7 +101,7 @@ pub fn resolve(skill: Skill, source: &mut Cryp, target: &mut Cryp, mut resolutio } } - // match self.category() == Category::Red { + // match self.category() == EffectCategory::Red { // true => { // if let Some(evasion) = target.evade(*self) { // resolutions.push(evasion); @@ -225,7 +225,6 @@ pub struct Cast { pub target_cryp_id: Uuid, pub skill: Skill, pub speed: u64, - pub is_tick: bool, } impl Cast { @@ -237,7 +236,6 @@ impl Cast { target_cryp_id, skill, speed: 0, - is_tick: false, }; } @@ -249,7 +247,6 @@ impl Cast { target_cryp_id: target.id, skill, speed: 0, - is_tick: true } } @@ -294,7 +291,7 @@ impl Resolution { pub enum Event { Disable { skill: Skill, disable: Disable }, Immunity { skill: Skill, immunity: Immunity }, - Damage { skill: Skill, amount: u64, mitigation: u64, colour: Category }, + Damage { skill: Skill, amount: u64, mitigation: u64, colour: Colour }, Healing { skill: Skill, amount: u64, overhealing: u64 }, Recharge { skill: Skill, red: u64, blue: u64 }, Inversion { skill: Skill }, @@ -314,39 +311,36 @@ pub enum Event { type Resolutions = Vec; pub type Cooldown = Option; +#[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)] +enum EffectCategory { + Buff, + Debuff, + + Ko, +} + #[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)] pub enum Effect { - Airborne, - Bleed, - Blind, + Amplify, + Banish, Block, Buff, Clutch, - Deadly, - Fury, + Curse, + Haste, + Hex, Impurity, - Injured, Invert, - Leech, Parry, Reflect, + Ruin, + Slow, Snare, Strangle, Strangling, Stun, Taunt, - Untouchable, Vulnerable, - - Hex, - Ruin, - Curse, - Banish, - Slow, - Haste, - Enslave, - Mesmerise, - Amplify, Silence, Wither, // Reduce green dmg (healing) taken @@ -369,8 +363,20 @@ pub enum Effect { Regen, Siphon, - SpeedSiphon, - SpeedIncrease, + Injured, + // Airborne, + // Boost + // Bleed, + // Blind, + // Deadly, + // Enslave, + // Fury, + // Injured, + // Leech, + // Mesmerise, + // Untouchable, + // SpeedSiphon, + // SpeedIncrease, Ko, } @@ -378,11 +384,9 @@ pub enum Effect { impl Effect { pub fn immune(&self, skill: Skill) -> bool { match self { - Effect::Parry => match skill.category() { - Category::Blue => false, - Category::Red => true, - _ => false, - }, + Effect::Parry => + skill.colours().contains(&Colour::Red) || + [Skill::Attack, Skill::Stun].contains(&skill), Effect::Banish => true, Effect::Clutch => [ Skill::Stun, @@ -392,16 +396,16 @@ impl Effect { Skill::Strangle, Skill::Snare ].contains(&skill), - Effect::Injured => match skill.category() { - Category::Green => true, - Category::GreenTick => true, - _ => false, - }, + Effect::Injured => skill.colours().contains(&Colour::Green), _ => false, } } pub fn disables_skill(&self, skill: Skill) -> bool { + if skill.is_tick() { + return false; + } + match self { Effect::Stun => true, Effect::Hex => true, @@ -409,18 +413,9 @@ impl Effect { Effect::Banish => true, Effect::Strangle => true, Effect::Strangling => skill != Skill::StrangleTick, - Effect::Silence => skill.components().contains(&Item::Blue), - Effect::Snare => match skill.category() { - Category::Blue => false, - Category::Red => true, - _ => false, - }, - - Effect::Ko => match skill.category() { - Category::BlueTick => false, - Category::GreenTick => false, - _ => true, - }, + Effect::Silence => skill.colours().contains(&Colour::Blue), + Effect::Snare => skill.colours().contains(&Colour::Red), + Effect::Ko => skill.ko_castable(), _ => false, } } @@ -477,65 +472,55 @@ impl Effect { } } - pub fn category(&self) -> Category { + fn category(&self) -> EffectCategory { match self { // physical - Effect::Stun => Category::Debuff, - Effect::Block => Category::Buff, - Effect::Buff => Category::Buff, - Effect::Parry => Category::Buff, - Effect::Bleed => Category::Debuff, - Effect::Leech => Category::Debuff, - Effect::Airborne => Category::Debuff, - Effect::Untouchable => Category::Buff, - Effect::Deadly => Category::Buff, - Effect::Vulnerable => Category::Debuff, - Effect::Fury => Category::Buff, - Effect::Blind => Category::Debuff, - Effect::Snare => Category::Debuff, - Effect::Clutch => Category::Buff, - Effect::Taunt => Category::Buff, - Effect::Injured => Category::Debuff, - Effect::Strangle => Category::Debuff, - Effect::Strangling => Category::Buff, + Effect::Stun => EffectCategory::Debuff, + Effect::Block => EffectCategory::Buff, + Effect::Buff => EffectCategory::Buff, + Effect::Parry => EffectCategory::Buff, + Effect::Vulnerable => EffectCategory::Debuff, + Effect::Snare => EffectCategory::Debuff, + Effect::Clutch => EffectCategory::Buff, + Effect::Taunt => EffectCategory::Buff, + Effect::Strangle => EffectCategory::Debuff, + Effect::Strangling => EffectCategory::Buff, // magic - Effect::Hex => Category::Debuff, - Effect::Ruin => Category::Debuff, - Effect::Curse => Category::Debuff, - Effect::Banish => Category::Debuff, // todo randomise + Effect::Hex => EffectCategory::Debuff, + Effect::Ruin => EffectCategory::Debuff, + Effect::Curse => EffectCategory::Debuff, + Effect::Banish => EffectCategory::Debuff, // todo randomise // Effect::Banish => rng.gen_bool(0.5), - Effect::Slow => Category::Debuff, - Effect::Haste => Category::Buff, - Effect::Hatred => Category::Buff, - Effect::Reflect => Category::Buff, - Effect::Enslave => Category::Debuff, - Effect::Mesmerise => Category::Debuff, - Effect::Amplify => Category::Buff, - Effect::Silence => Category::Debuff, - Effect::Wither => Category::Debuff, + Effect::Slow => EffectCategory::Debuff, + Effect::Haste => EffectCategory::Buff, + Effect::Hatred => EffectCategory::Buff, + Effect::Reflect => EffectCategory::Buff, + Effect::Amplify => EffectCategory::Buff, + Effect::Silence => EffectCategory::Debuff, + Effect::Wither => EffectCategory::Debuff, - Effect::Corrupt => Category::Buff, - Effect::Corruption => Category::Debuff, + Effect::Corrupt => EffectCategory::Buff, + Effect::Corruption => EffectCategory::Debuff, - Effect::Hostility => Category::Buff, + Effect::Hostility => EffectCategory::Buff, // magic - Effect::Impurity => Category::Buff, - Effect::Scatter => Category::Buff, - Effect::Invert => Category::Buff, + Effect::Impurity => EffectCategory::Buff, + Effect::Scatter => EffectCategory::Buff, + Effect::Invert => EffectCategory::Buff, // effects over time - Effect::Triage => Category::Buff, - Effect::Decay => Category::Debuff, - Effect::Regen => Category::Buff, - Effect::Siphon => Category::Debuff, + Effect::Triage => EffectCategory::Buff, + Effect::Decay => EffectCategory::Debuff, + Effect::Regen => EffectCategory::Buff, + Effect::Siphon => EffectCategory::Debuff, - Effect::SpeedSiphon => Category::Debuff, - Effect::SpeedIncrease => Category::Buff, + // not in game + Effect::Injured => EffectCategory::Debuff, - Effect::Ko => Category::Ko, + Effect::Ko => EffectCategory::Ko, } } } @@ -547,23 +532,10 @@ pub enum SkillEffect { } #[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)] -pub enum Category { +pub enum Colour { Red, Blue, Green, - - RedDamage, - BlueDamage, - GreenDamage, - - RedTick, - BlueTick, - GreenTick, - - Buff, - Debuff, - - Ko, } #[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)] @@ -837,72 +809,6 @@ impl Skill { } } - pub fn category(&self) -> Category { - match self { - Skill::Attack => Category::Red, - Skill::Strike => Category::Red, - Skill::StrikeII => Category::Red, - Skill::StrikeIII => Category::Red, - Skill::Injure => Category::Red, - Skill::Strangle => Category::Red, - Skill::StrangleTick => Category::Red, - Skill::Block => Category::Red, // reduce damage - Skill::Parry => Category::Red, // avoid all damage - Skill::Riposte => Category::Red, // avoid all damage - Skill::Snare => Category::Red, - Skill::Clutch => Category::Red, - Skill::Stun => Category::Red, - Skill::Slay => Category::Red, - Skill::Taunt => Category::Red, - Skill::HasteStrike => Category::Red, - Skill::Buff => Category::Red, - - Skill::Heal => Category::Green, - Skill::Triage => Category::Green, // hot - Skill::TriageTick => Category::GreenTick, // hot - Skill::Throw => Category::Green, - Skill::Purify => Category::Green, - Skill::Recharge => Category::Green, - Skill::Reflect => Category::Green, - Skill::Haste => Category::Green, - Skill::Impurity => Category::Green, - Skill::Invert => Category::Green, - Skill::Sleep => Category::Green, - - Skill::ImpureBlast => Category::Blue, - Skill::Scatter => Category::Blue, - Skill::Blast => Category::Blue, - Skill::Chaos => Category::Blue, - Skill::Amplify => Category::Blue, - Skill::Decay => Category::Blue, // dot - Skill::DecayTick => Category::BlueTick, // hot - Skill::Siphon => Category::Blue, - Skill::SiphonTick => Category::BlueTick, // hot - Skill::Curse => Category::Blue, - Skill::Silence => Category::Blue, - Skill::Purge => Category::Blue, - Skill::Banish => Category::Blue, - Skill::Hex => Category::Blue, - Skill::Debuff => Category::Blue, - Skill::Ruin => Category::Blue, - Skill::Hostility => Category::Blue, - Skill::Corrupt => Category::Blue, - Skill::CorruptionTick => Category::Blue, - - // ----------------- - // Test - // ----------------- - - Skill::TestAttack => Category::Red, - Skill::TestHeal => Category::Green, - Skill::TestTouch => Category::Red, - Skill::TestStun => Category::Red, - Skill::TestParry => Category::Red, - Skill::TestBlock => Category::Red, - Skill::TestSiphon => Category::Blue, - } - } - pub fn ko_castable(&self) -> bool { match self { Skill::TriageTick => true, @@ -913,6 +819,17 @@ impl Skill { } } + pub fn is_tick(&self) -> bool { + match self { + Skill::CorruptionTick => true, + Skill::DecayTick => true, + Skill::SiphonTick => true, + Skill::StrangleTick => true, + Skill::TriageTick => true, + _ => false, + } + } + pub fn speed(&self) -> u8 { match self { // ----------------- @@ -983,8 +900,30 @@ impl Skill { } } - pub fn components(&self) -> Vec { - Item::from(*self).components() + fn components(&self) -> Vec { + let mut components = Item::from(*self).components(); + components.sort_unstable(); + return components; + } + + fn colours(&self) -> Vec { + let mut components = self.components(); + let colour_items = [Item::Red, Item::Green, Item::Blue]; + components.dedup(); + return components.iter() + .filter(|i| colour_items.contains(i)) + .map(|i| i.into_colour()) + .collect::>(); + } + + fn base(&self) -> Skill { + let bases = [Item::Attack, Item::Stun, Item::Buff, Item::Debuff, Item::Block]; + match self.components() + .iter() + .find(|i| bases.contains(i)) { + Some(i) => i.into_skill().unwrap(), + None => panic!("{:?} has no base item", self), + } } } @@ -1128,9 +1067,9 @@ fn snare(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, skill: let s_multi = target.skills .iter() - .fold(100, |acc, cs| match cs.skill.category() { - Category::Red => acc + 35, - _ => acc, + .fold(100, |acc, cs| match cs.skill.colours().contains(&Colour::Red) { + true => acc + 35, + false => acc, }); let amount = source.red_damage().pct(skill.multiplier()).pct(s_multi); @@ -1374,10 +1313,9 @@ fn scatter_hit(source: &Cryp, target: &Cryp, mut results: Resolutions, game: &mu let mut scatter_target = game.cryp_by_id(scatter_target_id).unwrap(); let res = match colour { - Category::RedDamage => scatter_target.deal_red_damage(skill, amount), - Category::BlueDamage => scatter_target.deal_blue_damage(skill, amount), - Category::GreenDamage => scatter_target.deal_green_damage(skill, amount), - _ => panic!("{:?} unknown damage type", colour), + Colour::Red => scatter_target.deal_red_damage(skill, amount), + Colour::Blue => scatter_target.deal_blue_damage(skill, amount), + Colour::Green => scatter_target.deal_green_damage(skill, amount), }; results.push(Resolution::new(target, scatter_target).event(Event::Skill { skill: Skill::Scatter })); @@ -1398,9 +1336,9 @@ fn silence(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, skill let s_multi = target.skills .iter() - .fold(100, |acc, cs| match cs.skill.category() { - Category::Blue => acc + 45, - _ => acc, + .fold(100, |acc, cs| match cs.skill.colours().contains(&Colour::Blue) { + true => acc + 45, + false => acc, }); let amount = source.blue_damage().pct(skill.multiplier()).pct(s_multi); @@ -1414,7 +1352,7 @@ fn silence(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, skill fn purge(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, skill: Skill) -> Resolutions { while let Some(i) = target.effects .iter() - .position(|ce| [Category::Buff, Category::Buff].contains(&ce.effect.category())) { + .position(|ce| ce.effect.category() == EffectCategory::Buff) { let ce = target.effects.remove(i); results.push(Resolution::new(source, target).event(Event::Removal { effect: ce.effect })); } @@ -1427,7 +1365,7 @@ fn purify(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, skill: let amount = source.green_damage().pct(skill.multiplier()); while let Some(i) = target.effects .iter() - .position(|ce| Category::Debuff == ce.effect.category()) { + .position(|ce| ce.effect.category() == EffectCategory::Debuff) { let ce = target.effects.remove(i); results.push(Resolution::new(source, target).event(Event::Removal { effect: ce.effect })); target.deal_green_damage(skill, amount) From caaca4fb05e99b5628cc1ffaf025072da070f38e Mon Sep 17 00:00:00 2001 From: ntr Date: Wed, 22 May 2019 17:44:42 +1000 Subject: [PATCH 2/2] move combos --- client/src/utils.jsx | 12 ++-- server/src/item.rs | 165 ++++++++++++++++++++++++++++++------------- 2 files changed, 121 insertions(+), 56 deletions(-) diff --git a/client/src/utils.jsx b/client/src/utils.jsx index c3c0ae02..11be5c13 100644 --- a/client/src/utils.jsx +++ b/client/src/utils.jsx @@ -248,10 +248,10 @@ function resoCrypHealth(resolution, currentGame) { if (type === 'Damage') { const { amount, mitigation, colour } = event; cryp.green_life.value -= amount; - if (colour === 'RedDamage') { + if (colour === 'Red') { cryp.red_life.value -= mitigation; } - if (colour === 'BlueDamage') { + if (colour === 'Blue') { cryp.blue_life.value -= mitigation; } } @@ -312,13 +312,13 @@ function eventClasses(resolution, cryp) { // Deal damage to cryp and return effect if (target && postSkill) { - if (colour === 'RedDamage') { + if (colour === 'Red') { return 'red-damage'; } - if (colour === 'BlueDamage') { + if (colour === 'Blue') { return 'blue-damage'; } - if (colour === 'GreenDamage') return 'green-damage'; + if (colour === 'Green') return 'green-damage'; } } @@ -399,7 +399,7 @@ function getCombatSequence(event) { || (event[1].skill === 'Decay' && event[1].effect === 'Wither'))) return ['POST_SKILL']; if (['Damage'].includes(event[0]) - && ((event[1].skill === 'Chaos' && event[1].colour === 'RedDamage') + && ((event[1].skill === 'Chaos' && event[1].colour === 'Red') || event[1].skill === 'Silence' || event[1].skill === 'Snare')) return ['POST_SKILL']; diff --git a/server/src/item.rs b/server/src/item.rs index d0079ee0..b90157f1 100644 --- a/server/src/item.rs +++ b/server/src/item.rs @@ -467,6 +467,71 @@ impl Item { _ => format!("..."), } } + + fn combo(&self) -> Vec { + match self { + Item::Taunt => vec![Item::Buff, Item::Red, Item::Red], + Item::Triage => vec![Item::Buff, Item::Green, Item::Green], + Item::Scatter => vec![Item::Buff, Item::Blue, Item::Blue], //To be impl + Item::Haste => vec![Item::Buff, Item::Red, Item::Green], + Item::Impurity => vec![Item::Buff, Item::Green, Item::Blue], + Item::Amplify => vec![Item::Buff, Item::Red, Item::Blue], // Some flavour + + Item::Snare => vec![Item::Debuff, Item::Red, Item::Red], + Item::Purge => vec![Item::Debuff, Item::Green, Item::Green], // Needs flavour + Item::Silence => vec![Item::Debuff, Item::Blue, Item::Blue], + Item::Curse => vec![Item::Debuff, Item::Red, Item::Green], // To be reworked + Item::Decay => vec![Item::Debuff, Item::Green, Item::Blue], + Item::Invert => vec![Item::Debuff, Item::Red, Item::Blue], + + Item::Parry => vec![Item::Block, Item::Red, Item::Red], // Add red recharge + Item::Purify => vec![Item::Block, Item::Green, Item::Green], + Item::Corrupt => vec![Item::Block, Item::Blue, Item::Blue], + Item::Clutch => vec![Item::Block, Item::Red, Item::Green], + Item::Reflect => vec![Item::Block, Item::Green, Item::Blue], + Item::Recharge => vec![Item::Block, Item::Red, Item::Blue], + + Item::Strangle => vec![Item::Stun, Item::Red, Item::Red], + Item::Sleep => vec![Item::Stun, Item::Green, Item::Green], + Item::Ruin => vec![Item::Stun, Item::Blue, Item::Blue], + Item::Throw => vec![Item::Stun, Item::Red, Item::Green], + Item::Hex => vec![Item::Stun, Item::Green, Item::Blue], + Item::Banish => vec![Item::Stun, Item::Red, Item::Blue], + + Item::Strike => vec![Item::Attack, Item::Red, Item::Red], + Item::StrikeII => vec![Item::Strike, Item::Strike, Item::Strike], + Item::StrikeIII => vec![Item::StrikeII, Item::StrikeII, Item::StrikeII], + + Item::Heal => vec![Item::Attack, Item::Green, Item::Green], + Item::Blast => vec![Item::Attack, Item::Blue, Item::Blue], + Item::Slay => vec![Item::Attack, Item::Red, Item::Green], + Item::Siphon => vec![Item::Attack, Item::Green, Item::Blue], + Item::Chaos => vec![Item::Attack, Item::Red, Item::Blue], + + 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 for Item { @@ -567,64 +632,64 @@ pub struct Combo { pub fn get_combos() -> Vec { let mut combinations = vec![ - Combo { components: vec![Item::Buff, Item::Red, Item::Red], item: Item::Taunt }, - Combo { components: vec![Item::Buff, Item::Green, Item::Green], item: Item::Triage }, - Combo { components: vec![Item::Buff, Item::Blue, Item::Blue], item: Item::Scatter }, //To be impl - Combo { components: vec![Item::Buff, Item::Red, Item::Green], item: Item::Haste }, - Combo { components: vec![Item::Buff, Item::Green, Item::Blue], item: Item::Impurity }, - Combo { components: vec![Item::Buff, Item::Red, Item::Blue], item: Item::Amplify }, // Some flavour + Combo { components: Item::Taunt.combo(), item: Item::Taunt }, + Combo { components: Item::Triage.combo(), item: Item::Triage }, + Combo { components: Item::Scatter.combo(), item: Item::Scatter }, //To be impl + Combo { components: Item::Haste.combo(), item: Item::Haste }, + Combo { components: Item::Impurity.combo(), item: Item::Impurity }, + Combo { components: Item::Amplify.combo(), item: Item::Amplify }, // Some flavour - Combo { components: vec![Item::Debuff, Item::Red, Item::Red], item: Item::Snare }, - Combo { components: vec![Item::Debuff, Item::Green, Item::Green], item: Item::Purge }, // Needs flavour - Combo { components: vec![Item::Debuff, Item::Blue, Item::Blue], item: Item::Silence }, - Combo { components: vec![Item::Debuff, Item::Red, Item::Green], item: Item::Curse }, // To be reworked - Combo { components: vec![Item::Debuff, Item::Green, Item::Blue], item: Item::Decay }, - Combo { components: vec![Item::Debuff, Item::Red, Item::Blue], item: Item::Invert }, + Combo { components: Item::Snare.combo(), item: Item::Snare }, + Combo { components: Item::Purge.combo(), item: Item::Purge }, // Needs flavour + Combo { components: Item::Silence.combo(), item: Item::Silence }, + Combo { components: Item::Curse.combo(), item: Item::Curse }, // To be reworked + Combo { components: Item::Decay.combo(), item: Item::Decay }, + Combo { components: Item::Invert.combo(), item: Item::Invert }, - Combo { components: vec![Item::Block, Item::Red, Item::Red], item: Item::Parry }, // Add red recharge - Combo { components: vec![Item::Block, Item::Green, Item::Green], item: Item::Purify }, - Combo { components: vec![Item::Block, Item::Blue, Item::Blue], item: Item::Corrupt }, - Combo { components: vec![Item::Block, Item::Red, Item::Green], item: Item::Clutch }, - Combo { components: vec![Item::Block, Item::Green, Item::Blue], item: Item::Reflect }, - Combo { components: vec![Item::Block, Item::Red, Item::Blue], item: Item::Recharge }, + Combo { components: Item::Parry.combo(), item: Item::Parry }, // Add red recharge + Combo { components: Item::Purify.combo(), item: Item::Purify }, + Combo { components: Item::Corrupt.combo(), item: Item::Corrupt }, + Combo { components: Item::Clutch.combo(), item: Item::Clutch }, + Combo { components: Item::Reflect.combo(), item: Item::Reflect }, + Combo { components: Item::Recharge.combo(), item: Item::Recharge }, - Combo { components: vec![Item::Stun, Item::Red, Item::Red], item: Item::Strangle }, - Combo { components: vec![Item::Stun, Item::Green, Item::Green], item: Item::Sleep }, - Combo { components: vec![Item::Stun, Item::Blue, Item::Blue], item: Item::Ruin }, - Combo { components: vec![Item::Stun, Item::Red, Item::Green], item: Item::Throw }, - Combo { components: vec![Item::Stun, Item::Green, Item::Blue], item: Item::Hex }, - Combo { components: vec![Item::Stun, Item::Red, Item::Blue], item: Item::Banish }, + Combo { components: Item::Strangle.combo(), item: Item::Strangle }, + Combo { components: Item::Sleep.combo(), item: Item::Sleep }, + Combo { components: Item::Ruin.combo(), item: Item::Ruin }, + Combo { components: Item::Throw.combo(), item: Item::Throw }, + Combo { components: Item::Hex.combo(), item: Item::Hex }, + Combo { components: Item::Banish.combo(), item: Item::Banish }, - Combo { components: vec![Item::Attack, Item::Red, Item::Red], item: Item::Strike }, - Combo { components: vec![Item::Strike, Item::Strike, Item::Strike], item: Item::StrikeII }, - Combo { components: vec![Item::StrikeII, Item::StrikeII, Item::StrikeII], item: Item::StrikeIII }, + Combo { components: Item::Strike.combo(), item: Item::Strike }, + Combo { components: Item::StrikeII.combo(), item: Item::StrikeII }, + Combo { components: Item::StrikeIII.combo(), item: Item::StrikeIII }, - Combo { components: vec![Item::Attack, Item::Green, Item::Green], item: Item::Heal }, - Combo { components: vec![Item::Attack, Item::Blue, Item::Blue], item: Item::Blast }, - Combo { components: vec![Item::Attack, Item::Red, Item::Green], item: Item::Slay }, - Combo { components: vec![Item::Attack, Item::Green, Item::Blue], item: Item::Siphon }, - Combo { components: vec![Item::Attack, Item::Red, Item::Blue], item: Item::Chaos }, + Combo { components: Item::Heal.combo(), item: Item::Heal }, + Combo { components: Item::Blast.combo(), item: Item::Blast }, + Combo { components: Item::Slay.combo(), item: Item::Slay }, + Combo { components: Item::Siphon.combo(), item: Item::Siphon }, + Combo { components: Item::Chaos.combo(), item: Item::Chaos }, - Combo { components: vec![Item::Damage, Item::Red, Item::Red], item: Item::RedDamageI }, - Combo { components: vec![Item::Damage, Item::Green, Item::Green], item: Item::GreenDamageI }, - Combo { components: vec![Item::Damage, Item::Blue, Item::Blue], item: Item::BlueDamageI }, - Combo { components: vec![Item::Damage, Item::Red, Item::Green], item: Item::GRDI }, - Combo { components: vec![Item::Damage, Item::Green, Item::Blue], item: Item::GBDI }, - Combo { components: vec![Item::Damage, Item::Red, Item::Blue], item: Item::RBDI }, + 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: vec![Item::Life, Item::Red, Item::Red], item: Item::RedLifeI }, - Combo { components: vec![Item::Life, Item::Green, Item::Green], item: Item::GreenLifeI }, - Combo { components: vec![Item::Life, Item::Blue, Item::Blue], item: Item::BlueLifeI }, - Combo { components: vec![Item::Life, Item::Red, Item::Green], item: Item::GRLI }, - Combo { components: vec![Item::Life, Item::Green, Item::Blue], item: Item::GBLI }, - Combo { components: vec![Item::Life, Item::Red, Item::Blue], item: Item::RBLI }, + 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: vec![Item::Speed, Item::Red, Item::Red], item: Item::RedSpeedI }, - Combo { components: vec![Item::Speed, Item::Green, Item::Green], item: Item::GreenSpeedI }, - Combo { components: vec![Item::Speed, Item::Blue, Item::Blue], item: Item::BlueSpeedI }, - Combo { components: vec![Item::Speed, Item::Red, Item::Green], item: Item::GRSpeedI }, - Combo { components: vec![Item::Speed, Item::Green, Item::Blue], item: Item::GBSpeedI }, - Combo { components: vec![Item::Speed, Item::Red, Item::Blue], item: Item::RBSpeedI }, + 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 }, ];