ntr/mnml
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'remove-categories' of ssh://cryps.gg:40022/~/cryps into remove-categories

Browse Source
This commit is contained in:
Mashy 2019-05-22 22:07:57 +10:00
commit 59b5f92f42
5 changed files with 277 additions and 259 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
client/src/utils.jsx
View File

@ -248,10 +248,10 @@ function resoCrypHealth(resolution, currentGame) {
if (type === 'Damage') { if (type === 'Damage') {
const { amount, mitigation, colour } = event; const { amount, mitigation, colour } = event;
cryp.green_life.value -= amount; cryp.green_life.value -= amount;
if (colour === 'RedDamage') { if (colour === 'Red') {
cryp.red_life.value -= mitigation; cryp.red_life.value -= mitigation;
} }
if (colour === 'BlueDamage') { if (colour === 'Blue') {
cryp.blue_life.value -= mitigation; cryp.blue_life.value -= mitigation;
} }
} }
@ -312,13 +312,13 @@ function eventClasses(resolution, cryp) {
// Deal damage to cryp and return effect // Deal damage to cryp and return effect
if (target && postSkill) { if (target && postSkill) {
if (colour === 'RedDamage') { if (colour === 'Red') {
return 'red-damage'; return 'red-damage';
} }
if (colour === 'BlueDamage') { if (colour === 'Blue') {
return 'blue-damage'; 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']; || (event[1].skill === 'Decay' && event[1].effect === 'Wither'))) return ['POST_SKILL'];
if (['Damage'].includes(event[0]) 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 === 'Silence'
|| event[1].skill === 'Snare')) return ['POST_SKILL']; || event[1].skill === 'Snare')) return ['POST_SKILL'];

8
server/src/cryp.rs
View File

@ -9,7 +9,7 @@ use failure::err_msg;
use account::{Account}; use account::{Account};
use rpc::{CrypSpawnParams}; 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 spec::{Spec};
use item::{Item}; use item::{Item};
@ -564,7 +564,7 @@ impl Cryp {
skill, skill,
amount: delta, amount: delta,
mitigation: 0, mitigation: 0,
colour: Category::GreenDamage, colour: Colour::Green,
}); });
} }
} }
@ -617,7 +617,7 @@ impl Cryp {
skill, skill,
amount: delta, amount: delta,
mitigation, mitigation,
colour: Category::RedDamage, colour: Colour::Red,
}); });
}, },
true => { true => {
@ -692,7 +692,7 @@ impl Cryp {
skill, skill,
amount: delta, amount: delta,
mitigation, mitigation,
colour: Category::BlueDamage, colour: Colour::Blue,
}); });
}, },
true => { true => {

22
server/src/game.rs
View File

@ -17,7 +17,6 @@ use cryp::{Cryp};
use skill::{Skill, Effect, Cast, Resolution, Event, resolution_steps}; use skill::{Skill, Effect, Cast, Resolution, Event, resolution_steps};
use player::{Player}; use player::{Player};
use instance::{instance_game_finished, global_game_finished}; use instance::{instance_game_finished, global_game_finished};
use util::{IntPct};
#[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)] #[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
pub enum Phase { pub enum Phase {
@ -906,26 +905,27 @@ pub fn game_instance_new(tx: &mut Transaction, players: Vec<Player>, game_id: Uu
Ok(game) Ok(game)
} }
pub fn game_instance_join(tx: &mut Transaction, player: Player, game_id: Uuid) -> Result<Game, Error> { // pub fn game_instance_join(tx: &mut Transaction, player: Player, game_id: Uuid) -> Result<Game, Error> {
let mut game = game_get(tx, game_id)?; // let mut game = game_get(tx, game_id)?;
game.player_add(player)?; // game.player_add(player)?;
if game.can_start() { // if game.can_start() {
game = game.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)] #[cfg(test)]
mod tests { mod tests {
use game::*; use game::*;
use cryp::*; use cryp::*;
use util::IntPct;
fn create_test_game() -> Game { fn create_test_game() -> Game {
let mut x = Cryp::new() let mut x = Cryp::new()

182
server/src/item.rs
View File

@ -1,4 +1,4 @@
use skill::{Skill, Effect}; use skill::{Skill, Effect, Colour};
use spec::{Spec}; use spec::{Spec};
use cryp::{Colours}; 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 { pub fn into_description(&self) -> String {
match self { match self {
// colours // colours
@ -462,6 +471,71 @@ impl Item {
_ => format!("..."), _ => 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::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<Skill> for Item { impl From<Skill> for Item {
@ -506,6 +580,12 @@ impl From<Skill> for Item {
Skill::Triage => Item::Triage, Skill::Triage => Item::Triage,
Skill::Corrupt => Item::Corrupt, 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::TestTouch => Item::TestTouch,
Skill::TestStun => Item::TestStun, Skill::TestStun => Item::TestStun,
Skill::TestBlock => Item::TestBlock, Skill::TestBlock => Item::TestBlock,
@ -556,64 +636,64 @@ pub struct Combo {
pub fn get_combos() -> Vec<Combo> { pub fn get_combos() -> Vec<Combo> {
let mut combinations = vec![ let mut combinations = vec![
Combo { components: vec![Item::Buff, Item::Red, Item::Red], item: Item::Taunt }, Combo { components: Item::Taunt.combo(), item: Item::Taunt },
Combo { components: vec![Item::Buff, Item::Green, Item::Green], item: Item::Triage }, Combo { components: Item::Triage.combo(), item: Item::Triage },
Combo { components: vec![Item::Buff, Item::Blue, Item::Blue], item: Item::Scatter }, //To be impl Combo { components: Item::Scatter.combo(), item: Item::Scatter }, //To be impl
Combo { components: vec![Item::Buff, Item::Red, Item::Green], item: Item::Haste }, Combo { components: Item::Haste.combo(), item: Item::Haste },
Combo { components: vec![Item::Buff, Item::Green, Item::Blue], item: Item::Impurity }, Combo { components: Item::Impurity.combo(), item: Item::Impurity },
Combo { components: vec![Item::Buff, Item::Red, Item::Blue], item: Item::Amplify }, // Some flavour Combo { components: Item::Amplify.combo(), item: Item::Amplify }, // Some flavour
Combo { components: vec![Item::Debuff, Item::Red, Item::Red], item: Item::Snare }, Combo { components: Item::Snare.combo(), item: Item::Snare },
Combo { components: vec![Item::Debuff, Item::Green, Item::Green], item: Item::Purge }, // Needs flavour Combo { components: Item::Purge.combo(), item: Item::Purge }, // Needs flavour
Combo { components: vec![Item::Debuff, Item::Blue, Item::Blue], item: Item::Silence }, Combo { components: Item::Silence.combo(), item: Item::Silence },
Combo { components: vec![Item::Debuff, Item::Red, Item::Green], item: Item::Curse }, // To be reworked Combo { components: Item::Curse.combo(), item: Item::Curse }, // To be reworked
Combo { components: vec![Item::Debuff, Item::Green, Item::Blue], item: Item::Decay }, Combo { components: Item::Decay.combo(), item: Item::Decay },
Combo { components: vec![Item::Debuff, Item::Red, Item::Blue], item: Item::Invert }, 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: Item::Parry.combo(), item: Item::Parry }, // Add red recharge
Combo { components: vec![Item::Block, Item::Green, Item::Green], item: Item::Purify }, Combo { components: Item::Purify.combo(), item: Item::Purify },
Combo { components: vec![Item::Block, Item::Blue, Item::Blue], item: Item::Corrupt }, Combo { components: Item::Corrupt.combo(), item: Item::Corrupt },
Combo { components: vec![Item::Block, Item::Red, Item::Green], item: Item::Clutch }, Combo { components: Item::Clutch.combo(), item: Item::Clutch },
Combo { components: vec![Item::Block, Item::Green, Item::Blue], item: Item::Reflect }, Combo { components: Item::Reflect.combo(), item: Item::Reflect },
Combo { components: vec![Item::Block, Item::Red, Item::Blue], item: Item::Recharge }, Combo { components: Item::Recharge.combo(), item: Item::Recharge },
Combo { components: vec![Item::Stun, Item::Red, Item::Red], item: Item::Strangle }, Combo { components: Item::Strangle.combo(), item: Item::Strangle },
Combo { components: vec![Item::Stun, Item::Green, Item::Green], item: Item::Sleep }, Combo { components: Item::Sleep.combo(), item: Item::Sleep },
Combo { components: vec![Item::Stun, Item::Blue, Item::Blue], item: Item::Ruin }, Combo { components: Item::Ruin.combo(), item: Item::Ruin },
Combo { components: vec![Item::Stun, Item::Red, Item::Green], item: Item::Throw }, Combo { components: Item::Throw.combo(), item: Item::Throw },
Combo { components: vec![Item::Stun, Item::Green, Item::Blue], item: Item::Hex }, Combo { components: Item::Hex.combo(), item: Item::Hex },
Combo { components: vec![Item::Stun, Item::Red, Item::Blue], item: Item::Banish }, Combo { components: Item::Banish.combo(), item: Item::Banish },
Combo { components: vec![Item::Attack, Item::Red, Item::Red], item: Item::Strike }, Combo { components: Item::Strike.combo(), item: Item::Strike },
Combo { components: vec![Item::Strike, Item::Strike, Item::Strike], item: Item::StrikeII }, Combo { components: Item::StrikeII.combo(), item: Item::StrikeII },
Combo { components: vec![Item::StrikeII, Item::StrikeII, Item::StrikeII], item: Item::StrikeIII }, Combo { components: Item::StrikeIII.combo(), item: Item::StrikeIII },
Combo { components: vec![Item::Attack, Item::Green, Item::Green], item: Item::Heal }, Combo { components: Item::Heal.combo(), item: Item::Heal },
Combo { components: vec![Item::Attack, Item::Blue, Item::Blue], item: Item::Blast }, Combo { components: Item::Blast.combo(), item: Item::Blast },
Combo { components: vec![Item::Attack, Item::Red, Item::Green], item: Item::Slay }, Combo { components: Item::Slay.combo(), item: Item::Slay },
Combo { components: vec![Item::Attack, Item::Green, Item::Blue], item: Item::Siphon }, Combo { components: Item::Siphon.combo(), item: Item::Siphon },
Combo { components: vec![Item::Attack, Item::Red, Item::Blue], item: Item::Chaos }, Combo { components: Item::Chaos.combo(), item: Item::Chaos },
Combo { components: vec![Item::Damage, Item::Red, Item::Red], item: Item::RedDamageI }, Combo { components: Item::RedDamageI.combo(), item: Item::RedDamageI },
Combo { components: vec![Item::Damage, Item::Green, Item::Green], item: Item::GreenDamageI }, Combo { components: Item::GreenDamageI.combo(), item: Item::GreenDamageI },
Combo { components: vec![Item::Damage, Item::Blue, Item::Blue], item: Item::BlueDamageI }, Combo { components: Item::BlueDamageI.combo(), item: Item::BlueDamageI },
Combo { components: vec![Item::Damage, Item::Red, Item::Green], item: Item::GRDI }, Combo { components: Item::GRDI.combo(), item: Item::GRDI },
Combo { components: vec![Item::Damage, Item::Green, Item::Blue], item: Item::GBDI }, Combo { components: Item::GBDI.combo(), item: Item::GBDI },
Combo { components: vec![Item::Damage, Item::Red, Item::Blue], item: Item::RBDI }, Combo { components: Item::RBDI.combo(), item: Item::RBDI },
Combo { components: vec![Item::Life, Item::Red, Item::Red], item: Item::RedLifeI }, Combo { components: Item::RedLifeI.combo(), item: Item::RedLifeI },
Combo { components: vec![Item::Life, Item::Green, Item::Green], item: Item::GreenLifeI }, Combo { components: Item::GreenLifeI.combo(), item: Item::GreenLifeI },
Combo { components: vec![Item::Life, Item::Blue, Item::Blue], item: Item::BlueLifeI }, Combo { components: Item::BlueLifeI.combo(), item: Item::BlueLifeI },
Combo { components: vec![Item::Life, Item::Red, Item::Green], item: Item::GRLI }, Combo { components: Item::GRLI.combo(), item: Item::GRLI },
Combo { components: vec![Item::Life, Item::Green, Item::Blue], item: Item::GBLI }, Combo { components: Item::GBLI.combo(), item: Item::GBLI },
Combo { components: vec![Item::Life, Item::Red, Item::Blue], item: Item::RBLI }, Combo { components: Item::RBLI.combo(), item: Item::RBLI },
Combo { components: vec![Item::Speed, Item::Red, Item::Red], item: Item::RedSpeedI }, Combo { components: Item::RedSpeedI.combo(), item: Item::RedSpeedI },
Combo { components: vec![Item::Speed, Item::Green, Item::Green], item: Item::GreenSpeedI }, Combo { components: Item::GreenSpeedI.combo(), item: Item::GreenSpeedI },
Combo { components: vec![Item::Speed, Item::Blue, Item::Blue], item: Item::BlueSpeedI }, Combo { components: Item::BlueSpeedI.combo(), item: Item::BlueSpeedI },
Combo { components: vec![Item::Speed, Item::Red, Item::Green], item: Item::GRSpeedI }, Combo { components: Item::GRSpeedI.combo(), item: Item::GRSpeedI },
Combo { components: vec![Item::Speed, Item::Green, Item::Blue], item: Item::GBSpeedI }, Combo { components: Item::GBSpeedI.combo(), item: Item::GBSpeedI },
Combo { components: vec![Item::Speed, Item::Red, Item::Blue], item: Item::RBSpeedI }, Combo { components: Item::RBSpeedI.combo(), item: Item::RBSpeedI },
]; ];

312
server/src/skill.rs
View File

@ -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(); let mut target = game.cryp_by_id(target_id).unwrap().clone();
// bail out on ticks that have been removed // 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, Some(t) => t.id == cast.id,
None => false, None => false,
}).is_none() { }).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 => { // true => {
// if let Some(evasion) = target.evade(*self) { // if let Some(evasion) = target.evade(*self) {
// resolutions.push(evasion); // resolutions.push(evasion);
@ -225,7 +225,6 @@ pub struct Cast {
pub target_cryp_id: Uuid, pub target_cryp_id: Uuid,
pub skill: Skill, pub skill: Skill,
pub speed: u64, pub speed: u64,
pub is_tick: bool,
} }
impl Cast { impl Cast {
@ -237,7 +236,6 @@ impl Cast {
target_cryp_id, target_cryp_id,
skill, skill,
speed: 0, speed: 0,
is_tick: false,
}; };
} }
@ -249,7 +247,6 @@ impl Cast {
target_cryp_id: target.id, target_cryp_id: target.id,
skill, skill,
speed: 0, speed: 0,
is_tick: true
} }
} }
@ -294,7 +291,7 @@ impl Resolution {
pub enum Event { pub enum Event {
Disable { skill: Skill, disable: Disable }, Disable { skill: Skill, disable: Disable },
Immunity { skill: Skill, immunity: Immunity }, 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 }, Healing { skill: Skill, amount: u64, overhealing: u64 },
Recharge { skill: Skill, red: u64, blue: u64 }, Recharge { skill: Skill, red: u64, blue: u64 },
Inversion { skill: Skill }, Inversion { skill: Skill },
@ -314,39 +311,36 @@ pub enum Event {
type Resolutions = Vec<Resolution>; type Resolutions = Vec<Resolution>;
pub type Cooldown = Option<u8>; pub type Cooldown = Option<u8>;
#[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
enum EffectCategory {
Buff,
Debuff,
Ko,
}
#[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)] #[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
pub enum Effect { pub enum Effect {
Airborne, Amplify,
Bleed, Banish,
Blind,
Block, Block,
Buff, Buff,
Clutch, Clutch,
Deadly, Curse,
Fury, Haste,
Hex,
Impurity, Impurity,
Injured,
Invert, Invert,
Leech,
Parry, Parry,
Reflect, Reflect,
Ruin,
Slow,
Snare, Snare,
Strangle, Strangle,
Strangling, Strangling,
Stun, Stun,
Taunt, Taunt,
Untouchable,
Vulnerable, Vulnerable,
Hex,
Ruin,
Curse,
Banish,
Slow,
Haste,
Enslave,
Mesmerise,
Amplify,
Silence, Silence,
Wither, // Reduce green dmg (healing) taken Wither, // Reduce green dmg (healing) taken
@ -369,8 +363,20 @@ pub enum Effect {
Regen, Regen,
Siphon, Siphon,
SpeedSiphon, Injured,
SpeedIncrease, // Airborne,
// Boost
// Bleed,
// Blind,
// Deadly,
// Enslave,
// Fury,
// Injured,
// Leech,
// Mesmerise,
// Untouchable,
// SpeedSiphon,
// SpeedIncrease,
Ko, Ko,
} }
@ -378,11 +384,9 @@ pub enum Effect {
impl Effect { impl Effect {
pub fn immune(&self, skill: Skill) -> bool { pub fn immune(&self, skill: Skill) -> bool {
match self { match self {
Effect::Parry => match skill.category() { Effect::Parry =>
Category::Blue => false, skill.colours().contains(&Colour::Red) ||
Category::Red => true, [Skill::Attack, Skill::Stun].contains(&skill),
_ => false,
},
Effect::Banish => true, Effect::Banish => true,
Effect::Clutch => [ Effect::Clutch => [
Skill::Stun, Skill::Stun,
@ -392,16 +396,16 @@ impl Effect {
Skill::Strangle, Skill::Strangle,
Skill::Snare Skill::Snare
].contains(&skill), ].contains(&skill),
Effect::Injured => match skill.category() { Effect::Injured => skill.colours().contains(&Colour::Green),
Category::Green => true,
Category::GreenTick => true,
_ => false,
},
_ => false, _ => false,
} }
} }
pub fn disables_skill(&self, skill: Skill) -> bool { pub fn disables_skill(&self, skill: Skill) -> bool {
if skill.is_tick() {
return false;
}
match self { match self {
Effect::Stun => true, Effect::Stun => true,
Effect::Hex => true, Effect::Hex => true,
@ -409,18 +413,9 @@ impl Effect {
Effect::Banish => true, Effect::Banish => true,
Effect::Strangle => true, Effect::Strangle => true,
Effect::Strangling => skill != Skill::StrangleTick, Effect::Strangling => skill != Skill::StrangleTick,
Effect::Silence => skill.components().contains(&Item::Blue), Effect::Silence => skill.colours().contains(&Colour::Blue),
Effect::Snare => match skill.category() { Effect::Snare => skill.colours().contains(&Colour::Red),
Category::Blue => false, Effect::Ko => skill.ko_castable(),
Category::Red => true,
_ => false,
},
Effect::Ko => match skill.category() {
Category::BlueTick => false,
Category::GreenTick => false,
_ => true,
},
_ => false, _ => false,
} }
} }
@ -477,87 +472,64 @@ impl Effect {
} }
} }
pub fn category(&self) -> Category { fn category(&self) -> EffectCategory {
match self { match self {
// physical // physical
Effect::Stun => Category::Debuff, Effect::Stun => EffectCategory::Debuff,
Effect::Block => Category::Buff, Effect::Block => EffectCategory::Buff,
Effect::Buff => Category::Buff, Effect::Buff => EffectCategory::Buff,
Effect::Parry => Category::Buff, Effect::Parry => EffectCategory::Buff,
Effect::Bleed => Category::Debuff, Effect::Vulnerable => EffectCategory::Debuff,
Effect::Leech => Category::Debuff, Effect::Snare => EffectCategory::Debuff,
Effect::Airborne => Category::Debuff, Effect::Clutch => EffectCategory::Buff,
Effect::Untouchable => Category::Buff, Effect::Taunt => EffectCategory::Buff,
Effect::Deadly => Category::Buff, Effect::Strangle => EffectCategory::Debuff,
Effect::Vulnerable => Category::Debuff, Effect::Strangling => EffectCategory::Buff,
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,
// magic // magic
Effect::Hex => Category::Debuff, Effect::Hex => EffectCategory::Debuff,
Effect::Ruin => Category::Debuff, Effect::Ruin => EffectCategory::Debuff,
Effect::Curse => Category::Debuff, Effect::Curse => EffectCategory::Debuff,
Effect::Banish => Category::Debuff, // todo randomise Effect::Banish => EffectCategory::Debuff, // todo randomise
// Effect::Banish => rng.gen_bool(0.5), // Effect::Banish => rng.gen_bool(0.5),
Effect::Slow => Category::Debuff, Effect::Slow => EffectCategory::Debuff,
Effect::Haste => Category::Buff, Effect::Haste => EffectCategory::Buff,
Effect::Hatred => Category::Buff, Effect::Hatred => EffectCategory::Buff,
Effect::Reflect => Category::Buff, Effect::Reflect => EffectCategory::Buff,
Effect::Enslave => Category::Debuff, Effect::Amplify => EffectCategory::Buff,
Effect::Mesmerise => Category::Debuff, Effect::Silence => EffectCategory::Debuff,
Effect::Amplify => Category::Buff, Effect::Wither => EffectCategory::Debuff,
Effect::Silence => Category::Debuff,
Effect::Wither => Category::Debuff,
Effect::Corrupt => Category::Buff, Effect::Corrupt => EffectCategory::Buff,
Effect::Corruption => Category::Debuff, Effect::Corruption => EffectCategory::Debuff,
Effect::Hostility => Category::Buff, Effect::Hostility => EffectCategory::Buff,
// magic // magic
Effect::Impurity => Category::Buff, Effect::Impurity => EffectCategory::Buff,
Effect::Scatter => Category::Buff, Effect::Scatter => EffectCategory::Buff,
Effect::Invert => Category::Buff, Effect::Invert => EffectCategory::Buff,
// effects over time // effects over time
Effect::Triage => Category::Buff, Effect::Triage => EffectCategory::Buff,
Effect::Decay => Category::Debuff, Effect::Decay => EffectCategory::Debuff,
Effect::Regen => Category::Buff, Effect::Regen => EffectCategory::Buff,
Effect::Siphon => Category::Debuff, Effect::Siphon => EffectCategory::Debuff,
Effect::SpeedSiphon => Category::Debuff, // not in game
Effect::SpeedIncrease => Category::Buff, Effect::Injured => EffectCategory::Debuff,
Effect::Ko => Category::Ko, Effect::Ko => EffectCategory::Ko,
} }
} }
} }
#[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)] #[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
pub enum Category { pub enum Colour {
Red, Red,
Blue, Blue,
Green, Green,
RedDamage,
BlueDamage,
GreenDamage,
RedTick,
BlueTick,
GreenTick,
Buff,
Debuff,
Ko,
} }
#[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)] #[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
@ -798,72 +770,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 { pub fn ko_castable(&self) -> bool {
match self { match self {
Skill::TriageTick => true, Skill::TriageTick => true,
@ -874,6 +780,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 { pub fn speed(&self) -> u8 {
match self { match self {
// ----------------- // -----------------
@ -944,8 +861,30 @@ impl Skill {
} }
} }
pub fn components(&self) -> Vec<Item> { fn components(&self) -> Vec<Item> {
Item::from(*self).components() let mut components = Item::from(*self).components();
components.sort_unstable();
return components;
}
fn colours(&self) -> Vec<Colour> {
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::<Vec<Colour>>();
}
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),
}
} }
} }
@ -1096,9 +1035,9 @@ fn snare(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, skill:
let s_multi = target.skills let s_multi = target.skills
.iter() .iter()
.fold(100, |acc, cs| match cs.skill.category() { .fold(100, |acc, cs| match cs.skill.colours().contains(&Colour::Red) {
Category::Red => acc + 35, true => acc + 35,
_ => acc, false => acc,
}); });
let amount = source.red_damage().pct(skill.multiplier()).pct(s_multi); let amount = source.red_damage().pct(skill.multiplier()).pct(s_multi);
@ -1356,10 +1295,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 mut scatter_target = game.cryp_by_id(scatter_target_id).unwrap();
let res = match colour { let res = match colour {
Category::RedDamage => scatter_target.deal_red_damage(skill, amount), Colour::Red => scatter_target.deal_red_damage(skill, amount),
Category::BlueDamage => scatter_target.deal_blue_damage(skill, amount), Colour::Blue => scatter_target.deal_blue_damage(skill, amount),
Category::GreenDamage => scatter_target.deal_green_damage(skill, amount), Colour::Green => scatter_target.deal_green_damage(skill, amount),
_ => panic!("{:?} unknown damage type", colour),
}; };
results.push(Resolution::new(target, scatter_target).event(Event::Skill { skill: Skill::Scatter })); results.push(Resolution::new(target, scatter_target).event(Event::Skill { skill: Skill::Scatter }));
@ -1380,9 +1318,9 @@ fn silence(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, skill
let s_multi = target.skills let s_multi = target.skills
.iter() .iter()
.fold(100, |acc, cs| match cs.skill.category() { .fold(100, |acc, cs| match cs.skill.colours().contains(&Colour::Blue) {
Category::Blue => acc + 45, true => acc + 45,
_ => acc, false => acc,
}); });
let amount = source.blue_damage().pct(skill.multiplier()).pct(s_multi); let amount = source.blue_damage().pct(skill.multiplier()).pct(s_multi);
@ -1396,7 +1334,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 { fn purge(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, _skill: Skill) -> Resolutions {
while let Some(i) = target.effects while let Some(i) = target.effects
.iter() .iter()
.position(|ce| [Category::Buff, Category::Buff].contains(&ce.effect.category())) { .position(|ce| ce.effect.category() == EffectCategory::Buff) {
let ce = target.effects.remove(i); let ce = target.effects.remove(i);
results.push(Resolution::new(source, target).event(Event::Removal { effect: ce.effect })); results.push(Resolution::new(source, target).event(Event::Removal { effect: ce.effect }));
} }
@ -1409,7 +1347,7 @@ fn purify(source: &mut Cryp, target: &mut Cryp, mut results: Resolutions, skill:
let amount = source.green_damage().pct(skill.multiplier()); let amount = source.green_damage().pct(skill.multiplier());
while let Some(i) = target.effects while let Some(i) = target.effects
.iter() .iter()
.position(|ce| Category::Debuff == ce.effect.category()) { .position(|ce| ce.effect.category() == EffectCategory::Debuff) {
let ce = target.effects.remove(i); let ce = target.effects.remove(i);
results.push(Resolution::new(source, target).event(Event::Removal { effect: ce.effect })); results.push(Resolution::new(source, target).event(Event::Removal { effect: ce.effect }));
target.deal_green_damage(skill, amount) target.deal_green_damage(skill, amount)