wowlab_engine_domain/

gear.rs

//! Gear stat decoding: typed `StatType` enum over `WoW` DBC `stat_type` IDs plus [`apply_item_stat`].

use wowlab_engine_gamedata::RatingMultiplierSlot;
use wowlab_types::{
    constants::HUNDRED,
    data::{ResolvedItem, SpellDataFlat},
    game::{Attribute, ClassId, GearSlot, RatingType, SpecId},
};

use crate::{
    dbc::{ArmorSubclass, AttributeMask, AuraSubtypeKind, InventoryType, ItemClass},
    stats::{PrimaryStats, Ratings, primary_stat_for_spec},
};

const BASE_CRIT_DAMAGE_MULTIPLIER: f64 = 2.0;
const CRAFTED_PLACEHOLDER_STAT_IDS: [i32; 2] = [24, 25];
const CRIT_EFFECTIVENESS_PER_UNIQUE_COLOR: f64 = 0.0015;

/// Returns the rating-multiplier column for an inventory type.
#[must_use]
pub fn rating_multiplier_slot(inventory_type: i32) -> Option<RatingMultiplierSlot> {
    match InventoryType::try_from(inventory_type).ok() {
        Some(InventoryType::Neck | InventoryType::Finger) => Some(RatingMultiplierSlot::Jewelry),
        Some(InventoryType::Trinket) => Some(RatingMultiplierSlot::Trinket),
        Some(
            InventoryType::Weapon
            | InventoryType::TwoHandWeapon
            | InventoryType::MainHandWeapon
            | InventoryType::OffHandWeapon
            | InventoryType::Ranged
            | InventoryType::RangedRight
            | InventoryType::Thrown,
        ) => Some(RatingMultiplierSlot::Weapon),
        Some(
            InventoryType::Head
            | InventoryType::Shoulder
            | InventoryType::Body
            | InventoryType::Chest
            | InventoryType::Waist
            | InventoryType::Legs
            | InventoryType::Feet
            | InventoryType::Wrists
            | InventoryType::Hands
            | InventoryType::Shield
            | InventoryType::Cloak
            | InventoryType::Robe
            | InventoryType::Holdable,
        ) => Some(RatingMultiplierSlot::Armor),
        _ => None,
    }
}

const fn inventory_type_bit(kind: InventoryType) -> i32 {
    1_i32 << kind as i32
}

const MATCHING_ARMOR_INVENTORY_MASK: i32 = inventory_type_bit(InventoryType::Head)
    | inventory_type_bit(InventoryType::Shoulder)
    | inventory_type_bit(InventoryType::Chest)
    | inventory_type_bit(InventoryType::Waist)
    | inventory_type_bit(InventoryType::Legs)
    | inventory_type_bit(InventoryType::Feet)
    | inventory_type_bit(InventoryType::Wrists)
    | inventory_type_bit(InventoryType::Hands)
    | inventory_type_bit(InventoryType::Robe);

/// Armor slots required for specialization; cloaks are exempt.
#[rustfmt::skip]
pub const MATCHING_ARMOR_SLOTS: [GearSlot; 8] = [
    GearSlot::Head,
    GearSlot::Shoulders,
    GearSlot::Chest,
    GearSlot::Waist,
    GearSlot::Legs,
    GearSlot::Feet,
    GearSlot::Wrists,
    GearSlot::Hands,
];

/// DBC-provided primary-stat percentages gated by matching equipped armor.
#[derive(Clone, Copy, Debug, Default, PartialEq)]
pub struct MatchingArmorPassive {
    strength: Percent,
    agility: Percent,
    stamina: Percent,
    intellect: Percent,
}

impl MatchingArmorPassive {
    /// Returns an empty matching-armor payload.
    #[must_use]
    pub const fn new() -> Self {
        Self {
            strength: Percent::ZERO,
            agility: Percent::ZERO,
            stamina: Percent::ZERO,
            intellect: Percent::ZERO,
        }
    }

    /// Returns the DBC percentage for `attribute`.
    #[must_use]
    pub const fn percent_for(self, attribute: Attribute) -> f64 {
        match attribute {
            Attribute::Strength => self.strength.value(),
            Attribute::Agility => self.agility.value(),
            Attribute::Stamina => self.stamina.value(),
            Attribute::Intellect => self.intellect.value(),
        }
    }

