wowlab_engine_domain/dbc/

weapon.rs

//! Weapon classification into the `game.item_damage_scaling.weapon_type` key.

use wowlab_types::{
    constants::MS_PER_SECOND,
    data::{ItemDamageScalingFlat, ItemQuality, ResolvedItem, WeaponStats},
};

use super::{InventoryType, WeaponSubclass};

const DAMAGE_RANGE_HALF: f64 = 2.0;

/// Weapon classification bucket keyed by `game.item_damage_scaling.weapon_type`.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[non_exhaustive]
pub enum WeaponClass {
    OneHand,
    TwoHand,
    OneHandCaster,
    TwoHandCaster,
}

impl WeaponClass {
    /// The `weapon_type` string stored in `game.item_damage_scaling`.
    #[must_use]
    pub const fn weapon_type_string(self) -> &'static str {
        match self {
            WeaponClass::OneHand => "one_hand",
            WeaponClass::TwoHand => "two_hand",
            WeaponClass::OneHandCaster => "one_hand_caster",
            WeaponClass::TwoHandCaster => "two_hand_caster",
        }
    }
}

/// Classify a weapon by `inventory_type`, `item_subclass`, and caster-weapon flag; `None` for non-weapons.
#[must_use]
pub fn classify_weapon(
    inventory_type: i32,
    item_subclass: i32,
    is_caster: bool,
) -> Option<WeaponClass> {
    match InventoryType::try_from(inventory_type).ok()? {
        InventoryType::Weapon | InventoryType::MainHandWeapon | InventoryType::OffHandWeapon => {
            if is_caster {
                Some(WeaponClass::OneHandCaster)
            } else {
                Some(WeaponClass::OneHand)
            }
        }
        InventoryType::TwoHandWeapon => {
            if is_caster {
                Some(WeaponClass::TwoHandCaster)
            } else {
                Some(WeaponClass::TwoHand)
            }
        }
        InventoryType::Ranged | InventoryType::Thrown | InventoryType::RangedRight => {
            match WeaponSubclass::try_from(item_subclass).ok()? {
                WeaponSubclass::Bow | WeaponSubclass::Gun | WeaponSubclass::Crossbow => {
                    Some(WeaponClass::TwoHand)
                }
                WeaponSubclass::Thrown => Some(WeaponClass::OneHand),
                WeaponSubclass::Wand => Some(WeaponClass::OneHandCaster),
            }
        }
        _ => None,
    }
}

const NORMALIZED_SPEED_1H_S: f64 = 2.4;
const NORMALIZED_SPEED_2H_S: f64 = 3.6;

/// Normalized weapon speed (seconds) for AP-contribution.
#[must_use]
pub const fn normalized_speed_s(class: WeaponClass) -> f64 {
    match class {
        WeaponClass::OneHand | WeaponClass::OneHandCaster => NORMALIZED_SPEED_1H_S,
        WeaponClass::TwoHand | WeaponClass::TwoHandCaster => NORMALIZED_SPEED_2H_S,
    }
}

