wowlab_parsers/parsers/scaling/

resolve.rs

// #t(file: rust_alloc_in_loop) bonus resolution builds per-bonus diagnostic strings

//! Unified item resolution shared by the sim and the tooltip.

use wowlab_types::{
    constants::MAX_PLAYER_LEVEL,
    data::{
        AppliedBonus, ItemDataFlat, ItemEffect, ItemQuality, ItemScalingData, ResolvedItem,
        ResolvedSocket, ResolvedStat,
    },
    numeric::f64_to_i32_saturating_round,
    sim::IntMap,
};

use super::{
    bonus::{ALLOC_MULTIPLIER, BonusType, collect_bonuses, resolve_item_level},
    curve::interpolate_curve,
    stats::{get_stat_budget, get_stat_name, inventory_type_to_slot_index},
};

const CRAFTED_PLACEHOLDER_STAT_IDS: [i32; 2] = [24, 25];

struct ParsedItem {
    item_level: i32,
    quality: i32,
    required_level: i32,
    crafting_quality: i32,
    stat_allocs: Vec<(i32, i32)>,
    sockets: Vec<i32>,
    effects: Vec<ItemEffect>,
    applied: Vec<AppliedBonus>,
}

// docref:start items-scaling-resolve-item
/// Resolve an item's full effective state from its bonus IDs (the `weapon` field is left for the sim).
// #t(fn: rust_cyclomatic_complexity) one exhaustive 21-variant match over every BonusType
// #t(fn: rust_max_fn_lines) the exhaustive parsed-mutation pass and assembly live in one function
#[must_use]
pub fn resolve_item(
    base: &ItemDataFlat,
    bonus_ids: &[i32],
    scaling_data: &ItemScalingData,
    player_level: Option<i32>,
    drop_level: Option<i32>,
    forced_item_level: Option<i32>,
) -> ResolvedItem {
    // docref:end items-scaling-resolve-item
    let player_level = player_level.unwrap_or_else(|| i32::from(MAX_PLAYER_LEVEL));
    let slot_index = inventory_type_to_slot_index(base.inventory_type);

    let bonuses = collect_bonuses(bonus_ids, scaling_data);
    let level = resolve_item_level(
        &bonuses,
        base.item_level,
        bonus_ids,
        scaling_data,
        drop_level,
    );
    // An explicit `ilevel=` overrides bonus-derived scaling.
    let item_level = forced_item_level.unwrap_or(level.item_level);

    let mut parsed = ParsedItem {
        item_level,
        quality: base.quality,
        required_level: base.required_level,
        crafting_quality: 0,
        stat_allocs: base.stats.iter().map(|s| (s.stat_type, s.value)).collect(),
        sockets: base.sockets.clone(),
        effects: base.effects.clone(),
        applied: level.applied,
    };

    for bonus in &bonuses {
        match BonusType::try_from(bonus.bonus_type) {
            Ok(BonusType::Quality) => {
                parsed.quality = bonus.value_0;
                parsed.applied.push(AppliedBonus {
                    bonus_list_id: bonus.parent_item_bonus_list_id,
                    bonus_type: bonus.bonus_type,
                    description: format!("Quality set to {}", bonus.value_0),
                });
            }
            Ok(BonusType::Socket) => {
                for _ in 0..bonus.value_0.max(0) {
                    parsed.sockets.push(bonus.value_1);
                }

                parsed.applied.push(AppliedBonus {
                    bonus_list_id: bonus.parent_item_bonus_list_id,
                    bonus_type: bonus.bonus_type,
                    description: format!("+{} socket(s) of color {}", bonus.value_0, bonus.value_1),
                });
            }
            Ok(BonusType::ReqLevel) => {
                parsed.required_level += bonus.value_0;
                parsed.applied.push(AppliedBonus {
                    bonus_list_id: bonus.parent_item_bonus_list_id,
                    bonus_type: bonus.bonus_type,
                    description: format!("Required level {:+}", bonus.value_0),
                });
            }
            Ok(BonusType::ModItemStat) => {
                for slot in &mut parsed.stat_allocs {
                    if CRAFTED_PLACEHOLDER_STAT_IDS.contains(&slot.0) {
                        slot.0 = bonus.value_0;
                    }
                }

                parsed.applied.push(AppliedBonus {
                    bonus_list_id: bonus.parent_item_bonus_list_id,
                    bonus_type: bonus.bonus_type,
                    description: format!("Crafted stat -> {}", get_stat_name(bonus.value_0)),
                });
            }
            Ok(BonusType::AddItemEffect) => {
                parsed.effects.push(ItemEffect {
                    spell_id: 0,
                    trigger_type: 0,
                    charges: 0,
                    cooldown: 0,
                    category_cooldown: 0,
                });
                parsed.applied.push(AppliedBonus {
                    bonus_list_id: bonus.parent_item_bonus_list_id,
                    bonus_type: bonus.bonus_type,
                    description: format!("Add item effect {} (data deferred)", bonus.value_0),
                });
            }
            Ok(BonusType::CraftingQuality) => {
                parsed.crafting_quality = bonus.value_2 + 1;
                parsed.applied.push(AppliedBonus {
                    bonus_list_id: bonus.parent_item_bonus_list_id,
                    bonus_type: bonus.bonus_type,
                    description: format!("Crafting quality tier {}", parsed.crafting_quality),
                });
            }
            Ok(BonusType::Mod) => {
                match parsed
                    .stat_allocs
                    .iter_mut()
                    .find(|(stat_type, _)| *stat_type == bonus.value_0)
                {
                    Some(slot) => slot.1 += bonus.value_1,
                    None => parsed.stat_allocs.push((bonus.value_0, bonus.value_1)),
                }
            }
            Ok(
                BonusType::Ilevel
                | BonusType::SetIlevel2
                | BonusType::SquishCurve
                | BonusType::ScaleConfig
                | BonusType::ApplyBonus
                | BonusType::ScaleConfig2
                | BonusType::PostSquishItemLevel
                | BonusType::Scaling
                | BonusType::Scaling2
                | BonusType::Desc
                | BonusType::Suffix
                | BonusType::SetIlevel
                | BonusType::AddRank
                | BonusType::IlevelInPvp,
            )
            | Err(_) => {}
        }
    }

    let budget = if let Some(quality) = ItemQuality::from_dbc(parsed.quality) {
        if let Some(budget) = get_stat_budget(scaling_data, parsed.item_level, quality, slot_index)
        {
            budget
        } else {
            tracing::warn!(
                item_id = base.id,
                item_level = parsed.item_level,
                quality = parsed.quality,
                "item stat allocation has no RandPropPoints budget; allocated stats skipped"
            );

            0.0
        }
    } else {
        tracing::warn!(
            item_id = base.id,
            quality = parsed.quality,
            "item has unsupported DBC quality; allocated stats skipped"
        );

        0.0
    };

    let mut stats_map: IntMap<i32, f64> = IntMap::default();

    for (stat_type, alloc) in &parsed.stat_allocs {
        let value = f64::from(*alloc) * budget * ALLOC_MULTIPLIER;

        *stats_map.entry(*stat_type).or_default() += value;
    }

    for bonus in &bonuses {
        if matches!(
            BonusType::try_from(bonus.bonus_type),
            Ok(BonusType::Scaling | BonusType::Scaling2)
        ) && let Some(scaled_value) =
            interpolate_curve(scaling_data, bonus.value_0, f64::from(player_level))
        {
            let stat_type = bonus.value_1;

            if stat_type > 0 {
                *stats_map.entry(stat_type).or_default() += scaled_value;
                parsed.applied.push(AppliedBonus {
                    bonus_list_id: bonus.parent_item_bonus_list_id,
                    bonus_type: bonus.bonus_type,
                    description: format!(
                        "+{} {} (scaled)",
                        f64_to_i32_saturating_round(scaled_value),
                        get_stat_name(stat_type)
                    ),
                });
            }
        }
    }

    let stats: Vec<ResolvedStat> = stats_map
        .into_iter()
        .map(|(stat_type, value)| ResolvedStat {
            stat_type,
            stat_name: get_stat_name(stat_type).to_string(),
            value: f64_to_i32_saturating_round(value),
        })
        .filter(|s| s.value != 0)
        .collect();

    let sockets: Vec<ResolvedSocket> = parsed
        .sockets
        .iter()
        .map(|&color| ResolvedSocket { color })
        .collect();

    ResolvedItem {
        id: base.id,
        name: base.name.to_string(),
        file_name: base.file_name.to_string(),
        description: base.description.clone(),
        base_item_level: base.item_level,
        item_level: parsed.item_level,
        quality: parsed.quality,
        required_level: parsed.required_level,
        crafting_quality: parsed.crafting_quality,
        inventory_type: base.inventory_type,
        class_id: base.class_id,
        subclass_id: base.subclass_id,
        binding: base.binding,
        speed: base.speed,
        dmg_variance: base.dmg_variance,
        classification: base.classification.clone(),
        stats,
        sockets,
        socket_bonus_enchant_id: base.socket_bonus_enchant_id,
        effects: parsed.effects,
        item_set_id: base.item_set_id,
        set_info: base.set_info.clone(),
        weapon: None,
        applied_bonuses: parsed.applied,
    }
}