    pub(crate) fn add_scaled(&mut self, other: Self, scale: f64) {
        self.strength.add_scaled(other.strength, scale);
        self.agility.add_scaled(other.agility, scale);
        self.stamina.add_scaled(other.stamina, scale);
        self.intellect.add_scaled(other.intellect, scale);
    }

    fn add_effect(&mut self, stat_mask: i32, percent: f64) {
        let mask = AttributeMask::from_dbc(stat_mask);

        if mask.contains(AttributeMask::STRENGTH) {
            self.strength.add(percent);
        }

        if mask.contains(AttributeMask::AGILITY) {
            self.agility.add(percent);
        }

        if mask.contains(AttributeMask::STAMINA) {
            self.stamina.add(percent);
        }

        if mask.contains(AttributeMask::INTELLECT) {
            self.intellect.add(percent);
        }
    }
}

#[derive(Clone, Copy, Debug, Default, PartialEq)]
struct Percent(f64);

impl Percent {
    const ZERO: Self = Self(0.0);

    const fn value(self) -> f64 {
        self.0
    }

    fn add(&mut self, value: f64) {
        self.0 += value;
    }

    fn add_scaled(&mut self, other: Self, scale: f64) {
        self.0 += other.0 * scale;
    }
}

/// Resolves a matching-armor specialization passive and its DBC stat payload.
///
/// Gear resolution owns whether the equipped armor satisfies the requirement.
/// This function only identifies the requirement and retains its aura-137 stat percentages.
#[must_use]
pub fn matching_armor_specialization_passive(
    spell: &SpellDataFlat,
) -> Option<MatchingArmorPassive> {
    if !spell.is_passive {
        return None;
    }

    let requirement = spell.equipped_item_requirement?;

    if requirement.item_class != ItemClass::Armor as i32
        || requirement.inventory_type_mask & MATCHING_ARMOR_INVENTORY_MASK
            != MATCHING_ARMOR_INVENTORY_MASK
        || requirement.subclass_mask == 0
    {
        return None;
    }

    let mut passive = MatchingArmorPassive::default();
    let mut has_stat_effect = false;

    for effect in &spell.effects {
        if effect.aura != AuraSubtypeKind::ModTotalStatPercentage as i32 {
            continue;
        }

        passive.add_effect(effect.misc_value_1, effect.base_points);
        has_stat_effect = true;
    }

    has_stat_effect.then_some(passive)
}

/// Returns a class's specialized armor subclass; mirrors `SimC`'s `util::matching_armor_type`.
#[must_use]
pub const fn class_armor_subclass(class: ClassId) -> ArmorSubclass {
    match class {
        ClassId::Warrior | ClassId::Paladin | ClassId::DeathKnight => ArmorSubclass::Plate,
        ClassId::Hunter | ClassId::Shaman | ClassId::Evoker => ArmorSubclass::Mail,
        ClassId::Rogue | ClassId::Monk | ClassId::Druid | ClassId::DemonHunter => {
            ArmorSubclass::Leather
        }
        ClassId::Mage | ClassId::Priest | ClassId::Warlock => ArmorSubclass::Cloth,
    }
}

/// Maps a `WoW` DBC `stat_type` integer onto the engine's typed stat buckets.
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
#[non_exhaustive]
pub enum StatType {
    Agility,
    Strength,
    Intellect,
    Stamina,
    Crit,
    Haste,
    Versatility,
    Mastery,
    Avoidance,
    Leech,
    Speed,
    ComboPrimary,
}

/// Spec-resolved destination bucket for an item-stat row.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[non_exhaustive]
pub enum StatBucket {
    Primary(Attribute),
    Rating(RatingType),
}

