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

dmg -> damage

Browse Source
This commit is contained in:
ntr 2019-02-16 10:58:10 +11:00
parent 8a78528c80
commit a822177fb8
11 changed files with 96 additions and 96 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
client/src/scenes/constants.js
View File

@ -162,7 +162,7 @@ module.exports = {
[ { name: 'Amplify', [ { name: 'Amplify',
description: 'increase the magic damage dealt by a cryp' }, description: 'increase the magic damage dealt by a cryp' },
{ name: 'Attack', { name: 'Attack',
description: 'a fast attack with red dmg' }, description: 'a fast attack with red damage' },
{ name: 'Banish', { name: 'Banish',
description: description:
'target cryp is prevented from casting any skills and taking any damage' }, 'target cryp is prevented from casting any skills and taking any damage' },
@ -181,7 +181,7 @@ module.exports = {
description: 'increase the red damage dealt by a cryp' }, description: 'increase the red damage dealt by a cryp' },
{ name: 'Haste', { name: 'Haste',
description: 'magical skill that increases speed of target cryp' }, description: 'magical skill that increases speed of target cryp' },
{ name: 'Heal', description: 'heal a cryp with blue dmg' }, { name: 'Heal', description: 'heal a cryp with blue damage' },
{ name: 'Hex', { name: 'Hex',
description: description:
'magical based skill that prevents target cryp from using any skills' }, 'magical based skill that prevents target cryp from using any skills' },
@ -205,7 +205,7 @@ module.exports = {
{ name: 'Throw', { name: 'Throw',
description: 'stuns and makes the target take increased red damage' }, description: 'stuns and makes the target take increased red damage' },
{ name: 'Triage', { name: 'Triage',
description: 'grants a blue dmg based healing over time buff' } description: 'grants a blue damage based healing over time buff' }
] ]
}, },
}; };

4
client/src/scenes/menu.cryps.list.js
View File

@ -115,8 +115,8 @@ class MenuCrypList extends Phaser.Scene {
cryp.stamina, cryp.stamina,
cryp.red_shield, cryp.red_shield,
cryp.blue_shield, cryp.blue_shield,
cryp.red_dmg, cryp.red_damage,
cryp.blue_dmg, cryp.blue_damage,
cryp.speed, cryp.speed,
]; ];
CRYP_STATS.forEach((stat, j) => crypStat(stat, j, crypInfo)); CRYP_STATS.forEach((stat, j) => crypStat(stat, j, crypInfo));

4
client/src/scenes/statsheet.js
View File

@ -69,8 +69,8 @@ class StatSheet extends Phaser.Scene {
cryp.red_shield, cryp.red_shield,
cryp.blue_shield, cryp.blue_shield,
cryp.evasion, cryp.evasion,
cryp.red_dmg, cryp.red_damage,
cryp.blue_dmg, cryp.blue_damage,
cryp.speed, cryp.speed,
]; ];

8
server/NODES.md
View File

@ -30,11 +30,11 @@ Rare `25% hex for blast`
Rare `cooldown reduction` Rare `cooldown reduction`
Rare `effect duration` Rare `effect duration`
Rare `increased phys dmg, 0 spell damage` Rare `increased phys damage, 0 spell damage`
Rare `increased spell dmg, 0 phys damage` Rare `increased spell damage, 0 phys damage`
Rare `increased phys dmg, silenced` Rare `increased phys damage, silenced`
Rare `increased spell dmg, snared` Rare `increased spell damage, snared`
Rare `increased speed, increased durations` Rare `increased speed, increased durations`
Rare `increased speed, increased cooldowns` Rare `increased speed, increased cooldowns`

4
server/README.md
View File