#[cfg(test)]
mod resolve_tests {
    use googletest::prelude::*;
    use wowlab_types::data::{ItemBonusFlat, ItemStat, RandPropPointsFlat};

    use super::*;

    fn bonus_list(
        data: &mut ItemScalingData,
        list_id: i32,
        bonus_type: i32,
        order_index: i32,
        value_0: i32,
        value_1: i32,
        value_2: i32,
    ) {
        data.bonuses
            .entry(list_id)
            .or_default()
            .push(ItemBonusFlat {
                id: list_id * 100 + order_index,
                parent_item_bonus_list_id: list_id,
                bonus_type,
                value_0,
                value_1,
                value_2,
                value_3: 0,
                order_index,
            });
    }

    fn budget_row(data: &mut ItemScalingData, ilvl: i32, superior: f64, epic: f64) {
        data.rand_prop_points.insert(
            ilvl,
            RandPropPointsFlat {
                id: ilvl,
                superior_f_0: superior,
                epic_f_0: epic,
                ..Default::default()
            },
        );
    }

    pub(super) fn base_item(
        item_level: i32,
        quality: i32,
        inventory_type: i32,
        stats: Vec<ItemStat>,
    ) -> ItemDataFlat {
        ItemDataFlat {
            item_level,
            quality,
            inventory_type,
            stats,
            ..Default::default()
        }
    }