// Versatility has two ids: damage-done (40, canonical) and combined (61); both decode to the same bucket.
macro_rules! stat_type_table {
    ( $( $variant:ident, $canonical_id:literal $(, $alias_id:literal )* => $bucket:expr ; )+ ) => {
        impl TryFrom<i32> for StatType {
            type Error = UnknownStatType;

            fn try_from(value: i32) -> Result<Self, Self::Error> {
                match value {
                    $( $canonical_id $( | $alias_id )* => Ok(StatType::$variant), )+
                    COMBO_PRIMARY_STAT_MIN..=COMBO_PRIMARY_STAT_MAX => Ok(StatType::ComboPrimary),
                    other => Err(UnknownStatType(other)),
                }
            }
        }

        impl From<StatType> for i32 {
            fn from(value: StatType) -> Self {
                match value {
                    $( StatType::$variant => $canonical_id, )+
                    StatType::ComboPrimary => COMBO_PRIMARY_STAT_MIN,
                }
            }
        }

        impl StatType {
            /// Resolve to a spec-resolved [`StatBucket`].
            pub fn resolve_for_spec(self, spec: SpecId) -> StatBucket {
                match self {
                    $( StatType::$variant => $bucket, )+
                    StatType::ComboPrimary => StatBucket::Primary(primary_stat_for_spec(spec)),
                }
            }
        }
    };
}

const COMBO_PRIMARY_STAT_MIN: i32 = 71;
const COMBO_PRIMARY_STAT_MAX: i32 = 74;

stat_type_table! {
    Agility,     3            => StatBucket::Primary(Attribute::Agility);
    Strength,    4            => StatBucket::Primary(Attribute::Strength);
    Intellect,   5            => StatBucket::Primary(Attribute::Intellect);
    Stamina,     7            => StatBucket::Primary(Attribute::Stamina);
    Crit,        32           => StatBucket::Rating(RatingType::Crit);
    Haste,       36           => StatBucket::Rating(RatingType::Haste);
    Versatility, 40, 61       => StatBucket::Rating(RatingType::Versatility);
    Mastery,     49           => StatBucket::Rating(RatingType::Mastery);
    Avoidance,   91           => StatBucket::Rating(RatingType::Avoidance);
    Leech,       93           => StatBucket::Rating(RatingType::Leech);
    Speed,       94           => StatBucket::Rating(RatingType::Speed);
}

/// Returned by [`StatType::try_from`] for an unrecognised `stat_type` integer.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct UnknownStatType(i32);

impl UnknownStatType {
    /// Returns the unrecognized DBC stat identifier.
    #[must_use]
    pub const fn value(self) -> i32 {
        self.0
    }
}

impl core::fmt::Display for UnknownStatType {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "unknown WoW stat_type {}", self.0)
    }
}

impl core::error::Error for UnknownStatType {}

/// Apply a single item-stat row onto `primary` / `ratings`; unknown ids are dropped and logged.
pub fn apply_item_stat(
    primary: &mut PrimaryStats,
    ratings: &mut Ratings,
    spec: SpecId,
    stat_type: i32,
    value: f64,
) {
    let typed = match StatType::try_from(stat_type) {
        Ok(typed) => typed,
        Err(error) => {
            tracing::warn!(
                target: "wowlab::gear",
                stat_type = error.value(),
                value,
                "unknown WoW stat_type id; item stat dropped"
            );

            return;
        }
    };

    match typed.resolve_for_spec(spec) {
        StatBucket::Primary(attr) => primary.add(attr, value),
        StatBucket::Rating(rating) => ratings.add(rating, value),
    }
}

/// Scales and rounds rating stats by the slot multiplier.
#[must_use]
pub fn scale_rating_item_stat(stat_type: i32, value: f64, rating_multiplier: f64) -> f64 {
    match StatType::try_from(stat_type) {
        Ok(
            StatType::Crit
            | StatType::Haste
            | StatType::Versatility
            | StatType::Mastery
            | StatType::Avoidance
            | StatType::Leech
            | StatType::Speed,
        ) => (value * rating_multiplier).round(),
        _ => value,
    }
}

/// Apply all resolved item-stat rows, including crafted placeholder remapping.
pub fn apply_resolved_item_stats(
    item: &ResolvedItem,
    crafted_stats: Option<&[u32]>,
    rating_multiplier: f64,
    primary: &mut PrimaryStats,
    ratings: &mut Ratings,
    spec: SpecId,
) {
    for stat in &item.stats {
        let stat_type = remap_crafted_stat(stat.stat_type, crafted_stats);
        let value = scale_rating_item_stat(stat_type, f64::from(stat.value), rating_multiplier);

        apply_item_stat(primary, ratings, spec, stat_type, value);
    }
}

