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 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 => {

22
server/src/game.rs
View File

@ -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<Player>, game_id: Uu
Ok(game)
}
pub fn game_instance_join(tx: &mut Transaction, player: Player, game_id: Uuid) -> Result<Game, Error> {
let mut game = game_get(tx, game_id)?;
// pub fn game_instance_join(tx: &mut Transaction, player: Player, game_id: Uuid) -> Result<Game, Error> {
// 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()

17
server/src/item.rs
View File

@ -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<Skill> 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,

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();
// 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<Resolution>;
pub type Cooldown = Option<u8>;
#[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> {
Item::from(*self).components()
fn components(&self) -> Vec<Item> {
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
.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)