    #[gtest]
    fn test_resolve_item_quality_override() -> Result<()> {
        let mut data = ItemScalingData::default();

        bonus_list(&mut data, 1, 3, 0, 4, 0, 0);
        budget_row(&mut data, 100, 1000.0, 2000.0);

        let base = base_item(
            100,
            3,
            1,
            vec![ItemStat {
                stat_type: 3,
                value: 10000,
            }],
        );

        let rare = resolve_item(&base, &[], &data, None, None, None);
        let epic = resolve_item(&base, &[1], &data, None, None, None);

        verify_that!(rare.quality, eq(3))?;
        verify_that!(epic.quality, eq(4))?;
        let rare_val = rare
            .stats
            .iter()
            .find(|s| s.stat_type == 3)
            .or_fail()?
            .value;
        let epic_val = epic
            .stats
            .iter()
            .find(|s| s.stat_type == 3)
            .or_fail()?
            .value;

        verify_that!(rare_val, eq(1000))?;
        verify_that!(epic_val, eq(2000))?;

        Ok(())
    }

    #[gtest]
    fn test_resolve_item_sockets() -> Result<()> {
        let mut data = ItemScalingData::default();

        bonus_list(&mut data, 1, 6, 0, 2, 5, 0);
        budget_row(&mut data, 100, 1000.0, 2000.0);

        let mut base = base_item(100, 4, 1, vec![]);

        base.sockets = vec![1];

        let resolved = resolve_item(&base, &[1], &data, None, None, None);

        verify_that!(resolved.sockets.len(), eq(3))?;
        verify_that!(resolved.sockets[1].color, eq(5))?;
        verify_that!(resolved.sockets[2].color, eq(5))?;

        Ok(())
    }

