wowlab_engine_domain/

stats.rs

//! Stat and rating recomputation. Secondary/tertiary stats on [`CombatStats`] are stored as percent points (`25.0` = 25%), never as a fraction.

use wowlab_engine_gamedata::{
    RatingMultiplierSlot, ResolvedCurves, ResolvedGameData, ResolvedGameTables,
};
use wowlab_types::{
    constants::HUNDRED,
    game::{Attribute, RatingType, SpecId},
    numeric::interpolate_sorted,
};

use crate::{constants::BASE_CRIT_CHANCE, dbc::PassiveStatMods};

#[rustfmt::skip]
pub use wowlab_engine_ports::CombatStats;

/// Baseline mastery points every spec starts with.
pub const BASE_MASTERY_POINTS: f64 = 8.0;

/// DR curve for Crit/Haste/Mastery/Versatility.
pub const SECONDARY_DR_CURVE_ID: i32 = 21_024;
/// DR curve for Leech/Speed/Avoidance.
pub const TERTIARY_DR_CURVE_ID: i32 = 21_025;
const BASE_CRIT_MULTIPLIER: f64 = 2.0;

/// Converts haste percent points into a cadence multiplier.
#[must_use]
pub const fn haste_multiplier(stats: &CombatStats) -> f64 {
    1.0 + stats.haste / HUNDRED
}

/// Converts critical-damage bonus percent points into the full critical multiplier.
#[must_use]
pub const fn crit_multiplier(stats: &CombatStats) -> f64 {
    BASE_CRIT_MULTIPLIER + stats.crit_damage_bonus / HUNDRED
}

/// Converts versatility percent points into a damage/healing multiplier.
#[must_use]
pub const fn versatility_multiplier(stats: &CombatStats) -> f64 {
    1.0 + stats.versatility / HUNDRED
}

/// Selects the combat-rating divisor for `rating_type` from the resolved level row.
#[must_use]
pub fn combat_rating_divisor(
    tables: &ResolvedGameTables,
    rating_type: RatingType,
    level: u32,
) -> Option<f64> {
    let row = tables.combat_ratings_row(level)?;

    Some(match rating_type {
        RatingType::Crit => row.crit_spell,
        RatingType::Haste => row.haste_spell,
        RatingType::Mastery => row.mastery,
        RatingType::Versatility => row.versatility_damage_done,
        RatingType::Leech => row.lifesteal,
        RatingType::Avoidance => row.avoidance,
        RatingType::Speed => row.speed,
    })
}

/// Selects the item-level rating multiplier for a gear budget slot.
#[must_use]
pub fn rating_multiplier_at_ilvl(
    tables: &ResolvedGameTables,
    slot: RatingMultiplierSlot,
    item_level: i32,
) -> f64 {
    tables
        .combat_ratings_multiplier_row(item_level)
        .map_or(1.0, |row| match slot {
            RatingMultiplierSlot::Armor => row.armor_multiplier,
            RatingMultiplierSlot::Weapon => row.weapon_multiplier,
            RatingMultiplierSlot::Trinket => row.trinket_multiplier,
            RatingMultiplierSlot::Jewelry => row.jewelry_multiplier,
            _ => 1.0,
        })
}

wowlab_engine_macros::define_error! {
    /// Error raised while converting raw ratings into effective stats.
    #[derive(Debug)]
    pub struct StatsError {
        kind: StatsErrorKind,
    }

    #[derive(Debug, thiserror::Error)]
    enum StatsErrorKind {
        #[error("diminishing-returns curve {curve_id} missing for {rating_type:?}")]
        MissingCurve {
            curve_id: i32,
            rating_type: RatingType,
        },
        #[error("combat-rating divisor missing for {rating_type:?} at level {level}")]
        MissingCombatRating { rating_type: RatingType, level: u32 },
    }
}

impl StatsError {
    fn missing_curve(curve_id: i32, rating_type: RatingType) -> Self {
        Self {
            kind: StatsErrorKind::MissingCurve {
                curve_id,
                rating_type,
            },
        }
    }

    fn missing_combat_rating(rating_type: RatingType, level: u32) -> Self {
        Self {
            kind: StatsErrorKind::MissingCombatRating { rating_type, level },
        }
    }