/// Resolve an equipped weapon's damage range from its DBC item and scaling rows.
#[must_use]
pub fn resolve_weapon_stats(
    item: &ResolvedItem,
    damage: &ItemDamageScalingFlat,
    spec_is_caster: bool,
) -> Option<WeaponStats> {
    let class = classify_weapon(item.inventory_type, item.subclass_id, spec_is_caster)?;

    let quality_index = match ItemQuality::from_dbc(item.quality) {
        Some(ItemQuality::Heirloom) => {
            tracing::warn!(
                item_id = item.id,
                quality_index = ItemQuality::Artifact as i32,
                "Heirloom weapon quality uses the highest quality scaling column"
            );

            ItemQuality::Artifact as i32
        }
        Some(quality) => quality as i32,
        None => {
            tracing::warn!(
                item_id = item.id,
                quality = item.quality,
                "weapon has unsupported quality; weapon DPS skipped"
            );

            return None;
        }
    };

    let dps = match damage.quality(quality_index) {
        Some(value) if value > 0.0 => value,
        _ => {
            tracing::warn!(
                item_id = item.id,
                item_level = item.item_level,
                quality_index,
                "weapon damage scaling column is missing or zero"
            );

            0.0
        }
    };

    let variance = if item.dmg_variance > 0.0 {
        f64::from(item.dmg_variance)
    } else {
        tracing::warn!(
            item_id = item.id,
            "weapon damage variance is missing or zero"
        );

        0.0
    };

    let speed_ms = if item.speed > 0 {
        wowlab_types::numeric::i32_to_u32_nonnegative(item.speed)
    } else {
        tracing::warn!(
            item_id = item.id,
            "weapon speed is missing or zero; auto-attack will skip this weapon"
        );

        0
    };

    let average = dps * (f64::from(speed_ms) / MS_PER_SECOND);
    let minimum = average * (1.0 - variance / DAMAGE_RANGE_HALF);
    let maximum = average * (1.0 + variance / DAMAGE_RANGE_HALF);

    Some(WeaponStats {
        min_damage: minimum,
        max_damage: maximum,
        speed_ms,
        normalized_speed_s: normalized_speed_s(class),
        item_class: item.class_id,
        subclass: item.subclass_id,
        inventory_type: item.inventory_type,
    })
}

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

    use super::*;

    #[gtest]
    fn test_mainhand_physical_is_one_hand() {
        expect_that!(
            classify_weapon(InventoryType::MainHandWeapon as i32, 7, false),
            eq(Some(WeaponClass::OneHand))
        );
    }

    #[gtest]
    fn test_mainhand_caster_is_one_hand_caster() {
        expect_that!(
            classify_weapon(InventoryType::MainHandWeapon as i32, 15, true),
            eq(Some(WeaponClass::OneHandCaster))
        );
    }

    #[gtest]
    fn test_two_hand_physical() {
        expect_that!(
            classify_weapon(InventoryType::TwoHandWeapon as i32, 1, false),
            eq(Some(WeaponClass::TwoHand))
        );
    }

    #[gtest]
    fn test_two_hand_caster_staff() {
        expect_that!(
            classify_weapon(InventoryType::TwoHandWeapon as i32, 10, true),
            eq(Some(WeaponClass::TwoHandCaster))
        );
    }

    #[gtest]
    fn test_bow_is_two_hand() {
        expect_that!(
            classify_weapon(
                InventoryType::RangedRight as i32,
                WeaponSubclass::Bow as i32,
                false
            ),
            eq(Some(WeaponClass::TwoHand))
        );
    }

    #[gtest]
    fn test_wand_is_one_hand_caster() {
        expect_that!(
            classify_weapon(
                InventoryType::RangedRight as i32,
                WeaponSubclass::Wand as i32,
                false
            ),
            eq(Some(WeaponClass::OneHandCaster))
        );
    }

    #[gtest]
    fn test_thrown_is_one_hand() {
        expect_that!(
            classify_weapon(
                InventoryType::Thrown as i32,
                WeaponSubclass::Thrown as i32,
                false
            ),
            eq(Some(WeaponClass::OneHand))
        );
    }

    #[gtest]
    fn test_non_weapon_returns_none() {
        expect_that!(classify_weapon(5, 0, false), eq(None));
    }

    #[gtest]
    fn test_weapon_type_strings() {
        expect_that!(WeaponClass::OneHand.weapon_type_string(), eq("one_hand"));
        expect_that!(WeaponClass::TwoHand.weapon_type_string(), eq("two_hand"));
        expect_that!(
            WeaponClass::OneHandCaster.weapon_type_string(),
            eq("one_hand_caster")
        );
        expect_that!(
            WeaponClass::TwoHandCaster.weapon_type_string(),
            eq("two_hand_caster")
        );
    }

    #[gtest]
    fn test_normalized_speeds() {
        expect_that!(
            normalized_speed_s(WeaponClass::OneHand),
            near(2.4, f64::EPSILON)
        );
        expect_that!(
            normalized_speed_s(WeaponClass::OneHandCaster),
            near(2.4, f64::EPSILON)
        );
        expect_that!(
            normalized_speed_s(WeaponClass::TwoHand),
            near(3.6, f64::EPSILON)
        );
        expect_that!(
            normalized_speed_s(WeaponClass::TwoHandCaster),
            near(3.6, f64::EPSILON)
        );
    }
}