1313 lines
36 KiB
Rust
1313 lines
36 KiB
Rust
use rand::{thread_rng, Rng};
|
|
use uuid::Uuid;
|
|
|
|
use game::{Log};
|
|
use cryp::{Cryp, CrypEffect, Stat};
|
|
|
|
#[derive(Debug,Clone,PartialEq,Serialize,Deserialize)]
|
|
pub struct Cast {
|
|
pub id: Uuid,
|
|
pub skill: Skill,
|
|
pub source_team_id: Uuid,
|
|
pub source_cryp_id: Uuid,
|
|
pub target_cryp_id: Option<Uuid>,
|
|
pub target_team_id: Uuid,
|
|
pub resolution: Resolution,
|
|
}
|
|
|
|
impl Cast {
|
|
pub fn new(source_cryp_id: Uuid, source_team_id: Uuid, target_team_id: Option<Uuid>, skill: Skill) -> Cast {
|
|
|
|
let (target_cryp_id, target_team_id) = match skill.self_targeting() {
|
|
true => (Some(source_cryp_id), source_team_id),
|
|
false => (None, target_team_id.unwrap())
|
|
};
|
|
|
|
return Cast {
|
|
id: Uuid::new_v4(),
|
|
source_cryp_id,
|
|
source_team_id,
|
|
target_cryp_id,
|
|
target_team_id,
|
|
skill,
|
|
resolution: Resolution { skill, results: vec![] },
|
|
};
|
|
}
|
|
|
|
pub fn new_tick(source: &mut Cryp, target: &mut Cryp, skill: Skill) -> Cast {
|
|
let mut cast = Cast::new(source.id, source.account, Some(target.account), skill);
|
|
cast.set_target(target.id);
|
|
return cast;
|
|
}
|
|
|
|
pub fn set_resolution(&mut self, cryp: &mut Cryp, target: &mut Cryp) -> &mut Cast {
|
|
self.resolution = self.skill.resolve(cryp, target);
|
|
self
|
|
}
|
|
|
|
pub fn set_target(&mut self, cryp_id: Uuid) -> &mut Cast {
|
|
self.target_cryp_id = Some(cryp_id);
|
|
self
|
|
}
|
|
|
|
pub fn used_cooldown(&self) -> bool {
|
|
return self.skill.cd().is_some();
|
|
}
|
|
}
|
|
|
|
|
|
#[derive(Debug,Clone,PartialEq,Serialize,Deserialize)]
|
|
pub struct Immunity {
|
|
pub immune: bool,
|
|
pub effects: Vec<Effect>
|
|
}
|
|
|
|
#[derive(Debug,Clone,PartialEq,Serialize,Deserialize)]
|
|
pub enum ResolutionResult {
|
|
Damage { amount: u64, category: Category , immunity: Immunity },
|
|
Effect { effect: Effect, duration: u8, immunity: Immunity },
|
|
Removal { effect: Effect, immunity: Immunity },
|
|
}
|
|
|
|
#[derive(Debug,Clone,PartialEq,Serialize,Deserialize)]
|
|
pub struct Resolution {
|
|
pub skill: Skill,
|
|
pub results: Vec<ResolutionResult>,
|
|
}
|
|
|
|
pub type Cooldown = Option<u8>;
|
|
|
|
#[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
|
|
pub enum Effect {
|
|
// physical
|
|
Stun,
|
|
Block,
|
|
Bleed,
|
|
Leech,
|
|
Airborne,
|
|
Untouchable,
|
|
Deadly,
|
|
Vulnerable,
|
|
Fury,
|
|
Evasion,
|
|
Blind,
|
|
Snare,
|
|
|
|
Empower,
|
|
|
|
// magic
|
|
Hex,
|
|
Curse,
|
|
Banish,
|
|
Slow,
|
|
Haste,
|
|
Enslave,
|
|
Mesmerise,
|
|
Amplify,
|
|
Silence,
|
|
|
|
// magic immunity
|
|
Shield,
|
|
|
|
// effects over time
|
|
Triage,
|
|
Decay,
|
|
Regen,
|
|
Drain,
|
|
|
|
SpeedDrain,
|
|
SpeedIncrease,
|
|
|
|
Ko,
|
|
}
|
|
|
|
impl Effect {
|
|
pub fn immune(&self, skill: Skill) -> bool {
|
|
match self {
|
|
Effect::Block => match skill {
|
|
Skill::Stun |
|
|
Skill::TestStun |
|
|
Skill::Attack => true,
|
|
_ => false,
|
|
},
|
|
Effect::Shield => match skill.category() {
|
|
Category::Spell => true,
|
|
Category::Physical => false,
|
|
_ => false,
|
|
},
|
|
Effect::Banish => true,
|
|
_ => false,
|
|
}
|
|
}
|
|
|
|
pub fn prevents_casting(&self, skill: Skill) -> bool {
|
|
match self {
|
|
Effect::Stun => true,
|
|
Effect::Silence => match skill.category() {
|
|
Category::Spell => true,
|
|
Category::Physical => false,
|
|
_ => false,
|
|
},
|
|
_ => false,
|
|
}
|
|
}
|
|
|
|
pub fn modifications(&self) -> Vec<Stat> {
|
|
match self {
|
|
Effect::Amplify => vec![Stat::SpellDmg],
|
|
Effect::Empower => vec![Stat::PhysDmg],
|
|
_ => vec![],
|
|
}
|
|
}
|
|
|
|
// maybe increase by rng
|
|
// roll little endian bits
|
|
// and OR with base stat
|
|
pub fn apply(&self, value: u64) -> u64 {
|
|
match self {
|
|
Effect::Amplify => value << 1,
|
|
Effect::Empower => value << 1,
|
|
_ => panic!("{:?} does not have a mod effect", self),
|
|
}
|
|
}
|
|
|
|
pub fn category(&self) -> Category {
|
|
match self {
|
|
// physical
|
|
Effect::Stun => Category::PhysDebuff,
|
|
Effect::Block => Category::PhysBuff,
|
|
Effect::Bleed => Category::PhysDebuff,
|
|
Effect::Leech => Category::PhysDebuff,
|
|
Effect::Airborne => Category::PhysDebuff,
|
|
Effect::Untouchable => Category::PhysBuff,
|
|
Effect::Deadly => Category::PhysBuff,
|
|
Effect::Vulnerable => Category::PhysDebuff,
|
|
Effect::Fury => Category::PhysBuff,
|
|
Effect::Evasion => Category::PhysBuff,
|
|
Effect::Blind => Category::PhysDebuff,
|
|
Effect::Snare => Category::PhysDebuff,
|
|
|
|
Effect::Empower => Category::PhysBuff,
|
|
|
|
// magic
|
|
Effect::Hex => Category::SpellDebuff,
|
|
Effect::Curse => Category::SpellDebuff,
|
|
Effect::Banish => Category::SpellDebuff, // todo randomise
|
|
Effect::Slow => Category::SpellDebuff,
|
|
Effect::Haste => Category::SpellBuff,
|
|
Effect::Enslave => Category::SpellDebuff,
|
|
Effect::Mesmerise => Category::SpellDebuff,
|
|
Effect::Amplify => Category::SpellBuff,
|
|
Effect::Silence => Category::SpellDebuff,
|
|
|
|
// magic immunity
|
|
Effect::Shield => Category::SpellBuff,
|
|
|
|
// effects over time
|
|
Effect::Triage => Category::SpellBuff,
|
|
Effect::Decay => Category::SpellDebuff,
|
|
Effect::Regen => Category::SpellBuff,
|
|
Effect::Drain => Category::SpellDebuff,
|
|
|
|
Effect::SpeedDrain => Category::SpellDebuff,
|
|
Effect::SpeedIncrease => Category::SpellBuff,
|
|
|
|
Effect::Ko => Category::Ko,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
|
|
pub enum Category {
|
|
Physical,
|
|
PhysHeal,
|
|
PhysDmg,
|
|
PhysDebuff,
|
|
PhysBuff,
|
|
Spell,
|
|
SpellDmg,
|
|
SpellHeal,
|
|
SpellDebuff,
|
|
SpellBuff,
|
|
Ko,
|
|
}
|
|
|
|
#[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
|
|
pub enum Skill {
|
|
Attack,
|
|
|
|
// -----------------
|
|
// Nature
|
|
// -----------------
|
|
Block, // reduce dmg
|
|
Parry, // avoid all dmg
|
|
Snare,
|
|
|
|
Paralyse,
|
|
|
|
Strangle, // physical dot and disable
|
|
|
|
Stun,
|
|
Evade, // actively evade
|
|
Evasion, // adds evasion to cryp
|
|
|
|
|
|
// -----------------
|
|
// Technology
|
|
// -----------------
|
|
Replicate,
|
|
Swarm,
|
|
Orbit,
|
|
Repair,
|
|
Scan, // track?
|
|
|
|
// -----------------
|
|
// Nonviolence
|
|
// -----------------
|
|
Heal,
|
|
Triage, // hot
|
|
TriageTick,
|
|
Throw, // no dmg stun, adds vulnerable
|
|
Charm,
|
|
Calm,
|
|
Rez,
|
|
|
|
// -------------------
|
|
// Destruction
|
|
// -------------------
|
|
Blast,
|
|
Amplify,
|
|
Decay, // dot
|
|
DecayTick, // dot
|
|
Drain,
|
|
DrainTick,
|
|
Curse,
|
|
Plague, // aoe dot
|
|
Ruin, // aoe
|
|
|
|
// -----------------
|
|
// Purity
|
|
// -----------------
|
|
Empower,
|
|
Slay,
|
|
Shield,
|
|
Silence,
|
|
Inquiry,
|
|
Purify,
|
|
Purge,
|
|
// Precision,
|
|
|
|
// -----------------
|
|
// Chaos
|
|
// -----------------
|
|
Banish,
|
|
Hex,
|
|
Fear,
|
|
Taunt,
|
|
Pause, // speed slow
|
|
|
|
// used by tests, no cd, no dmg
|
|
TestTouch,
|
|
TestStun,
|
|
TestBlock,
|
|
TestDrain,
|
|
}
|
|
|
|
impl Skill {
|
|
pub fn cd(&self) -> Cooldown {
|
|
match self {
|
|
Skill::Attack => None,
|
|
|
|
// -----------------
|
|
// Nature
|
|
// -----------------
|
|
Skill::Block => Some(1), // reduce dmg
|
|
Skill::Parry => Some(1), // avoid all dmg
|
|
Skill::Snare => Some(2),
|
|
|
|
Skill::Paralyse => Some(3),
|
|
Skill::Strangle => Some(3),
|
|
|
|
// Strangle
|
|
|
|
Skill::Stun => Some(1),
|
|
Skill::Evade => Some(2),
|
|
Skill::Evasion => Some(3), // additional layer of dmg avoidance
|
|
|
|
// -----------------
|
|
// Technology
|
|
// -----------------
|
|
Skill::Replicate => Some(1),
|
|
Skill::Swarm => Some(3),
|
|
Skill::Orbit => Some(2),
|
|
Skill::Repair => Some(1),
|
|
Skill::Scan => Some(2), // track?
|
|
|
|
// -----------------
|
|
// Preservation
|
|
// -----------------
|
|
Skill::Heal => Some(1),
|
|
Skill::Triage => Some(1), // hot
|
|
Skill::TriageTick => None,
|
|
Skill::Throw => Some(2), // no dmg stun, adds vulnerable
|
|
Skill::Charm => Some(2),
|
|
Skill::Calm => Some(2),
|
|
Skill::Rez => Some(4),
|
|
|
|
// -----------------
|
|
// Destruction
|
|
// -----------------
|
|
Skill::Blast => Some(1),
|
|
Skill::Amplify => Some(2),
|
|
Skill::Decay => Some(1), // dot
|
|
Skill::DecayTick => None,
|
|
Skill::Drain => Some(2),
|
|
Skill::DrainTick => None,
|
|
Skill::Curse => Some(2),
|
|
Skill::Plague => Some(2), // aoe dot
|
|
Skill::Ruin => Some(3), // aoe
|
|
|
|
// -----------------
|
|
// Purity
|
|
// -----------------
|
|
// Skill::Precision => Some(1),
|
|
Skill::Empower => Some(2),
|
|
Skill::Slay => Some(1),
|
|
Skill::Shield => Some(1),
|
|
Skill::Silence => Some(2),
|
|
Skill::Inquiry => Some(2),
|
|
Skill::Purify => Some(1),
|
|
Skill::Purge => Some(1),
|
|
|
|
// -----------------
|
|
// Chaos
|
|
// -----------------
|
|
Skill::Banish => Some(2),
|
|
Skill::Hex => Some(1),
|
|
Skill::Fear => Some(1),
|
|
Skill::Taunt => Some(2),
|
|
Skill::Pause => Some(2), // speed slow
|
|
|
|
// -----------------
|
|
// Test
|
|
// -----------------
|
|
Skill::TestTouch => None,
|
|
Skill::TestStun => None,
|
|
Skill::TestBlock => None,
|
|
Skill::TestDrain => None,
|
|
}
|
|
}
|
|
|
|
pub fn category(&self) -> Category {
|
|
match self {
|
|
Skill::Attack => Category::Physical,
|
|
|
|
// -----------------
|
|
// Nature
|
|
// -----------------
|
|
Skill::Block => Category::Physical, // reduce dmg
|
|
Skill::Evade => Category::Physical,
|
|
Skill::Parry => Category::Physical, // avoid all dmg
|
|
Skill::Snare => Category::Physical,
|
|
|
|
Skill::Paralyse => Category::Physical,
|
|
Skill::Strangle => Category::Physical,
|
|
|
|
// Strangle
|
|
|
|
Skill::Stun => Category::Physical,
|
|
Skill::Evasion => Category::Physical, // additional layer of dmg avoidance
|
|
|
|
// -----------------
|
|
// Technology
|
|
// -----------------
|
|
Skill::Replicate => Category::Physical,
|
|
Skill::Swarm => Category::Physical,
|
|
Skill::Orbit => Category::Physical,
|
|
Skill::Repair => Category::Physical,
|
|
Skill::Scan => Category::Physical, // track?
|
|
|
|
// -----------------
|
|
// Preservation
|
|
// -----------------
|
|
Skill::Heal => Category::Physical,
|
|
Skill::Triage => Category::Physical, // hot
|
|
Skill::TriageTick => Category::Physical, // hot
|
|
Skill::Throw => Category::Physical, // no dmg stun, adds vulnerable
|
|
Skill::Charm => Category::Physical,
|
|
Skill::Calm => Category::Physical,
|
|
Skill::Rez => Category::Physical,
|
|
|
|
// -----------------
|
|
// Destruction
|
|
// -----------------
|
|
Skill::Blast => Category::Spell,
|
|
Skill::Amplify => Category::Spell,
|
|
Skill::Decay => Category::Spell, // dot
|
|
Skill::DecayTick => Category::Spell, // hot
|
|
Skill::Drain => Category::Spell,
|
|
Skill::DrainTick => Category::Spell, // hot
|
|
Skill::Curse => Category::Spell,
|
|
Skill::Plague => Category::Spell, // aoe dot
|
|
Skill::Ruin => Category::Spell, // aoe
|
|
|
|
// -----------------
|
|
// Purity
|
|
// -----------------
|
|
// Skill::Precision => 1,
|
|
Skill::Empower => Category::Physical,
|
|
Skill::Slay => Category::Physical,
|
|
Skill::Shield => Category::Spell,
|
|
Skill::Silence => Category::Spell,
|
|
Skill::Inquiry => Category::Spell,
|
|
Skill::Purify => Category::Spell,
|
|
Skill::Purge => Category::Spell,
|
|
|
|
// -----------------
|
|
// Chaos
|
|
// -----------------
|
|
Skill::Banish => Category::Spell,
|
|
Skill::Hex => Category::Spell,
|
|
Skill::Fear => Category::Spell,
|
|
Skill::Taunt => Category::Spell,
|
|
Skill::Pause => Category::Spell, // extend durations
|
|
// Skill::Lag => 2, //
|
|
|
|
// -----------------
|
|
// Test
|
|
// -----------------
|
|
Skill::TestTouch => Category::Physical,
|
|
Skill::TestStun => Category::Physical,
|
|
Skill::TestBlock => Category::Physical,
|
|
Skill::TestDrain => Category::Spell,
|
|
}
|
|
}
|
|
|
|
pub fn speed(&self) -> u8 {
|
|
match self {
|
|
Skill::Attack => 5,
|
|
|
|
// -----------------
|
|
// Nature
|
|
// -----------------
|
|
Skill::Block => 10, // reduce dmg
|
|
Skill::Evade => 10,
|
|
Skill::Parry => 10, // avoid all dmg
|
|
Skill::Snare => 10,
|
|
|
|
Skill::Paralyse => 5,
|
|
Skill::Strangle => 5,
|
|
|
|
// Strangle
|
|
|
|
Skill::Stun => 5,
|
|
Skill::Evasion => 3, // additional layer of dmg avoidance
|
|
|
|
// -----------------
|
|
// Technology
|
|
// -----------------
|
|
Skill::Replicate => 1,
|
|
Skill::Swarm => 3,
|
|
Skill::Orbit => 2,
|
|
Skill::Repair => 1,
|
|
Skill::Scan => 2, // track?
|
|
|
|
// -----------------
|
|
// Preservation
|
|
// -----------------
|
|
Skill::Heal => 1,
|
|
Skill::Triage => 1, // hot
|
|
Skill::TriageTick => 1, // hot
|
|
Skill::Throw => 2, // no dmg stun, adds vulnerable
|
|
Skill::Charm => 2,
|
|
Skill::Calm => 2,
|
|
Skill::Rez => 4,
|
|
|
|
// -----------------
|
|
// Destruction
|
|
// -----------------
|
|
Skill::Blast => 1,
|
|
Skill::Amplify => 2,
|
|
Skill::Decay => 1, // dot
|
|
Skill::DecayTick => 2, // hot
|
|
Skill::Drain => 2,
|
|
Skill::DrainTick => 2, // hot
|
|
Skill::Curse => 2,
|
|
Skill::Plague => 2, // aoe dot
|
|
Skill::Ruin => 3, // aoe
|
|
|
|
// -----------------
|
|
// Purity
|
|
// -----------------
|
|
// Skill::Precision => 1,
|
|
Skill::Empower => 2,
|
|
Skill::Slay => 1,
|
|
Skill::Shield => 1,
|
|
Skill::Silence => 2,
|
|
Skill::Inquiry => 2,
|
|
Skill::Purify => 1,
|
|
Skill::Purge => 1,
|
|
|
|
// -----------------
|
|
// Chaos
|
|
// -----------------
|
|
Skill::Banish => 2,
|
|
Skill::Hex => 1,
|
|
Skill::Fear => 1,
|
|
Skill::Taunt => 2,
|
|
Skill::Pause => 2, // extend durations
|
|
// Skill::Lag => 2, //
|
|
|
|
// -----------------
|
|
// Test
|
|
// -----------------
|
|
Skill::TestTouch => 10,
|
|
Skill::TestStun => 5,
|
|
Skill::TestBlock => 10,
|
|
Skill::TestDrain => 10,
|
|
}
|
|
}
|
|
|
|
pub fn resolve(&self, cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
|
|
let mut rng = thread_rng();
|
|
let base: u64 = rng.gen();
|
|
|
|
match self {
|
|
Skill::Attack => attack(cryp, target),
|
|
// -----------------
|
|
// Nature
|
|
// -----------------
|
|
Skill::Block => block(cryp, target),
|
|
Skill::Evade => panic!("nyi"), //
|
|
Skill::Parry => panic!("nyi"), // avoid all dmg
|
|
Skill::Snare => snare(cryp, target), // TODO prevent physical moves
|
|
|
|
Skill::Paralyse => panic!("nyi"), // no physical moves
|
|
Skill::Strangle => panic!("nyi"), // no physical moves
|
|
|
|
Skill::Stun => stun(cryp, target),
|
|
Skill::Evasion => panic!("nyi"), // additional layer of dmg avoidance
|
|
|
|
// -----------------
|
|
// Technology
|
|
// -----------------
|
|
Skill::Replicate => panic!("nyi"),
|
|
Skill::Swarm => panic!("nyi"),
|
|
Skill::Orbit => panic!("nyi"),
|
|
Skill::Repair => panic!("nyi"),
|
|
Skill::Scan => panic!("nyi"), // track?
|
|
|
|
// -----------------
|
|
// Preservation
|
|
// -----------------
|
|
Skill::Heal => heal(cryp, target),
|
|
Skill::Triage => triage(cryp, target), // hot
|
|
Skill::TriageTick => triage_tick(cryp, target), // hot
|
|
Skill::Throw => throw(cryp, target), // no dmg stun, adds vulnerable
|
|
Skill::Charm => panic!("nyi"), // target casts random spell on teammate
|
|
Skill::Calm => panic!("nyi"), // physical fear, taunt removal
|
|
Skill::Rez => panic!("nyi"),
|
|
|
|
// -----------------
|
|
// Destruction
|
|
// -----------------
|
|
Skill::Blast => blast(cryp, target),
|
|
Skill::Amplify => amplify(cryp, target), // increase magic dmg
|
|
Skill::Decay => decay(cryp, target), // dot
|
|
Skill::DecayTick => decay_tick(cryp, target), // hot
|
|
Skill::Drain => drain(cryp, target),
|
|
Skill::DrainTick => drain_tick(cryp, target), // hot
|
|
Skill::Curse => curse(cryp, target),
|
|
Skill::Plague => panic!("nyi"), // dot that spreads every turn
|
|
Skill::Ruin => panic!("nyi"), // aoe version of blast
|
|
|
|
// -----------------
|
|
// Purity
|
|
// -----------------
|
|
// Skill::Precision => panic!("nyi"),
|
|
Skill::Empower => empower(cryp, target), // increased phys dmg
|
|
Skill::Slay => panic!("nyi"), // phys dmg mult by target magic dmg
|
|
Skill::Shield => shield(cryp, target), // target is immune to magic dmg and fx
|
|
Skill::Silence => silence(cryp, target), // target cannot cast spells
|
|
Skill::Inquiry => panic!("nyi"), //
|
|
Skill::Purify => purify(cryp, target), // dispel all debuffs
|
|
Skill::Purge => purge(cryp, target), // dispel all buffs
|
|
|
|
// -----------------
|
|
// Chaos
|
|
// -----------------
|
|
Skill::Banish => banish(cryp, target), // TODO prevent all actions
|
|
Skill::Hex => hex(cryp, target), // todo prevent casting
|
|
Skill::Fear => panic!("nyi"), // cast random spell on self
|
|
Skill::Taunt => panic!("nyi"), // target forced to attack
|
|
Skill::Pause => panic!("nyi"), // speed slow
|
|
|
|
// -----------------
|
|
// Test
|
|
// -----------------
|
|
Skill::TestTouch => Resolution { skill: Skill::TestTouch, results: vec![] },
|
|
Skill::TestStun => stun(cryp, target),
|
|
Skill::TestBlock => block(cryp, target),
|
|
Skill::TestDrain => drain(cryp, target),
|
|
}
|
|
}
|
|
|
|
pub fn duration(&self) -> u8 {
|
|
match self {
|
|
Skill::Evade => 1,
|
|
Skill::Stun => 2,
|
|
Skill::Block => 1,
|
|
|
|
Skill::Empower => 2,
|
|
|
|
Skill::Decay => 3,
|
|
Skill::Drain => 3,
|
|
Skill::Triage => 3,
|
|
|
|
Skill::Amplify => 2,
|
|
Skill::Silence => 3,
|
|
|
|
Skill::TestBlock => 1,
|
|
Skill::TestStun => 2,
|
|
_ => {
|
|
println!("{:?} does not have a duration", self);
|
|
return 2;
|
|
},
|
|
}
|
|
}
|
|
|
|
pub fn self_targeting(&self) -> bool {
|
|
match self {
|
|
Skill::Block => true,
|
|
Skill::TestBlock => true,
|
|
_ => false,
|
|
}
|
|
}
|
|
|
|
pub fn castable(&self, cryp: &Cryp) -> bool {
|
|
!cryp.effects.iter().any(|e| e.effect.prevents_casting(*self))
|
|
}
|
|
}
|
|
|
|
fn attack(cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
|
|
let amount = cryp.phys_dmg();
|
|
let immunity = target.immune(Skill::Attack);
|
|
let immune = immunity.immune;
|
|
|
|
let attack_result = ResolutionResult::Damage {
|
|
amount,
|
|
category: Category::PhysDmg,
|
|
immunity,
|
|
};
|
|
|
|
let resolution = Resolution { skill: Skill::Attack, results: vec![attack_result] };
|
|
|
|
if !immune {
|
|
target.deal_phys_dmg(amount);
|
|
}
|
|
|
|
|
|
return resolution;
|
|
}
|
|
|
|
fn stun(_cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
|
|
let stun = CrypEffect { effect: Effect::Stun, duration: Skill::Stun.duration(), tick: None };
|
|
let immunity = target.immune(Skill::Stun);
|
|
let immune = immunity.immune;
|
|
|
|
let attack_result = ResolutionResult::Effect {
|
|
effect: stun.effect,
|
|
duration: stun.duration,
|
|
immunity,
|
|
};
|
|
|
|
let resolution = Resolution { skill: Skill::Stun, results: vec![attack_result] };
|
|
|
|
if !immune {
|
|
target.effects.push(stun);
|
|
}
|
|
|
|
return resolution;
|
|
}
|
|
|
|
fn throw(_cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
|
|
let stun = CrypEffect { effect: Effect::Stun, duration: Skill::Stun.duration(), tick: None };
|
|
let vulnerable = CrypEffect { effect: Effect::Vulnerable, duration: Skill::Stun.duration(), tick: None };
|
|
let immunity = target.immune(Skill::Throw);
|
|
let immune = immunity.immune;
|
|
|
|
let stun_result = ResolutionResult::Effect {
|
|
effect: stun.effect,
|
|
duration: stun.duration,
|
|
immunity: immunity.clone(),
|
|
};
|
|
|
|
let vulnerable_result = ResolutionResult::Effect {
|
|
effect: vulnerable.effect,
|
|
duration: vulnerable.duration,
|
|
immunity,
|
|
};
|
|
|
|
let resolution = Resolution { skill: Skill::Throw, results: vec![stun_result, vulnerable_result] };
|
|
|
|
if !immune {
|
|
target.effects.push(stun);
|
|
target.effects.push(vulnerable);
|
|
}
|
|
|
|
return resolution;
|
|
}
|
|
|
|
|
|
fn block(_cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
|
|
let block = CrypEffect { effect: Effect::Block, duration: Skill::Block.duration(), tick: None };
|
|
let immunity = target.immune(Skill::Block);
|
|
let immune = immunity.immune;
|
|
|
|
let block_result = ResolutionResult::Effect {
|
|
effect: block.effect,
|
|
duration: block.duration,
|
|
immunity,
|
|
};
|
|
|
|
let resolution = Resolution { skill: Skill::Block, results: vec![block_result] };
|
|
|
|
if !immune {
|
|
target.effects.push(block);
|
|
}
|
|
|
|
return resolution;
|
|
}
|
|
|
|
fn snare(_cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
|
|
let snare = CrypEffect { effect: Effect::Snare, duration: Skill::Snare.duration(), tick: None };
|
|
let immunity = target.immune(Skill::Snare);
|
|
let immune = immunity.immune;
|
|
|
|
let snare_result = ResolutionResult::Effect {
|
|
effect: snare.effect,
|
|
duration: snare.duration,
|
|
immunity,
|
|
};
|
|
|
|
let resolution = Resolution { skill: Skill::Snare, results: vec![snare_result] };
|
|
|
|
if !immune {
|
|
target.effects.push(snare);
|
|
}
|
|
|
|
return resolution;
|
|
}
|
|
|
|
fn empower(_cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
|
|
let empower = CrypEffect { effect: Effect::Empower, duration: Skill::Empower.duration(), tick: None };
|
|
let immunity = target.immune(Skill::Empower);
|
|
let immune = immunity.immune;
|
|
|
|
let snare_result = ResolutionResult::Effect {
|
|
effect: empower.effect,
|
|
duration: empower.duration,
|
|
immunity,
|
|
};
|
|
|
|
let resolution = Resolution { skill: Skill::Empower, results: vec![snare_result] };
|
|
|
|
if !immune {
|
|
target.effects.push(empower);
|
|
}
|
|
|
|
return resolution;
|
|
}
|
|
|
|
// TODO put overhealing back
|
|
fn heal(cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
|
|
let amount = cryp.phys_dmg();
|
|
let immunity = target.immune(Skill::Heal);
|
|
let immune = immunity.immune;
|
|
|
|
let heal_result = ResolutionResult::Damage {
|
|
amount,
|
|
category: Category::PhysHeal,
|
|
immunity,
|
|
};
|
|
|
|
let resolution = Resolution { skill: Skill::Heal, results: vec![heal_result] };
|
|
|
|
if !immune {
|
|
let (_healing, _overhealing) = target.heal(amount);
|
|
}
|
|
|
|
|
|
return resolution;
|
|
|
|
}
|
|
|
|
fn triage(cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
|
|
let triage = CrypEffect {
|
|
effect: Effect::Triage,
|
|
duration: Skill::Triage.duration(),
|
|
tick: Some(Cast::new_tick(cryp, target, Skill::TriageTick)),
|
|
};
|
|
let immunity = target.immune(Skill::Triage);
|
|
let immune = immunity.immune;
|
|
|
|
let snare_result = ResolutionResult::Effect {
|
|
effect: triage.effect,
|
|
duration: triage.duration,
|
|
immunity,
|
|
};
|
|
|
|
let resolution = Resolution { skill: Skill::Triage, results: vec![snare_result] };
|
|
|
|
if !immune {
|
|
target.effects.push(triage);
|
|
}
|
|
|
|
return resolution;
|
|
}
|
|
|
|
fn triage_tick(cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
|
|
let amount = cryp.spell_dmg().wrapping_div(2);
|
|
let immunity = target.immune(Skill::TriageTick);
|
|
let immune = immunity.immune;
|
|
|
|
let heal_result = ResolutionResult::Damage {
|
|
amount,
|
|
category: Category::PhysHeal,
|
|
immunity,
|
|
};
|
|
|
|
let resolution = Resolution { skill: Skill::TriageTick, results: vec![heal_result] };
|
|
|
|
if !immune {
|
|
let (_healing, _overhealing) = target.heal(amount);
|
|
}
|
|
|
|
|
|
return resolution;
|
|
}
|
|
|
|
fn blast(cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
|
|
let amount = cryp.spell_dmg();
|
|
let immunity = target.immune(Skill::Blast);
|
|
let immune = immunity.immune;
|
|
|
|
let blast_result = ResolutionResult::Damage {
|
|
amount,
|
|
category: Category::SpellDmg,
|
|
immunity,
|
|
};
|
|
|
|
let resolution = Resolution { skill: Skill::Blast, results: vec![blast_result] };
|
|
|
|
if !immune {
|
|
target.deal_spell_dmg(amount);
|
|
}
|
|
|
|
return resolution;
|
|
}
|
|
|
|
fn amplify(_cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
|
|
let amplify = CrypEffect { effect: Effect::Amplify, duration: Skill::Amplify.duration(), tick: None };
|
|
let immunity = target.immune(Skill::Amplify);
|
|
let immune = immunity.immune;
|
|
|
|
let amplify_result = ResolutionResult::Effect {
|
|
effect: amplify.effect,
|
|
duration: amplify.duration,
|
|
immunity,
|
|
};
|
|
|
|
let resolution = Resolution { skill: Skill::Amplify, results: vec![amplify_result] };
|
|
|
|
if !immune {
|
|
target.effects.push(amplify);
|
|
}
|
|
|
|
return resolution;;
|
|
}
|
|
|
|
fn decay(cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
|
|
let decay = CrypEffect {
|
|
effect: Effect::Decay,
|
|
duration: Skill::Decay.duration(),
|
|
tick: Some(Cast::new_tick(cryp, target, Skill::DecayTick)),
|
|
};
|
|
let immunity = target.immune(Skill::Empower);
|
|
let immune = immunity.immune;
|
|
|
|
let decay_result = ResolutionResult::Effect {
|
|
effect: decay.effect,
|
|
duration: decay.duration,
|
|
immunity,
|
|
};
|
|
|
|
let resolution = Resolution { skill: Skill::Decay, results: vec![decay_result] };
|
|
|
|
if !immune {
|
|
target.effects.push(decay);
|
|
}
|
|
|
|
return resolution;
|
|
}
|
|
|
|
fn decay_tick(cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
|
|
let amount = cryp.spell_dmg();
|
|
let immunity = target.immune(Skill::DecayTick);
|
|
let immune = immunity.immune;
|
|
|
|
let decay_tick_result = ResolutionResult::Damage {
|
|
amount,
|
|
category: Category::SpellDmg,
|
|
immunity,
|
|
};
|
|
|
|
let resolution = Resolution { skill: Skill::DecayTick, results: vec![decay_tick_result] };
|
|
|
|
if !immune {
|
|
target.deal_spell_dmg(amount);
|
|
}
|
|
|
|
return resolution;
|
|
}
|
|
|
|
fn hex(_cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
|
|
let hex = CrypEffect { effect: Effect::Hex, duration: Skill::Hex.duration(), tick: None };
|
|
let immunity = target.immune(Skill::Hex);
|
|
let immune = immunity.immune;
|
|
|
|
let hex_result = ResolutionResult::Effect {
|
|
effect: hex.effect,
|
|
duration: hex.duration,
|
|
immunity,
|
|
};
|
|
|
|
let resolution = Resolution { skill: Skill::Hex, results: vec![hex_result] };
|
|
|
|
if !immune {
|
|
target.effects.push(hex);
|
|
}
|
|
|
|
return resolution;;
|
|
}
|
|
|
|
fn curse(_cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
|
|
let curse = CrypEffect { effect: Effect::Curse, duration: Skill::Curse.duration(), tick: None };
|
|
let immunity = target.immune(Skill::Curse);
|
|
let immune = immunity.immune;
|
|
|
|
let curse_result = ResolutionResult::Effect {
|
|
effect: curse.effect,
|
|
duration: curse.duration,
|
|
immunity,
|
|
};
|
|
|
|
let resolution = Resolution { skill: Skill::Curse, results: vec![curse_result] };
|
|
|
|
if !immune {
|
|
target.effects.push(curse);
|
|
}
|
|
|
|
return resolution;;
|
|
}
|
|
|
|
fn drain(cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
|
|
let drain = CrypEffect {
|
|
effect: Effect::Drain,
|
|
duration: Skill::Drain.duration(),
|
|
tick: Some(Cast::new_tick(cryp, target, Skill::DrainTick)),
|
|
};
|
|
let immunity = target.immune(Skill::Drain);
|
|
let immune = immunity.immune;
|
|
|
|
let drain_result = ResolutionResult::Effect {
|
|
effect: drain.effect,
|
|
duration: drain.duration,
|
|
immunity,
|
|
};
|
|
|
|
let resolution = Resolution { skill: Skill::Drain, results: vec![drain_result] };
|
|
|
|
if !immune {
|
|
target.effects.push(drain);
|
|
}
|
|
|
|
return resolution;;
|
|
}
|
|
|
|
// TODO is fukt
|
|
fn drain_tick(cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
|
|
let amount = cryp.spell_dmg().wrapping_div(2);
|
|
let immunity = target.immune(Skill::DrainTick);
|
|
let immune = immunity.immune;
|
|
|
|
let drain_tick_dmg_result = ResolutionResult::Damage {
|
|
amount,
|
|
category: Category::SpellDmg,
|
|
immunity: immunity.clone(),
|
|
};
|
|
|
|
let drain_tick_heal_result = ResolutionResult::Damage {
|
|
amount,
|
|
category: Category::SpellHeal,
|
|
immunity,
|
|
};
|
|
|
|
|
|
let resolution = Resolution { skill: Skill::DrainTick, results: vec![drain_tick_dmg_result, drain_tick_heal_result] };
|
|
|
|
if !immune {
|
|
// need to saturate amount and check caster immunity to healing
|
|
target.deal_spell_dmg(amount);
|
|
let (_healing, _overhealing) = cryp.heal(amount);
|
|
}
|
|
|
|
return resolution;
|
|
}
|
|
|
|
fn shield(_cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
|
|
let shield = CrypEffect { effect: Effect::Shield, duration: Skill::Shield.duration(), tick: None };
|
|
let immunity = target.immune(Skill::Shield);
|
|
let immune = immunity.immune;
|
|
|
|
let shield_result = ResolutionResult::Effect {
|
|
effect: shield.effect,
|
|
duration: shield.duration,
|
|
immunity,
|
|
};
|
|
|
|
let resolution = Resolution { skill: Skill::Shield, results: vec![shield_result] };
|
|
|
|
if !immune {
|
|
target.effects.push(shield);
|
|
}
|
|
|
|
return resolution;
|
|
}
|
|
|
|
fn silence(_cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
|
|
let silence = CrypEffect { effect: Effect::Silence, duration: Skill::Silence.duration(), tick: None };
|
|
let immunity = target.immune(Skill::Silence);
|
|
let immune = immunity.immune;
|
|
|
|
let silence_result = ResolutionResult::Effect {
|
|
effect: silence.effect,
|
|
duration: silence.duration,
|
|
immunity,
|
|
};
|
|
|
|
let resolution = Resolution { skill: Skill::Silence, results: vec![silence_result] };
|
|
|
|
if !immune {
|
|
target.effects.push(silence);
|
|
}
|
|
|
|
return resolution;
|
|
}
|
|
|
|
fn purge(_cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
|
|
let immunity = target.immune(Skill::Purge);
|
|
let immune = immunity.immune;
|
|
|
|
let mut resolution = Resolution { skill: Skill::Silence, results: vec![] };
|
|
|
|
if !immune {
|
|
for (i, ce) in target.effects.clone().iter_mut().enumerate() {
|
|
if ce.effect.category() == Category::SpellBuff {
|
|
target.effects.remove(i);
|
|
resolution.results.push(ResolutionResult::Removal { effect: ce.effect, immunity: immunity.clone() });
|
|
}
|
|
}
|
|
}
|
|
|
|
return resolution;
|
|
}
|
|
|
|
fn purify(_cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
|
|
let immunity = target.immune(Skill::Purify);
|
|
let immune = immunity.immune;
|
|
|
|
let mut resolution = Resolution { skill: Skill::Silence, results: vec![] };
|
|
|
|
if !immune {
|
|
for (i, ce) in target.effects.clone().iter_mut().enumerate() {
|
|
if ce.effect.category() == Category::SpellDebuff {
|
|
target.effects.remove(i);
|
|
resolution.results.push(ResolutionResult::Removal { effect: ce.effect, immunity: immunity.clone() });
|
|
}
|
|
}
|
|
}
|
|
|
|
return resolution;
|
|
}
|
|
|
|
fn banish(_cryp: &mut Cryp, target: &mut Cryp) -> Resolution {
|
|
let banish = CrypEffect { effect: Effect::Banish, duration: Skill::Banish.duration(), tick: None };
|
|
let immunity = target.immune(Skill::Banish);
|
|
let immune = immunity.immune;
|
|
|
|
let banish_result = ResolutionResult::Effect {
|
|
effect: banish.effect,
|
|
duration: banish.duration,
|
|
immunity,
|
|
};
|
|
|
|
let resolution = Resolution { skill: Skill::Banish, results: vec![banish_result] };
|
|
|
|
if !immune {
|
|
target.effects.push(banish);
|
|
}
|
|
|
|
return resolution;
|
|
}
|
|
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use skill::*;
|
|
|
|
#[test]
|
|
fn heal_test() {
|
|
let mut x = Cryp::new()
|
|
.named(&"muji".to_string())
|
|
.level(8)
|
|
.learn(Skill::Heal)
|
|
.create();
|
|
|
|
let mut y = Cryp::new()
|
|
.named(&"camel".to_string())
|
|
.level(8)
|
|
.learn(Skill::Heal)
|
|
.create();
|
|
|
|
x.deal_phys_dmg(5);
|
|
|
|
heal(&mut y, &mut x);
|
|
}
|
|
|
|
#[test]
|
|
fn decay_test() {
|
|
let mut x = Cryp::new()
|
|
.named(&"muji".to_string())
|
|
.level(8)
|
|
.create();
|
|
|
|
let mut y = Cryp::new()
|
|
.named(&"camel".to_string())
|
|
.level(8)
|
|
.create();
|
|
|
|
let mut log = vec![];
|
|
decay(&mut x, &mut y);
|
|
|
|
assert!(y.effects.iter().any(|e| e.effect == Effect::Decay));
|
|
|
|
y.reduce_effect_durations(&mut log);
|
|
let _decay = y.effects.iter().find(|e| e.effect == Effect::Decay);
|
|
// assert!(y.hp() == y.stamina().saturating_sub(decay.unwrap().tick.unwrap().amount));
|
|
}
|
|
|
|
#[test]
|
|
fn triage_test() {
|
|
let mut x = Cryp::new()
|
|
.named(&"muji".to_string())
|
|
.level(8)
|
|
.create();
|
|
|
|
let mut y = Cryp::new()
|
|
.named(&"pretaliation".to_string())
|
|
.level(8)
|
|
.create();
|
|
|
|
// ensure it doesn't have 0 sd
|
|
x.spell_dmg.set(50);
|
|
y.deal_phys_dmg(5);
|
|
let prev_hp = y.hp();
|
|
|
|
triage(&mut x, &mut y);
|
|
|
|
assert!(y.effects.iter().any(|e| e.effect == Effect::Triage));
|
|
|
|
triage_tick(&mut x, &mut y);
|
|
assert!(y.hp() > prev_hp);
|
|
}
|
|
|
|
#[test]
|
|
fn silence_test() {
|
|
let mut x = Cryp::new()
|
|
.named(&"muji".to_string())
|
|
.level(8)
|
|
.create();
|
|
|
|
silence(&mut x.clone(), &mut x);
|
|
assert!(x.effects.iter().any(|e| e.effect == Effect::Silence));
|
|
assert!(!Skill::Decay.castable(&x));
|
|
}
|
|
|
|
#[test]
|
|
fn amplify_test() {
|
|
let mut x = Cryp::new()
|
|
.named(&"muji".to_string())
|
|
.level(8)
|
|
.create();
|
|
|
|
x.spell_dmg.set(50);
|
|
|
|
amplify(&mut x.clone(), &mut x);
|
|
assert!(x.effects.iter().any(|e| e.effect == Effect::Amplify));
|
|
assert_eq!(x.spell_dmg(), 100);
|
|
}
|
|
|
|
#[test]
|
|
fn purify_test() {
|
|
let mut x = Cryp::new()
|
|
.named(&"muji".to_string())
|
|
.level(8)
|
|
.create();
|
|
|
|
decay(&mut x.clone(), &mut x);
|
|
assert!(x.effects.iter().any(|e| e.effect == Effect::Decay));
|
|
|
|
purify(&mut x.clone(), &mut x);
|
|
assert!(!x.effects.iter().any(|e| e.effect == Effect::Decay));
|
|
}
|
|
}
|
|
|
|
// #[derive(Debug,Clone,Copy,PartialEq,Serialize,Deserialize)]
|
|
// pub enum Skill {
|
|
// Stoney,
|
|
// Evasive,
|
|
// }
|
|
|
|
// impl Skill {
|
|
// pub fn apply(&self, roll: Roll) -> Roll {
|
|
// match self {
|
|
// Skill::Stoney => stoney(self, roll),
|
|
// Skill::Evasive => evasive(self, roll),
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
// fn stoney(_s: &Skill, mut roll: Roll) -> Roll {
|
|
// let effect = 0b11110000;
|
|
// match roll.kind {
|
|
// StatKind::Def => {
|
|
// // println!("{:064b} | <- {:?}", effect, s);
|
|
// roll.result = roll.result | effect;
|
|
// roll
|
|
// },
|
|
// _ => roll,
|
|
// }
|
|
// }
|
|
|
|
// fn evasive(_s: &Skill, mut roll: Roll) -> Roll {
|
|
// match roll.kind {
|
|
// StatKind::Def => {
|
|
// if roll.result.is_power_of_two() {
|
|
// roll.result = u64::max_value()
|
|
// }
|
|
// roll
|
|
// },
|
|
// _ => roll,
|
|
// }
|
|
// }
|