    /// Tests whether this reports a specific missing diminishing-returns curve.
    #[must_use]
    pub fn is_missing_curve(&self, curve_id: i32, rating_type: RatingType) -> bool {
        matches!(
            self.kind,
            StatsErrorKind::MissingCurve {
                curve_id: found_curve,
                rating_type: found_rating,
            } if found_curve == curve_id && found_rating == rating_type
        )
    }
}

macro_rules! stat_accessors {
    (
        $struct:ident, $enum_ty:ty, [ $( $variant:ident => $field:ident ),+ $(,)? ]
    ) => {
        impl $struct {
            pub fn get(&self, key: $enum_ty) -> f64 {
                match key {
                    $( <$enum_ty>::$variant => self.$field, )+
                }
            }

            pub fn set(&mut self, key: $enum_ty, value: f64) {
                match key {
                    $( <$enum_ty>::$variant => self.$field = value, )+
                }
            }

            pub fn add(&mut self, key: $enum_ty, value: f64) {
                match key {
                    $( <$enum_ty>::$variant => self.$field += value, )+
                }
            }
        }
    };
}

/// Player primary attributes.
#[derive(Clone, Debug, Default)]
pub struct PrimaryStats {
    pub strength: f64,
    pub agility: f64,
    pub intellect: f64,
    pub stamina: f64,
}

stat_accessors!(PrimaryStats, Attribute, [
    Strength => strength,
    Agility => agility,
    Intellect => intellect,
    Stamina => stamina,
]);

/// Raw secondary and tertiary stat ratings before DR conversion.
#[derive(Clone, Debug, Default)]
pub struct Ratings {
    pub crit: f64,
    pub haste: f64,
    pub mastery: f64,
    pub versatility: f64,
    pub leech: f64,
    pub avoidance: f64,
    pub speed: f64,
}

stat_accessors!(Ratings, RatingType, [
    Crit => crit,
    Haste => haste,
    Mastery => mastery,
    Versatility => versatility,
    Leech => leech,
    Avoidance => avoidance,
    Speed => speed,
]);

/// Convert a raw rating to effective percent points via the DBC DR curve.
///
/// # Errors
///
/// Returns an error when the required diminishing-returns curve is unavailable.
// docref:start stats-rating-to-percent
pub fn rating_to_percent(
    rating: f64,
    rating_type: RatingType,
    divisor: f64,
    curves: &ResolvedCurves,
) -> Result<f64, StatsError> {
    let raw_pct = rating / divisor;
    let curve_id = dr_curve_id(rating_type);
    curves
        .curve_points(curve_id)
        .and_then(|points| interpolate_sorted(points, raw_pct))
        .ok_or_else(|| StatsError::missing_curve(curve_id, rating_type))
}
// docref:end stats-rating-to-percent

/// Convert raw rating from resolved game data into effective percent points.
///
/// Empty introspection data produces a neutral zero instead of requiring rating tables.
///
/// # Errors
///
/// Errors when the level divisor or diminishing-returns curve is unavailable.
pub fn rating_percent_points(
    data: &ResolvedGameData,
    rating_type: RatingType,
    amount: f64,
) -> Result<f64, StatsError> {
    if data.is_empty() {
        return Ok(0.0);
    }

    let divisor = divisor_for(data.game_tables(), rating_type, data.level())?;

    rating_to_percent(amount, rating_type, divisor, data.curves())
}

fn divisor_for(
    tables: &ResolvedGameTables,
    rating_type: RatingType,
    level: u32,
) -> Result<f64, StatsError> {
    combat_rating_divisor(tables, rating_type, level)
        .ok_or_else(|| StatsError::missing_combat_rating(rating_type, level))
}

const fn dr_curve_id(rating_type: RatingType) -> i32 {
    match rating_type {
        RatingType::Crit | RatingType::Haste | RatingType::Versatility | RatingType::Mastery => {
            SECONDARY_DR_CURVE_ID
        }
        RatingType::Leech | RatingType::Avoidance | RatingType::Speed => TERTIARY_DR_CURVE_ID,
    }
}