fn remap_crafted_stat(stat_type: i32, crafted_stats: Option<&[u32]>) -> i32 {
    let Some(crafted_stats) = crafted_stats else {
        return stat_type;
    };

    let crafted_stat = CRAFTED_PLACEHOLDER_STAT_IDS
        .iter()
        .position(|&placeholder| placeholder == stat_type)
        .and_then(|slot| crafted_stats.get(slot));

    crafted_stat.map_or(stat_type, |&stat| {
        wowlab_types::numeric::u32_to_i32_saturating(stat)
    })
}

/// Fold the Powerful Eversong Diamond bonus over distinct Midnight gem colors.
#[must_use]
pub fn crit_effectiveness_with_unique_gems(
    current_multiplier: f64,
    unique_color_count: usize,
) -> f64 {
    let count = f64::from(wowlab_types::numeric::usize_to_u32_saturating(
        unique_color_count,
    ));

    current_multiplier * (1.0 + CRIT_EFFECTIVENESS_PER_UNIQUE_COLOR * count)
}

/// Apply a percentage increase to critical-strike effectiveness.
#[must_use]
pub const fn crit_effectiveness_with_percent(current_multiplier: f64, percent: f64) -> f64 {
    current_multiplier * (1.0 + percent / HUNDRED)
}

/// Convert critical-strike effectiveness into bonus critical-damage percentage points.
#[must_use]
pub const fn crit_damage_bonus_from_effectiveness(multiplier: f64) -> f64 {
    (BASE_CRIT_DAMAGE_MULTIPLIER * multiplier - BASE_CRIT_DAMAGE_MULTIPLIER) * HUNDRED
}