    #[gtest]
    fn test_resolve_item_req_level() -> Result<()> {
        let mut data = ItemScalingData::default();

        bonus_list(&mut data, 1, 8, 0, 10, 0, 0);
        budget_row(&mut data, 100, 1000.0, 2000.0);

        let mut base = base_item(100, 4, 1, vec![]);

        base.required_level = 60;

        let resolved = resolve_item(&base, &[1], &data, None, None, None);

        verify_that!(resolved.required_level, eq(70))?;

        Ok(())
    }

    #[gtest]
    fn test_resolve_item_crafting_quality() -> Result<()> {
        let mut data = ItemScalingData::default();

        bonus_list(&mut data, 1, 52, 0, 5, 0, 2);
        budget_row(&mut data, 105, 1000.0, 2000.0);

        let base = base_item(100, 4, 1, vec![]);

        let resolved = resolve_item(&base, &[1], &data, None, None, None);

        verify_that!(resolved.item_level, eq(105))?;
        verify_that!(resolved.crafting_quality, eq(3))?;

        Ok(())
    }
}

#[cfg(test)]
mod resolve_parity_tests {
    use googletest::prelude::*;
    use wowlab_types::data::{
        CurveFlat, CurvePointFlat, ItemBonusFlat, ItemOffsetCurveFlat, ItemScalingConfigFlat,
        ItemStat, RandPropPointsFlat,
    };

    use super::{ItemScalingData, resolve_item, resolve_tests::base_item};

    /// Locks `resolve_item` output for the no-mutation case via the Midnight fixture: config 228 → curve 88583 → ilvl 289.
    #[gtest]
    fn test_resolve_item_parity() -> Result<()> {
        let mut data = ItemScalingData::default();

        data.bonuses.insert(
            12806,
            vec![ItemBonusFlat {
                id: 1,
                parent_item_bonus_list_id: 12806,
                bonus_type: 49,
                value_0: 228,
                value_1: 0,
                value_2: 0,
                value_3: 0,
                order_index: 0,
            }],
        );

        data.item_scaling_configs.insert(
            228,
            ItemScalingConfigFlat {
                id: 228,
                item_offset_curve_id: 47,
                item_level: 289,
                required_level: 90,
                item_squish_era_id: 2,
                flags: 0,
            },
        );

        data.item_offset_curves.insert(
            47,
            ItemOffsetCurveFlat {
                id: 47,
                curve_id: 88583,
                offset: 0,
            },
        );

        data.curves.insert(
            88583,
            CurveFlat {
                id: 88583,
                curve_type: 0,
                flags: 0,
            },
        );

        data.curve_points.insert(
            88583,
            vec![
                CurvePointFlat {
                    id: 1,
                    curve_id: 88583,
                    order_index: 0,
                    pos_0: 0.0,
                    pos_1: 0.0,
                    pos_pre_squish_0: 0.0,
                    pos_pre_squish_1: 0.0,
                },
                CurvePointFlat {
                    id: 2,
                    curve_id: 88583,
                    order_index: 1,
                    pos_0: 1300.0,
                    pos_1: 1300.0,
                    pos_pre_squish_0: 0.0,
                    pos_pre_squish_1: 0.0,
                },
            ],
        );

        data.rand_prop_points.insert(
            289,
            RandPropPointsFlat {
                id: 289,
                epic_f_0: 1000.0,
                ..Default::default()
            },
        );

        let stats = vec![ItemStat {
            stat_type: 3,
            value: 5000,
        }];
        let base = base_item(197, 4, 1, stats);

        let resolved = resolve_item(&base, &[12806], &data, None, None, None);

        verify_that!(resolved.item_level, eq(289))?;
        verify_that!(resolved.stats.len(), eq(1))?;
        let stat = resolved.stats.iter().find(|s| s.stat_type == 3).or_fail()?;

        verify_that!(stat.value, eq(500))?;

        Ok(())
    }
}