wowlab_engine_domain/

damage.rs

//! Damage calculation pipeline: base + coef * power, then crit, vers, armor, and multipliers.

use wowlab_engine_rng::proc_chance;
use wowlab_types::{
    combat::{DamageSchool, HitResult},
    constants::{HUNDRED, MS_PER_SECOND},
};

/// Converts weapon damage per second into attack power.
pub const WEAPON_POWER_COEFFICIENT: f64 = 6.0;

/// Returns the owner-power coefficient for a pet weapon swing.
#[must_use]
pub fn pet_swing_power_coefficient(
    power_from_owner: f64,
    weapon_speed_ms: u32,
    weapon_multiplier: f64,
) -> f64 {
    power_from_owner * f64::from(weapon_speed_ms) / MS_PER_SECOND / WEAPON_POWER_COEFFICIENT
        * weapon_multiplier
}

/// Attack-power coefficient for a normalized pet auto-attack swing.
#[must_use]
pub fn pet_swing_ap(swing_ms: u32) -> f64 {
    pet_swing_power_coefficient(1.0, swing_ms, 1.0)
}

/// Result of a single damage calculation.
#[derive(Clone, Debug)]
#[must_use]
pub struct DamageResult {
    pub raw: f64,
    pub is_crit: bool,
    pub hit_result: HitResult,
    pub final_amount: f64,
}

/// Ordered one-roll attack-table probabilities and landed-hit reductions.
#[derive(Clone, Copy, Debug)]
#[must_use]
pub struct AttackTable {
    pub miss_chance: f64,
    pub dodge_chance: f64,
    pub parry_chance: f64,
    pub glance_chance: f64,
    pub block_chance: f64,
    pub critical_block_chance: f64,
    pub glance_multiplier: f64,
    pub block_multiplier: f64,
    pub critical_block_multiplier: f64,
}

impl AttackTable {
    const DEFAULT_BLOCK_MULTIPLIER: f64 = 0.7;
    const DEFAULT_CRITICAL_BLOCK_MULTIPLIER: f64 = 0.4;
    const DEFAULT_GLANCE_MULTIPLIER: f64 = 0.75;

    fn resolve(self, crit_chance: f64, rng: &mut (impl FnMut() -> f64 + ?Sized)) -> HitResult {
        let roll = rng();
        let mut threshold = self.miss_chance.clamp(0.0, 1.0);

        if roll < threshold {
            return HitResult::Miss;
        }

        threshold = (threshold + self.dodge_chance.max(0.0)).min(1.0);

        if roll < threshold {
            return HitResult::Dodge;
        }

        threshold = (threshold + self.parry_chance.max(0.0)).min(1.0);

        if roll < threshold {
            return HitResult::Parry;
        }

        threshold = (threshold + self.glance_chance.max(0.0)).min(1.0);

        if roll < threshold {
            return HitResult::Glance;
        }

        threshold = (threshold + self.block_chance.max(0.0)).min(1.0);

        if roll < threshold {
            let mut critical_block_roll = || rng();

            return if proc_chance(&mut critical_block_roll, self.critical_block_chance) {
                HitResult::CritBlock
            } else {
                HitResult::Block
            };
        }

        threshold = (threshold + crit_chance.clamp(0.0, 1.0)).min(1.0);

        if roll < threshold {
            HitResult::Crit
        } else {
            HitResult::Hit
        }
    }

    const fn multiplier(self, result: HitResult, crit_multiplier: f64) -> f64 {
        match result {
            HitResult::Miss | HitResult::Dodge | HitResult::Parry => 0.0,
            HitResult::Glance => self.glance_multiplier,
            HitResult::Block => self.block_multiplier,
            HitResult::CritBlock => self.critical_block_multiplier,
            HitResult::Crit => crit_multiplier,
            HitResult::Hit => 1.0,
        }
    }
}

impl Default for AttackTable {
    fn default() -> Self {
        Self {
            miss_chance: 0.0,
            dodge_chance: 0.0,
            parry_chance: 0.0,
            glance_chance: 0.0,
            block_chance: 0.0,
            critical_block_chance: 0.0,
            glance_multiplier: Self::DEFAULT_GLANCE_MULTIPLIER,
            block_multiplier: Self::DEFAULT_BLOCK_MULTIPLIER,
            critical_block_multiplier: Self::DEFAULT_CRITICAL_BLOCK_MULTIPLIER,
        }
    }
}

/// All inputs needed to compute a damage hit.
// docref:start combat-formulas-damage-calc-struct
#[derive(Clone, Debug)]
#[must_use]
pub struct DamageCalc {
    pub base: f64,
    pub coefficient: f64,
    pub attack_power: f64,
    pub crit_chance: f64,
    pub crit_multiplier: f64,
    pub attack_table: AttackTable,
    pub versatility: f64,
    pub target_armor: f64,
    pub armor_k: f64,
    pub damage_multiplier: f64,
    pub mastery_mult: f64,
    pub weapon_min: f64,
    pub weapon_max: f64,
    pub weapon_multiplier: f64,
    pub school: DamageSchool,
}
// docref:end combat-formulas-damage-calc-struct

impl DamageCalc {
    /// Compute the damage result, calling `rng` once for the weapon roll (if any) and once for crit.
    pub fn calculate(&self, rng: &mut (impl FnMut() -> f64 + ?Sized)) -> DamageResult {
        let weapon_roll = if self.weapon_max > 0.0 {
            self.weapon_min + rng() * (self.weapon_max - self.weapon_min)
        } else {
            0.0
        };
        let raw =
            self.base + weapon_roll * self.weapon_multiplier + self.coefficient * self.attack_power;

        let hit_result = self.attack_table.resolve(self.crit_chance, rng);
        let is_crit = hit_result.is_crit();
        let crit_factor = self
            .attack_table
            .multiplier(hit_result, self.crit_multiplier);

        let after_crit = raw * crit_factor;
        let after_vers = after_crit * (1.0 + self.versatility / HUNDRED);
        let mit = armor_mitigation(self.target_armor, self.armor_k);
        let after_armor = after_vers * mit;
        let final_amount = (after_armor * self.damage_multiplier * self.mastery_mult).max(0.0);

        DamageResult {
            raw,
            is_crit,
            hit_result,
            final_amount,
        }
    }
}

/// Fraction of damage that bypasses armor (`1 - armor / (armor + K)`), in `[0, 1]`.
// docref:start combat-formulas-armor-mitigation
#[must_use]
pub fn armor_mitigation(armor: f64, armor_k: f64) -> f64 {
    if armor <= 0.0 {
        return 1.0;
    }
    let mitigated = armor / (armor + armor_k);
    (1.0 - mitigated.clamp(0.0, 1.0)).max(0.0)
}
// docref:end combat-formulas-armor-mitigation

#[cfg(test)]
#[path = "damage/tests.rs"]
mod tests;