/// Extract the Midnight gem color suffix while excluding meta gems.
#[must_use]
pub fn gem_color_key(name: &str) -> Option<&str> {
    (!name.contains("Diamond"))
        .then(|| name.split_whitespace().next_back())
        .flatten()
}

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

    use super::*;

    #[gtest]
    fn primary_stat_ids_decode() {
        expect_that!(StatType::try_from(3), eq(Ok(StatType::Agility)));
        expect_that!(StatType::try_from(4), eq(Ok(StatType::Strength)));
        expect_that!(StatType::try_from(5), eq(Ok(StatType::Intellect)));
        expect_that!(StatType::try_from(7), eq(Ok(StatType::Stamina)));
    }

    #[gtest]
    fn rating_ids_decode() {
        expect_that!(StatType::try_from(32), eq(Ok(StatType::Crit)));
        expect_that!(StatType::try_from(36), eq(Ok(StatType::Haste)));
        expect_that!(StatType::try_from(49), eq(Ok(StatType::Mastery)));
        expect_that!(StatType::try_from(91), eq(Ok(StatType::Avoidance)));
        expect_that!(StatType::try_from(93), eq(Ok(StatType::Leech)));
        expect_that!(StatType::try_from(94), eq(Ok(StatType::Speed)));
    }

    #[gtest]
    fn versatility_accepts_both_ids() {
        expect_that!(StatType::try_from(40), eq(Ok(StatType::Versatility)));
        expect_that!(StatType::try_from(61), eq(Ok(StatType::Versatility)));
    }

    #[gtest]
    fn combo_primary_range_is_inclusive() {
        for id in 71..=74 {
            expect_that!(StatType::try_from(id), eq(Ok(StatType::ComboPrimary)));
        }
    }

    #[gtest]
    fn legacy_ids_are_unknown() {
        for id in [31, 37, 13, 14] {
            expect_that!(StatType::try_from(id).is_err(), is_true());
        }
    }

    #[gtest]
    fn round_trip_canonical_ids() {
        for typed in [
            StatType::Agility,
            StatType::Strength,
            StatType::Intellect,
            StatType::Stamina,
            StatType::Crit,
            StatType::Haste,
            StatType::Mastery,
            StatType::Avoidance,
            StatType::Leech,
            StatType::Speed,
        ] {
            let raw: i32 = typed.into();

            expect_that!(StatType::try_from(raw), eq(Ok(typed)));
        }
    }

    #[gtest]
    fn versatility_canonical_id_is_damage_done() {
        let raw: i32 = StatType::Versatility.into();

        expect_that!(raw, eq(40));
        expect_that!(StatType::try_from(raw), eq(Ok(StatType::Versatility)));
    }

    #[gtest]
    fn combo_primary_resolves_to_spec_primary() {
        expect_that!(
            StatType::ComboPrimary.resolve_for_spec(SpecId::Outlaw),
            eq(StatBucket::Primary(Attribute::Agility))
        );
        expect_that!(
            StatType::ComboPrimary.resolve_for_spec(SpecId::Arms),
            eq(StatBucket::Primary(Attribute::Strength))
        );
        expect_that!(
            StatType::ComboPrimary.resolve_for_spec(SpecId::FrostMage),
            eq(StatBucket::Primary(Attribute::Intellect))
        );
    }

    #[gtest]
    fn apply_item_stat_routes_primary() {
        let mut primary = PrimaryStats::default();
        let mut ratings = Ratings::default();

        apply_item_stat(&mut primary, &mut ratings, SpecId::Outlaw, 3, 100.0);
        expect_that!(primary.agility, near(100.0, f64::EPSILON));
    }

    #[gtest]
    fn apply_item_stat_routes_rating() {
        let mut primary = PrimaryStats::default();
        let mut ratings = Ratings::default();

        apply_item_stat(&mut primary, &mut ratings, SpecId::Outlaw, 32, 250.0);
        expect_that!(ratings.crit, near(250.0, f64::EPSILON));
    }

    #[gtest]
    fn apply_item_stat_combo_primary_uses_spec_primary() {
        let mut primary = PrimaryStats::default();
        let mut ratings = Ratings::default();

        apply_item_stat(&mut primary, &mut ratings, SpecId::Outlaw, 72, 50.0);
        expect_that!(primary.agility, near(50.0, f64::EPSILON));

        let mut primary = PrimaryStats::default();
        let mut ratings = Ratings::default();

        apply_item_stat(&mut primary, &mut ratings, SpecId::Arms, 71, 50.0);
        expect_that!(primary.strength, near(50.0, f64::EPSILON));
    }

    #[gtest]
    fn rating_multiplier_slot_mirrors_simc() {
        expect_that!(
            rating_multiplier_slot(InventoryType::Neck as i32),
            eq(Some(RatingMultiplierSlot::Jewelry))
        );
        expect_that!(
            rating_multiplier_slot(InventoryType::Finger as i32),
            eq(Some(RatingMultiplierSlot::Jewelry))
        );
        expect_that!(
            rating_multiplier_slot(InventoryType::Trinket as i32),
            eq(Some(RatingMultiplierSlot::Trinket))
        );
        expect_that!(
            rating_multiplier_slot(InventoryType::TwoHandWeapon as i32),
            eq(Some(RatingMultiplierSlot::Weapon))
        );
        expect_that!(
            rating_multiplier_slot(InventoryType::Chest as i32),
            eq(Some(RatingMultiplierSlot::Armor))
        );
        expect_that!(rating_multiplier_slot(0), eq(None));
        expect_that!(rating_multiplier_slot(19), eq(None));
    }

    #[gtest]
    fn scale_rating_item_stat_scales_ratings_only() {
        let jewelry_mult = 1.305_538_02;

        expect_that!(
            scale_rating_item_stat(32, 100.0, jewelry_mult),
            near(131.0, f64::EPSILON)
        );
        expect_that!(
            scale_rating_item_stat(4, 100.0, jewelry_mult),
            near(100.0, f64::EPSILON)
        );
        expect_that!(
            scale_rating_item_stat(7, 100.0, jewelry_mult),
            near(100.0, f64::EPSILON)
        );
    }

    #[gtest]
    fn apply_item_stat_unknown_id_is_noop() {
        let mut primary = PrimaryStats::default();
        let mut ratings = Ratings::default();

        apply_item_stat(&mut primary, &mut ratings, SpecId::Outlaw, 999, 100.0);
        expect_that!(primary.agility.abs() < f64::EPSILON, is_true());
        expect_that!(ratings.crit.abs() < f64::EPSILON, is_true());
    }

    #[gtest]
    fn midnight_gem_color_uses_the_color_name_and_excludes_meta_gems() -> Result<()> {
        verify_that!(gem_color_key("Flawless Masterful Lapis"), some(eq("Lapis")))?;

        verify_that!(gem_color_key("Powerful Eversong Diamond"), none())
    }
}