/// Returns the primary attribute used by a spec.
#[must_use]
pub fn primary_stat_for_spec(spec: SpecId) -> Attribute {
    use SpecId::{
        Affliction, Arcane, Arms, Assassination, Augmentation, Balance, BeastMastery, Blood,
        Brewmaster, Demonology, Destruction, Devastation, Devourer, Discipline, Elemental,
        Enhancement, Feral, Fire, FrostDK, FrostMage, Fury, Guardian, Havoc, HolyPaladin,
        HolyPriest, Marksmanship, Mistweaver, Outlaw, Preservation, ProtPaladin, ProtWarrior,
        RestoDruid, RestoShaman, Retribution, Shadow, Subtlety, Survival, Unholy, Vengeance,
        Windwalker,
    };

    match spec {
        BeastMastery | Marksmanship | Survival | Assassination | Outlaw | Subtlety | Feral
        | Guardian | Brewmaster | Windwalker | Havoc | Vengeance | Enhancement => {
            Attribute::Agility
        }

        Arms | Fury | ProtWarrior | HolyPaladin | ProtPaladin | Retribution | Blood | FrostDK
        | Unholy => Attribute::Strength,

        Discipline | HolyPriest | Shadow | Elemental | RestoShaman | Arcane | Fire | FrostMage
        | Affliction | Demonology | Destruction | Mistweaver | Balance | RestoDruid | Devourer
        | Devastation | Preservation | Augmentation => Attribute::Intellect,
    }
}

// Attack and spell power intentionally share a 1:1 primary-stat model.
const fn attack_and_spell_power(primary_value: f64) -> (f64, f64) {
    (primary_value, primary_value)
}

/// Produces [`CombatStats`] from primaries, ratings, passives, and spec data.
///
/// # Errors
///
/// Returns an error when required game-table rows or rating curves are unavailable.
// #t(fn: rust_large_fn_params) recompute threads every resolved stat input verbatim.
// docref:start stats-recompute
pub fn recompute(
    primary: &PrimaryStats,
    ratings: &Ratings,
    passives: &PassiveStatMods,
    spec: SpecId,
    tables: &ResolvedGameTables,
    level: u32,
    curves: &ResolvedCurves,
) -> Result<CombatStats, StatsError> {
    // docref:end stats-recompute
    let strength = primary.strength * passives.strength_mult;
    let agility = primary.agility * passives.agility_mult;
    let stamina = primary.stamina * passives.stamina_mult;
    let intellect = primary.intellect * passives.intellect_mult;

    let (primary_value, primary_stat_mult) = match primary_stat_for_spec(spec) {
        Attribute::Strength => (strength, passives.strength_mult),
        Attribute::Agility => (agility, passives.agility_mult),
        Attribute::Stamina => (stamina, passives.stamina_mult),
        Attribute::Intellect => (intellect, passives.intellect_mult),
    };

    let (attack_power, spell_power) = attack_and_spell_power(primary_value);

    let crit_divisor = divisor_for(tables, RatingType::Crit, level)?;
    let crit_rating = ratings.crit * passives.crit_rating_mult;
    let crit_pct = rating_to_percent(crit_rating, RatingType::Crit, crit_divisor, curves)?;
    let crit_chance = BASE_CRIT_CHANCE * HUNDRED + crit_pct + passives.crit_chance;

    let haste_divisor = divisor_for(tables, RatingType::Haste, level)?;
    let haste_rating = ratings.haste * passives.haste_rating_mult;
    let haste_pct = rating_to_percent(haste_rating, RatingType::Haste, haste_divisor, curves)?;
    let haste = ((1.0 + haste_pct / HUNDRED) * passives.haste_mult - 1.0) * HUNDRED;

    let mastery_divisor = divisor_for(tables, RatingType::Mastery, level)?;
    // Raw mastery in points (base plus rating); the per-effect coefficient is applied by hooks.
    let mastery_rating = ratings.mastery * passives.mastery_rating_mult;
    let mastery = BASE_MASTERY_POINTS
        + passives.mastery_points
        + rating_to_percent(mastery_rating, RatingType::Mastery, mastery_divisor, curves)?;

    let vers_divisor = divisor_for(tables, RatingType::Versatility, level)?;
    let vers_rating = ratings.versatility * passives.versatility_rating_mult;
    let versatility =
        rating_to_percent(vers_rating, RatingType::Versatility, vers_divisor, curves)?
            + passives.versatility_pct;
    let leech_divisor = divisor_for(tables, RatingType::Leech, level)?;
    let leech = rating_to_percent(ratings.leech, RatingType::Leech, leech_divisor, curves)?;

    // The single place every formula input is known; without it a rating gap and a
    // rating->percent conversion gap are indistinguishable downstream.

    tracing::debug!(
        name: "resolved_combat_stats",
        level,
        attack_power,
        crit_rating = crit_rating,
        crit_divisor,
        crit_chance,
        haste_rating = haste_rating,
        haste_divisor,
        haste,
        mastery_rating = mastery_rating,
        mastery_divisor,
        mastery_base_points = BASE_MASTERY_POINTS + passives.mastery_points,
        mastery,
        versatility_rating = vers_rating,
        vers_divisor,
        versatility,
        "resolved combat stats"
    );

    Ok(CombatStats {
        attack_power,
        spell_power,
        crit_chance,
        haste,
        mastery,
        versatility,
        leech,
        crit_damage_bonus: 0.0,
        armor: 0.0,
        stamina,
        intellect,
        agility,
        strength,
        positive_strength_bonus: 0.0,
        positive_agility_bonus: 0.0,
        positive_stamina_bonus: 0.0,
        positive_intellect_bonus: 0.0,
        primary_stat_mult,
    })
}

