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

remove categories

Browse Source
This commit is contained in:
ntr 2019-05-22 17:22:35 +10:00
parent 585bafe45e
commit cf3cef3f31
4 changed files with 156 additions and 203 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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};
@ -560,7 +560,7 @@ impl Cryp {
skill, skill,
amount: delta, amount: delta,
mitigation: 0, mitigation: 0,
colour: Category::GreenDamage, colour: Colour::Green,
}); });
} }
} }
@ -613,7 +613,7 @@ impl Cryp {
skill, skill,
amount: delta, amount: delta,
mitigation, mitigation,
colour: Category::RedDamage, colour: Colour::Red,
}); });
}, },
true => { true => {
@ -688,7 +688,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()

17
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
@ -502,6 +511,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,

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,65 +472,55 @@ 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,
} }
} }
} }
@ -547,23 +532,10 @@ pub enum SkillEffect {
} }
#[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)]
@ -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 { pub fn ko_castable(&self) -> bool {
match self { match self {
Skill::TriageTick => true, 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 { pub fn speed(&self) -> u8 {
match self { match self {
// ----------------- // -----------------
@ -983,8 +900,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),
}
} }
} }
@ -1128,9 +1067,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);
@ -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 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 }));
@ -1398,9 +1336,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);
@ -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 { 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 }));
} }
@ -1427,7 +1365,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)