@ -21,11 +21,11 @@ resolve phase:
2.2 <- attack (normal resolve) 2.2 <- attack (normal resolve)
1.1 <- hexed (no skills for the rest of this turn and next) 1.1 <- hexed (no skills for the rest of this turn and next)
## Dmg Chart ## Damage Chart
| Red | Magic | Modifiers | | Red | Magic | Modifiers |
| ------ | ------ | ------ | | ------ | ------ | ------ |
| dmg | dmg | speed | | damage | damage | speed |
| evasion | resistance | cooldowns | | evasion | resistance | cooldowns |
| reduction | absorption? | durations | | reduction | absorption? | durations |

70
server/src/cryp.rs
View File

@ -136,10 +136,10 @@ pub struct CrypRecover {
pub struct Cryp { pub struct Cryp {
pub id: Uuid, pub id: Uuid,
pub account: Uuid, pub account: Uuid,
pub red_dmg: CrypStat, pub red_damage: CrypStat,
pub red_shield: CrypStat, pub red_shield: CrypStat,
pub blue_shield: CrypStat, pub blue_shield: CrypStat,
pub blue_dmg: CrypStat, pub blue_damage: CrypStat,
pub speed: CrypStat, pub speed: CrypStat,
pub stamina: CrypStat, pub stamina: CrypStat,
pub hp: CrypStat, pub hp: CrypStat,
@ -164,9 +164,9 @@ impl Cryp {
return Cryp { return Cryp {
id, id,
account: id, account: id,
red_dmg: CrypStat { base: 0, value: 0, stat: Stat::RedDamage }, red_damage: CrypStat { base: 0, value: 0, stat: Stat::RedDamage },
red_shield: CrypStat { base: 0, value: 0, stat: Stat::RedShield }, red_shield: CrypStat { base: 0, value: 0, stat: Stat::RedShield },
blue_dmg: CrypStat { base: 0, value: 0, stat: Stat::BlueDamage }, blue_damage: CrypStat { base: 0, value: 0, stat: Stat::BlueDamage },
blue_shield: CrypStat { base: 0, value: 0, stat: Stat::BlueShield }, blue_shield: CrypStat { base: 0, value: 0, stat: Stat::BlueShield },
speed: CrypStat { base: 0, value: 0, stat: Stat::Speed }, speed: CrypStat { base: 0, value: 0, stat: Stat::Speed },
stamina: CrypStat { base: 0, value: 0, stat: Stat::Stamina }, stamina: CrypStat { base: 0, value: 0, stat: Stat::Stamina },
@ -238,8 +238,8 @@ impl Cryp {
let evasion_max = 5; let evasion_max = 5;
match stat { match stat {
Stat::RedDamage => self.red_dmg.set(rng.gen_range(stat_min, stat_max), &self.specs), Stat::RedDamage => self.red_damage.set(rng.gen_range(stat_min, stat_max), &self.specs),
Stat::BlueDamage => self.blue_dmg.set(rng.gen_range(stat_min, stat_max), &self.specs), Stat::BlueDamage => self.blue_damage.set(rng.gen_range(stat_min, stat_max), &self.specs),
Stat::Speed => self.speed.set(rng.gen_range(stat_min, stat_max), &self.specs), Stat::Speed => self.speed.set(rng.gen_range(stat_min, stat_max), &self.specs),
Stat::Stamina => { Stat::Stamina => {
self.stamina.set(rng.gen_range(stam_min, stam_max), &self.specs); self.stamina.set(rng.gen_range(stam_min, stam_max), &self.specs);
@ -331,9 +331,9 @@ impl Cryp {
fn recalculate_stats(&mut self) -> &mut Cryp { fn recalculate_stats(&mut self) -> &mut Cryp {
self.stamina.recalculate(&self.specs); self.stamina.recalculate(&self.specs);
self.hp.recalculate(&self.specs); self.hp.recalculate(&self.specs);
self.red_dmg.recalculate(&self.specs); self.red_damage.recalculate(&self.specs);
self.red_shield.recalculate(&self.specs); self.red_shield.recalculate(&self.specs);
self.blue_dmg.recalculate(&self.specs); self.blue_damage.recalculate(&self.specs);
self.blue_shield.recalculate(&self.specs); self.blue_shield.recalculate(&self.specs);
self.evasion.recalculate(&self.specs); self.evasion.recalculate(&self.specs);
self.speed.recalculate(&self.specs); self.speed.recalculate(&self.specs);
@ -468,24 +468,24 @@ impl Cryp {
// } // }
// Stats // Stats
pub fn red_dmg(&self) -> u64 { pub fn red_damage(&self) -> u64 {
let red_dmg_mods = self.effects.iter() let red_damage_mods = self.effects.iter()
.filter(|e| e.effect.modifications().contains(&Stat::RedDamage)) .filter(|e| e.effect.modifications().contains(&Stat::RedDamage))
.map(|cryp_effect| cryp_effect.effect) .map(|cryp_effect| cryp_effect.effect)
.collect::<Vec<Effect>>(); .collect::<Vec<Effect>>();
let modified_red_dmg = red_dmg_mods.iter().fold(self.red_dmg.value, |acc, m| m.apply(acc)); let modified_red_damage = red_damage_mods.iter().fold(self.red_damage.value, |acc, m| m.apply(acc));
return modified_red_dmg; return modified_red_damage;
} }
pub fn blue_dmg(&self) -> u64 { pub fn blue_damage(&self) -> u64 {
let blue_dmg_mods = self.effects.iter() let blue_damage_mods = self.effects.iter()
.filter(|e| e.effect.modifications().contains(&Stat::BlueDamage)) .filter(|e| e.effect.modifications().contains(&Stat::BlueDamage))
.map(|cryp_effect| cryp_effect.effect) .map(|cryp_effect| cryp_effect.effect)
.collect::<Vec<Effect>>(); .collect::<Vec<Effect>>();
let modified_blue_dmg = blue_dmg_mods.iter().fold(self.blue_dmg.value, |acc, m| m.apply(acc)); let modified_blue_damage = blue_damage_mods.iter().fold(self.blue_damage.value, |acc, m| m.apply(acc));
return modified_blue_dmg; return modified_blue_damage;
} }
pub fn skill_speed(&self, s: Skill) -> u64 { pub fn skill_speed(&self, s: Skill) -> u64 {
@ -551,7 +551,7 @@ impl Cryp {
}; };
} }
pub fn deal_red_dmg(&mut self, skill: Skill, amount: u64) -> ResolutionResult { pub fn deal_red_damage(&mut self, skill: Skill, amount: u64) -> ResolutionResult {
let immunity = self.immune(skill); let immunity = self.immune(skill);
let immune = immunity.immune; let immune = immunity.immune;
@ -559,26 +559,26 @@ impl Cryp {
return ResolutionResult::Damage { return ResolutionResult::Damage {
amount: 0, amount: 0,
mitigation: 0, mitigation: 0,
category: Category::RedDmg, category: Category::RedDamage,
immunity, immunity,
}; };
} }
let red_dmg_mods = self.effects.iter() let red_damage_mods = self.effects.iter()
.filter(|e| e.effect.modifications().contains(&Stat::RedDamageTaken)) .filter(|e| e.effect.modifications().contains(&Stat::RedDamageTaken))
.map(|cryp_effect| cryp_effect.effect) .map(|cryp_effect| cryp_effect.effect)
.collect::<Vec<Effect>>(); .collect::<Vec<Effect>>();
// println!("{:?}", red_dmg_mods); // println!("{:?}", red_damage_mods);
let modified_dmg = red_dmg_mods.iter().fold(amount, |acc, m| m.apply(acc)); let modified_damage = red_damage_mods.iter().fold(amount, |acc, m| m.apply(acc));
// calculate amount of damage red_shield will not absorb // calculate amount of damage red_shield will not absorb
// eg 50 red_shield 25 dmg -> 0 remainder 25 mitigation // eg 50 red_shield 25 damage -> 0 remainder 25 mitigation
// 50 red_shield 100 dmg -> 50 remainder 50 mitigation // 50 red_shield 100 damage -> 50 remainder 50 mitigation
// 50 red_shield 5 dmg -> 0 remainder 5 mitigation // 50 red_shield 5 damage -> 0 remainder 5 mitigation
let remainder = modified_dmg.saturating_sub(self.red_shield.value); let remainder = modified_damage.saturating_sub(self.red_shield.value);
let mitigation = modified_dmg.saturating_sub(remainder); let mitigation = modified_damage.saturating_sub(remainder);
// reduce red_shield by mitigation amount // reduce red_shield by mitigation amount
self.red_shield.reduce(mitigation); self.red_shield.reduce(mitigation);
@ -589,12 +589,12 @@ impl Cryp {
return ResolutionResult::Damage { return ResolutionResult::Damage {
amount: remainder, amount: remainder,
mitigation, mitigation,
category: Category::RedDmg, category: Category::RedDamage,
immunity, immunity,
}; };
} }
pub fn deal_blue_dmg(&mut self, skill: Skill, amount: u64) -> ResolutionResult { pub fn deal_blue_damage(&mut self, skill: Skill, amount: u64) -> ResolutionResult {
let immunity = self.immune(skill); let immunity = self.immune(skill);
let immune = immunity.immune; let immune = immunity.immune;
@ -602,21 +602,21 @@ impl Cryp {
return ResolutionResult::Damage { return ResolutionResult::Damage {
amount: 0, amount: 0,
mitigation: 0, mitigation: 0,
category: Category::BlueDmg, category: Category::BlueDamage,
immunity, immunity,
}; };
} }
let blue_dmg_mods = self.effects.iter() let blue_damage_mods = self.effects.iter()
.filter(|e| e.effect.modifications().contains(&Stat::BlueDamageTaken)) .filter(|e| e.effect.modifications().contains(&Stat::BlueDamageTaken))
.map(|cryp_effect| cryp_effect.effect) .map(|cryp_effect| cryp_effect.effect)
.collect::<Vec<Effect>>(); .collect::<Vec<Effect>>();
// println!("{:?}", blue_dmg_mods); // println!("{:?}", blue_damage_mods);
let modified_dmg = blue_dmg_mods.iter().fold(amount, |acc, m| m.apply(acc)); let modified_damage = blue_damage_mods.iter().fold(amount, |acc, m| m.apply(acc));
let remainder = modified_dmg.saturating_sub(self.blue_shield.value); let remainder = modified_damage.saturating_sub(self.blue_shield.value);
let mitigation = modified_dmg.saturating_sub(remainder); let mitigation = modified_damage.saturating_sub(remainder);
self.blue_shield.reduce(mitigation); self.blue_shield.reduce(mitigation);
self.hp.reduce(remainder); self.hp.reduce(remainder);
@ -624,7 +624,7 @@ impl Cryp {
return ResolutionResult::Damage { return ResolutionResult::Damage {
amount: remainder, amount: remainder,
mitigation, mitigation,
category: Category::BlueDmg, category: Category::BlueDamage,
immunity, immunity,
}; };
} }

2
server/src/game.rs
View File

@ -1014,7 +1014,7 @@ mod tests {
let x_cryp = x_team.cryps[0].clone(); let x_cryp = x_team.cryps[0].clone();
let y_cryp = y_team.cryps[0].clone(); let y_cryp = y_team.cryps[0].clone();
game.team_by_id(y_team.id).cryp_by_id(y_cryp.id).unwrap().red_dmg.force(u64::max_value()); game.team_by_id(y_team.id).cryp_by_id(y_cryp.id).unwrap().red_damage.force(u64::max_value());
game.team_by_id(y_team.id).cryp_by_id(y_cryp.id).unwrap().speed.force(u64::max_value()); game.team_by_id(y_team.id).cryp_by_id(y_cryp.id).unwrap().speed.force(u64::max_value());
// just in case // just in case

2
server/src/game_target_phase.rs
View File

@ -1104,7 +1104,7 @@ mod tests {
let x_cryp = x_team.cryps[0].clone(); let x_cryp = x_team.cryps[0].clone();
let y_cryp = y_team.cryps[0].clone(); let y_cryp = y_team.cryps[0].clone();
game.team_by_id(y_team.id).cryp_by_id(y_cryp.id).unwrap().red_dmg.set(u64::max_value()); game.team_by_id(y_team.id).cryp_by_id(y_cryp.id).unwrap().red_damage.set(u64::max_value());
let x_stun_id = game.add_skill(x_team.id, x_cryp.id, Some(y_team.id), Skill::TestStun).unwrap(); let x_stun_id = game.add_skill(x_team.id, x_cryp.id, Some(y_team.id), Skill::TestStun).unwrap();
let y_attack_id = game.add_skill(y_team.id, y_cryp.id, Some(x_team.id), Skill::Attack).unwrap(); let y_attack_id = game.add_skill(y_team.id, y_cryp.id, Some(x_team.id), Skill::Attack).unwrap();

8
server/src/item.rs
View File

@ -25,8 +25,8 @@ pub enum ItemAction {
RerollBlueShield, RerollBlueShield,
RerollEvasion, RerollEvasion,
SpecRedDmg5, SpecRedDamage5,
SpecBlueDmg5, SpecBlueDamage5,
SpecRedShield5, SpecRedShield5,
SpecBlueShield5, SpecBlueShield5,
SpecBlueEvasion5, SpecBlueEvasion5,
@ -60,8 +60,8 @@ impl Item {
ItemAction::RerollBlueShield => reroll(self, tx, target, Stat::BlueShield), ItemAction::RerollBlueShield => reroll(self, tx, target, Stat::BlueShield),
ItemAction::RerollEvasion => reroll(self, tx, target, Stat::Evasion), ItemAction::RerollEvasion => reroll(self, tx, target, Stat::Evasion),
ItemAction::SpecRedDmg5 => spec_add(self, tx, target, SpecType::RedDamage5), ItemAction::SpecRedDamage5 => spec_add(self, tx, target, SpecType::RedDamage5),
ItemAction::SpecBlueDmg5 => spec_add(self, tx, target, SpecType::BlueDamage5), ItemAction::SpecBlueDamage5 => spec_add(self, tx, target, SpecType::BlueDamage5),
_ => unimplemented!(), _ => unimplemented!(),
} }
} }

4
server/src/rpc.rs
View File

@ -337,8 +337,8 @@ impl Rpc {
ItemAction::RerollRedShield, ItemAction::RerollRedShield,
ItemAction::RerollBlueShield, ItemAction::RerollBlueShield,
ItemAction::RerollEvasion, ItemAction::RerollEvasion,
ItemAction::SpecRedDmg5, ItemAction::SpecRedDamage5,
ItemAction::SpecBlueDmg5, ItemAction::SpecBlueDamage5,
].into_iter() { ].into_iter() {
let item = Item::new(*action, account.id); let item = Item::new(*action, account.id);
item_create(item, tx, account.id)?; item_create(item, tx, account.id)?;

80
server/src/skill.rs
View File

@ -298,12 +298,12 @@ impl Effect {
pub enum Category { pub enum Category {
Red, Red,
RedHeal, RedHeal,
RedDmg, RedDamage,
RedDebuff, RedDebuff,
RedBuff, RedBuff,
RedTick, RedTick,
Blue, Blue,
BlueDmg, BlueDamage,
BlueHeal, BlueHeal,
BlueDebuff, BlueDebuff,
BlueBuff, BlueBuff,
@ -318,8 +318,8 @@ pub enum Skill {
// ----------------- // -----------------
// Nature // Nature
// ----------------- // -----------------
Block, // reduce dmg Block, // reduce damage
Parry, // avoid all dmg Parry, // avoid all damage
Snare, Snare,
Paralyse, Paralyse,
@ -345,7 +345,7 @@ pub enum Skill {
Heal, Heal,
Triage, // hot Triage, // hot
TriageTick, TriageTick,
Throw, // no dmg stun, adds vulnerable Throw, // no damage stun, adds vulnerable
Charm, Charm,
Calm, Calm,
Rez, Rez,
@ -389,7 +389,7 @@ pub enum Skill {
Haste, Haste,
Slow, Slow,
// used by tests, no cd, no dmg // used by tests, no cd, no damage
TestTouch, TestTouch,
TestStun, TestStun,
TestBlock, TestBlock,
@ -405,8 +405,8 @@ impl Skill {
// ----------------- // -----------------
// Nature // Nature
// ----------------- // -----------------
Skill::Block => None, // reduce dmg Skill::Block => None, // reduce damage
Skill::Parry => None, // avoid all dmg Skill::Parry => None, // avoid all damage
Skill::Snare => Some(1), Skill::Snare => Some(1),
Skill::Paralyse => Some(1), Skill::Paralyse => Some(1),
@ -431,7 +431,7 @@ impl Skill {
Skill::Heal => None, Skill::Heal => None,
Skill::Triage => None, // hot Skill::Triage => None, // hot
Skill::TriageTick => None, Skill::TriageTick => None,
Skill::Throw => Some(1), // no dmg stun, adds vulnerable Skill::Throw => Some(1), // no damage stun, adds vulnerable
Skill::Charm => Some(1), Skill::Charm => Some(1),
Skill::Calm => None, Skill::Calm => None,
Skill::Rez => Some(2), Skill::Rez => Some(2),
@ -490,8 +490,8 @@ impl Skill {
// ----------------- // -----------------
// Nature // Nature
// ----------------- // -----------------
Skill::Block => Category::Red, // reduce dmg Skill::Block => Category::Red, // reduce damage
Skill::Parry => Category::Red, // avoid all dmg Skill::Parry => Category::Red, // avoid all damage
Skill::Snare => Category::Red, Skill::Snare => Category::Red,
Skill::Paralyse => Category::Red, Skill::Paralyse => Category::Red,
@ -516,7 +516,7 @@ impl Skill {
Skill::Heal => Category::Red, Skill::Heal => Category::Red,
Skill::Triage => Category::Blue, // hot Skill::Triage => Category::Blue, // hot
Skill::TriageTick => Category::BlueTick, // hot Skill::TriageTick => Category::BlueTick, // hot
Skill::Throw => Category::Red, // no dmg stun, adds vulnerable Skill::Throw => Category::Red, // no damage stun, adds vulnerable
Skill::Charm => Category::Blue, Skill::Charm => Category::Blue,
Skill::Calm => Category::Red, Skill::Calm => Category::Red,
Skill::Rez => Category::Blue, Skill::Rez => Category::Blue,
@ -583,10 +583,10 @@ impl Skill {
match self { match self {
// defensive block // defensive block
Skill::Block => 10, // reduce dmg Skill::Block => 10, // reduce damage
Skill::Parry => 10, // avoid all dmg Skill::Parry => 10, // avoid all damage
Skill::Snare => 10, Skill::Snare => 10,
Skill::Shield => 10, // avoid magic dmg, Skill::Shield => 10, // avoid magic damage,
// fast phys combat // fast phys combat
Skill::Attack => 5, Skill::Attack => 5,
@ -614,7 +614,7 @@ impl Skill {
Skill::Plague => 2, // aoe dot Skill::Plague => 2, // aoe dot
Skill::Silence => 2, Skill::Silence => 2,
Skill::Stun => 2, Skill::Stun => 2,
Skill::Throw => 2, // no dmg stun, adds vulnerable Skill::Throw => 2, // no damage stun, adds vulnerable
Skill::TriageTick => 2, // hot Skill::TriageTick => 2, // hot
Skill::Heal => 1, Skill::Heal => 1,
@ -703,7 +703,7 @@ impl Skill {
Skill::Heal => heal(source, target, resolution), Skill::Heal => heal(source, target, resolution),
Skill::Triage => triage(source, target, resolution), // hot Skill::Triage => triage(source, target, resolution), // hot
Skill::TriageTick => triage_tick(source, target, resolution), // hot Skill::TriageTick => triage_tick(source, target, resolution), // hot
Skill::Throw => throw(source, target, resolution), // no dmg stun, adds vulnerable Skill::Throw => throw(source, target, resolution), // no damage stun, adds vulnerable
Skill::Charm => panic!("nyi"), // target casts random spell on teammate Skill::Charm => panic!("nyi"), // target casts random spell on teammate
Skill::Calm => panic!("nyi"), // physical fear, taunt removal Skill::Calm => panic!("nyi"), // physical fear, taunt removal
Skill::Rez => panic!("nyi"), Skill::Rez => panic!("nyi"),
@ -712,7 +712,7 @@ impl Skill {
// Destruction // Destruction
// ----------------- // -----------------
Skill::Blast => blast(source, target, resolution), Skill::Blast => blast(source, target, resolution),
Skill::Amplify => amplify(source, target, resolution), // increase magic dmg Skill::Amplify => amplify(source, target, resolution), // increase magic damage
Skill::Decay => decay(source, target, resolution), // dot Skill::Decay => decay(source, target, resolution), // dot
Skill::DecayTick => decay_tick(source, target, resolution), // dot Skill::DecayTick => decay_tick(source, target, resolution), // dot
Skill::Drain => drain(source, target, resolution), Skill::Drain => drain(source, target, resolution),
@ -725,9 +725,9 @@ impl Skill {
// Purity // Purity
// ----------------- // -----------------
// Skill::Precision => panic!("nyi"), // Skill::Precision => panic!("nyi"),
Skill::Empower => empower(source, target, resolution), // increased phys dmg Skill::Empower => empower(source, target, resolution), // increased phys damage
Skill::Slay => panic!("nyi"), // phys dmg mult by target magic dmg Skill::Slay => panic!("nyi"), // phys damage mult by target magic damage
Skill::Shield => shield(source, target, resolution), // target is immune to magic dmg and fx Skill::Shield => shield(source, target, resolution), // target is immune to magic damage and fx
Skill::Silence => silence(source, target, resolution), // target cannot cast spells Skill::Silence => silence(source, target, resolution), // target cannot cast spells
Skill::Inquiry => panic!("nyi"), // Skill::Inquiry => panic!("nyi"), //
Skill::Purify => purify(source, target, resolution), // dispel all debuffs Skill::Purify => purify(source, target, resolution), // dispel all debuffs
@ -780,8 +780,8 @@ impl Skill {
} }
fn attack(cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution { fn attack(cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution {
let amount = cryp.red_dmg(); let amount = cryp.red_damage();
resolution.results.push(target.deal_red_dmg(Skill::Attack, amount)); resolution.results.push(target.deal_red_damage(Skill::Attack, amount));
return resolution; return resolution;
} }
@ -828,7 +828,7 @@ fn empower(_cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> R
} }
fn heal(cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution { fn heal(cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution {
let amount = cryp.blue_dmg(); let amount = cryp.blue_damage();
resolution.results.push(target.heal(Skill::Heal, amount)); resolution.results.push(target.heal(Skill::Heal, amount));
return resolution; return resolution;
} }
@ -858,14 +858,14 @@ fn triage(cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Res
} }
fn triage_tick(cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution { fn triage_tick(cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution {
let amount = cryp.blue_dmg().wrapping_div(2); let amount = cryp.blue_damage().wrapping_div(2);
resolution.results.push(target.heal(Skill::TriageTick, amount)); resolution.results.push(target.heal(Skill::TriageTick, amount));
return resolution; return resolution;
} }
fn blast(cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution { fn blast(cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution {
let amount = cryp.blue_dmg(); let amount = cryp.blue_damage();
resolution.results.push(target.deal_blue_dmg(Skill::Blast, amount)); resolution.results.push(target.deal_blue_damage(Skill::Blast, amount));
return resolution; return resolution;
} }
@ -898,8 +898,8 @@ fn decay(cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Reso
} }
fn decay_tick(cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution { fn decay_tick(cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution {
let amount = cryp.blue_dmg(); let amount = cryp.blue_damage();
resolution.results.push(target.deal_blue_dmg(Skill::DecayTick, amount)); resolution.results.push(target.deal_blue_damage(Skill::DecayTick, amount));
return resolution; return resolution;
} }
@ -926,17 +926,17 @@ fn drain(cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Reso
} }
fn drain_tick(cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution { fn drain_tick(cryp: &mut Cryp, target: &mut Cryp, mut resolution: Resolution) -> Resolution {
let amount = cryp.blue_dmg(); let amount = cryp.blue_damage();
let drain_dmg = target.deal_blue_dmg(Skill::DrainTick, amount); let drain_damage = target.deal_blue_damage(Skill::DrainTick, amount);
resolution.results.push(drain_dmg.clone()); resolution.results.push(drain_damage.clone());
match drain_dmg { match drain_damage {
ResolutionResult::Damage { amount, mitigation, category: _, immunity } => { ResolutionResult::Damage { amount, mitigation, category: _, immunity } => {
if !immunity.immune { if !immunity.immune {
resolution.results.push(cryp.heal(Skill::Heal, amount)); resolution.results.push(cryp.heal(Skill::Heal, amount));
} }
}, },
_ => panic!("drain tick dmg not dealt {:?}", drain_dmg), _ => panic!("drain tick damage not dealt {:?}", drain_damage),
} }
return resolution; return resolution;
@ -1011,7 +1011,7 @@ mod tests {
.learn(Skill::Heal) .learn(Skill::Heal)
.create(); .create();
x.deal_red_dmg(Skill::Attack, 5); x.deal_red_damage(Skill::Attack, 5);
heal(&mut y, &mut x, Resolution::new(Skill::Heal)); heal(&mut y, &mut x, Resolution::new(Skill::Heal));
} }
@ -1051,7 +1051,7 @@ mod tests {
.create(); .create();
// ensure it doesn't have 0 pd // ensure it doesn't have 0 pd
x.red_dmg.force(100); x.red_damage.force(100);
y.hp.force(500); y.hp.force(500);
block(&mut y.clone(), &mut y, Resolution::new(Skill::Block)); block(&mut y.clone(), &mut y, Resolution::new(Skill::Block));
@ -1078,13 +1078,13 @@ mod tests {
.create(); .create();
// ensure it doesn't have 0 sd // ensure it doesn't have 0 sd
x.blue_dmg.force(50); x.blue_damage.force(50);
// remove all mitigation // remove all mitigation
y.red_shield.force(0); y.red_shield.force(0);
y.blue_shield.force(0); y.blue_shield.force(0);
y.deal_red_dmg(Skill::Attack, 5); y.deal_red_damage(Skill::Attack, 5);
let prev_hp = y.hp(); let prev_hp = y.hp();
let res = Resolution::new(Skill::Triage); let res = Resolution::new(Skill::Triage);
@ -1118,11 +1118,11 @@ mod tests {
.level(8) .level(8)
.create(); .create();
x.blue_dmg.force(50); x.blue_damage.force(50);
amplify(&mut x.clone(), &mut x, Resolution::new(Skill::Amplify)); amplify(&mut x.clone(), &mut x, Resolution::new(Skill::Amplify));
assert!(x.effects.iter().any(|e| e.effect == Effect::Amplify)); assert!(x.effects.iter().any(|e| e.effect == Effect::Amplify));
assert_eq!(x.blue_dmg(), 100); assert_eq!(x.blue_damage(), 100);
} }
#[test] #[test]