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, 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, 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 } #[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, } pub type Cooldown = Option; #[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 { 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, // } // }