// Hand-picked round numbers, not derived from real ratings (no curves available in those contexts).
const PLACEHOLDER_POWER: f64 = 15_000.0;
const PLACEHOLDER_CRIT_PCT: f64 = 25.0;
const PLACEHOLDER_HASTE_PCT: f64 = 15.0;
const PLACEHOLDER_MASTERY_PCT: f64 = 40.0;
const PLACEHOLDER_VERSATILITY_PCT: f64 = 5.0;

/// Placeholder gearless [`CombatStats`]; see the module note on units (percent points).
#[must_use]
pub const fn default_stats() -> CombatStats {
    CombatStats {
        attack_power: PLACEHOLDER_POWER,
        spell_power: PLACEHOLDER_POWER,
        crit_chance: PLACEHOLDER_CRIT_PCT,
        haste: PLACEHOLDER_HASTE_PCT,
        mastery: PLACEHOLDER_MASTERY_PCT,
        versatility: PLACEHOLDER_VERSATILITY_PCT,
        leech: 0.0,
        crit_damage_bonus: 0.0,
        armor: 0.0,
        stamina: 0.0,
        intellect: 0.0,
        agility: 0.0,
        strength: 0.0,
        positive_strength_bonus: 0.0,
        positive_agility_bonus: 0.0,
        positive_stamina_bonus: 0.0,
        positive_intellect_bonus: 0.0,
        primary_stat_mult: 1.0,
    }
}

#[cfg(test)]
mod tests {
    use googletest::prelude::*;
    use rstest::rstest;
    use wowlab_types::sim::IntMap;

    use super::*;

    const LEVEL_90_CRIT_DIVISOR: f64 = 46.0;

    fn secondary_dr_curves() -> ResolvedCurves {
        let mut points: IntMap<i32, Vec<(f64, f64)>> = IntMap::default();

        points.insert(
            SECONDARY_DR_CURVE_ID,
            vec![(0.0, 0.0), (30.0, 30.0), (40.0, 39.0), (50.0, 47.0)],
        );

        ResolvedCurves::from_points(points)
    }

    #[gtest]
    #[rstest]
    #[case::zero_rating(0.0, 0.0)]
    #[case::ret_mid1_crit_below_first_breakpoint(1052.0, 1052.0 / LEVEL_90_CRIT_DIVISOR)]
    #[case::dr_interpolates_past_30(1610.0, 34.5)]
    fn rating_to_percent_level_90_crit_arms(
        #[case] rating: f64,
        #[case] expected_pct: f64,
    ) -> Result<()> {
        let curves = secondary_dr_curves();
        let pct = rating_to_percent(rating, RatingType::Crit, LEVEL_90_CRIT_DIVISOR, &curves)
            .expect("secondary DR curve is seeded");

        verify_that!(pct, near(expected_pct, 1e-9))
    }

    #[gtest]
    fn enhancement_uses_agility_as_its_primary_stat() {
        expect_that!(
            primary_stat_for_spec(SpecId::Enhancement),
            eq(Attribute::Agility)
        );
    }
}