wowlab_parsers/parsers/transform/

item.rs

use wowlab_engine_domain::dbc::InventoryType;
use wowlab_types::data::{
    ItemClassification, ItemDataFlat, ItemDropSource, ItemEffect, ItemSetBonus, ItemSetInfo,
    ItemStat,
};

#[cfg(feature = "dbc")]
use super::{super::dbc::DbcData, super::errors::TransformError};

macro_rules! array_fields {
    ($base:ident . $prefix:ident, [ $($n:literal),+ $(,)? ]) => {
        [ $( $crate::_private::paste::paste!( $base.[<$prefix _ $n>] ) ),+ ]
    };
    (vec $base:ident . $prefix:ident, [ $($n:literal),+ $(,)? ]) => {
        ::std::vec![ $( $crate::_private::paste::paste!( $base.[<$prefix _ $n>] ) ),+ ]
    };
}

#[rustfmt::skip]
const EXPANSION_NAMES: &[(i32, &str)] = &[
    // #t:aligned
    (0 , "Classic")               ,
    (1 , "The Burning Crusade")   ,
    (2 , "Wrath of the Lich King"),
    (3 , "Cataclysm")             ,
    (4 , "Mists of Pandaria")     ,
    (5 , "Warlords of Draenor")   ,
    (6 , "Legion")                ,
    (7 , "Battle for Azeroth")    ,
    (8 , "Shadowlands")           ,
    (9 , "Dragonflight")          ,
    (10, "The War Within")        ,
];

fn combine_allowable_race(low: Option<i64>, high: Option<i64>) -> i64 {
    const WORD_BITS: u32 = 32;
    let [byte_0, byte_1, byte_2, byte_3, ..] = low.unwrap_or(-1).to_le_bytes();
    let low = i64::from(u32::from_le_bytes([byte_0, byte_1, byte_2, byte_3]));
    let high = high.unwrap_or(-1);

    (high << WORD_BITS) | low
}

// Bit N (0-indexed) maps to `Difficulty.ID == N + 1`.
fn decode_difficulty_mask(mask: i32) -> Vec<i32> {
    const MAX_DIFFICULTY_ID: i32 = 31;

    if mask == -1 || mask == 0 {
        return Vec::new();
    }

    (1..=MAX_DIFFICULTY_ID)
        .filter(|id| mask & (1 << (id - 1)) != 0)
        .collect()
}

fn get_expansion_name(id: i32) -> &'static str {
    EXPANSION_NAMES
        .iter()
        .find(|(i, _)| *i == id)
        .map_or("Unknown", |(_, name)| *name)
}

fn get_inventory_type_name(id: i32) -> &'static str {
    InventoryType::try_from(id)
        .ok()
        .map_or("Unknown", InventoryType::display_name)
}

/// Assemble a flat item record from the Item, `ItemSparse`, set, source, and appearance DBC tables.
///
/// # Errors
///
/// Returns [`TransformError`] when `item_id` is absent from the DBC data.
// #t(rust_max_fn_lines) item transform gathers 15+ DBC tables and computes set info, drop sources, etc.
pub fn transform_item(dbc: &DbcData, item_id: i32) -> Result<ItemDataFlat, TransformError> {
    let item = dbc
        .item
        .get(&item_id)
        .ok_or_else(|| TransformError::item_not_found(item_id))?;

    let sparse = dbc.item_sparse.get(&item_id);

    let mut icon_file_data_id = item.IconFileDataID;

    if icon_file_data_id == 0
        && let Some(modified_appearance) = dbc.item_modified_appearance.get(&item_id)
        && let Some(appearance) = dbc
            .item_appearance
            .get(&modified_appearance.ItemAppearanceID)
        && appearance.DefaultIconFileDataID > 0
    {
        icon_file_data_id = appearance.DefaultIconFileDataID;
    }

    let file_name = super::resolve_icon_file_name(dbc, icon_file_data_id);

    let effect_links = dbc.item_x_item_effect.get(&item_id);
    let effects: Vec<ItemEffect> = effect_links
        .map(|links| {
            links
                .iter()
                .filter_map(|link| {
                    dbc.item_effect
                        .get(&link.ItemEffectID)
                        .map(|effect| ItemEffect {
                            spell_id: effect.SpellID,
                            trigger_type: effect.TriggerType,
                            charges: effect.Charges,
                            cooldown: effect.CoolDownMSec,
                            category_cooldown: effect.CategoryCoolDownMSec,
                        })
                })
                .collect()
        })
        .unwrap_or_default();

    let stats: Vec<ItemStat> = sparse
        .map(|s| {
            let stat_types = array_fields!(s.StatModifierBonusStat, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
            let stat_values = array_fields!(s.StatPercentEditor, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);

            stat_types
                .iter()
                .zip(stat_values.iter())
                .filter(|&(&t, _)| t != -1 && t != 0)
                .map(|(&t, &v)| ItemStat {
                    stat_type: t,
                    value: v,
                })
                .collect()
        })
        .unwrap_or_default();

    let expansion_id = sparse.map_or(0, |s| s.ExpansionID);
    let item_class_row = dbc.item_class_by_class_id.get(&item.ClassID);
    let item_sub_classes = dbc.item_sub_class_by_class_id.get(&item.ClassID);
    let item_sub_class_row =
        item_sub_classes.and_then(|scs| scs.iter().find(|sc| sc.SubClassID == item.SubclassID));

    let classification = Some(ItemClassification {
        class_id: item.ClassID,
        class_name: item_class_row
            .and_then(|c| c.ClassName_lang.clone())
            .unwrap_or_else(|| "Unknown".to_string())
            .into(),
        subclass_id: item.SubclassID,
        subclass_name: item_sub_class_row
            .and_then(|sc| sc.DisplayName_lang.clone())
            .unwrap_or_else(|| "Unknown".to_string())
            .into(),
        inventory_type: item.InventoryType,
        inventory_type_name: get_inventory_type_name(item.InventoryType).into(),
        expansion_id,
        expansion_name: get_expansion_name(expansion_id).into(),
    });

    let sockets: Vec<i32> = sparse
        .map(|s| {
            array_fields!(s.SocketType, [0, 1, 2])
                .into_iter()
                .filter(|&t| t > 0)
                .collect()
        })
        .unwrap_or_default();

    let flags: Vec<i32> = sparse
        .map(|s| array_fields!(vec s.Flags, [0, 1, 2, 3, 4]))
        .unwrap_or_default();

    let item_set_id = sparse.map_or(0, |s| s.ItemSet);
    let set_info = if item_set_id > 0 {
        dbc.item_set.get(&item_set_id).map(|item_set| {
            let item_ids: Vec<i32> = array_fields!(
                item_set.ItemID,
                [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
            )
            .into_iter()
            .filter(|&id| id > 0)
            .collect();

            let bonuses: Vec<ItemSetBonus> = dbc
                .item_set_spell
                .get(&item_set_id)
                .map(|spells| {
                    spells
                        .iter()
                        .map(|spell| ItemSetBonus {
                            threshold: spell.Threshold,
                            spell_id: spell.SpellID,
                            spec_id: spell.ChrSpecID,
                        })
                        .collect()
                })
                .unwrap_or_default();

            ItemSetInfo {
                set_id: item_set_id,
                set_name: item_set
                    .Name_lang
                    .clone()
                    .unwrap_or_else(|| "Unknown Set".to_string())
                    .into(),
                item_ids,
                bonuses,
            }
        })
    } else {
        None
    };

    let drop_sources: Vec<ItemDropSource> = dbc
        .journal_encounter_item
        .get(&item_id)
        .map(|encounter_items| {
            encounter_items
                .iter()
                .filter_map(|encounter_item| {
                    let encounter = dbc
                        .journal_encounter
                        .get(&encounter_item.JournalEncounterID)?;
                    let instance = dbc.journal_instance.get(&encounter.JournalInstanceID);

                    Some(ItemDropSource {
                        instance_id: instance.map_or(0, |i| i.ID),
                        instance_name: instance
                            .and_then(|i| i.Name_lang.clone())
                            .unwrap_or_else(|| "Unknown".to_string())
                            .into(),
                        encounter_id: encounter.ID,
                        encounter_name: encounter
                            .Name_lang
                            .clone()
                            .unwrap_or_else(|| "Unknown".to_string())
                            .into(),
                        difficulty_ids: decode_difficulty_mask(encounter_item.DifficultyMask),
                    })
                })
                .collect()
        })
        .unwrap_or_default();

    Ok(ItemDataFlat {
        id: item_id,
        name: sparse
            .and_then(|s| s.Display_lang.clone())
            .unwrap_or_default()
            .into(),
        description: sparse
            .and_then(|s| s.Description_lang.clone())
            .unwrap_or_default(),
        file_name: file_name.into(),
        item_level: sparse.map_or(0, |s| s.ItemLevel),
        quality: sparse.map_or(0, |s| s.OverallQualityID),
        required_level: sparse.map_or(0, |s| s.RequiredLevel),
        binding: sparse.map_or(0, |s| s.Bonding),
        buy_price: sparse.map_or(0, |s| s.BuyPrice),
        sell_price: sparse.map_or(0, |s| s.SellPrice),
        max_count: sparse.map_or(0, |s| s.MaxCount),
        stackable: sparse.map_or(1, |s| s.Stackable),
        speed: sparse.map_or(0, |s| s.ItemDelay),
        class_id: item.ClassID,
        subclass_id: item.SubclassID,
        inventory_type: item.InventoryType,
        classification,
        stats,
        effects,
        sockets,
        socket_bonus_enchant_id: sparse.map_or(0, |s| s.SocketMatchEnchantmentID),
        flags,
        allowable_class: sparse.map_or(-1, |s| s.AllowableClass),
        allowable_race: sparse.map_or(-1, |s| {
            combine_allowable_race(s.AllowableRaces_0, s.AllowableRaces_1)
        }),
        expansion_id,
        item_set_id,
        set_info,
        drop_sources,
        dmg_variance: sparse.map_or(0.0, |s| s.DmgVariance),
        gem_properties: sparse.map_or(0, |s| s.GemProperties),
        modified_crafting_reagent_item_id: item.ModifiedCraftingReagentItemID,
    })
}

/// Transform every item row into flat `ItemDataFlat` records.
#[must_use]
pub fn transform_all_items(dbc: &DbcData) -> Vec<ItemDataFlat> {
    super::transform_all(dbc.item.keys().copied(), "item", |item_id| {
        transform_item(dbc, item_id)
    })
}

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

    use super::*;

    #[gtest]
    #[rstest]
    #[case::both_none(None, None, -1)]
    #[case::low_zero_high_zero(Some(0), Some(0), 0)]
    #[case::low_only(Some(5), Some(0), 5)]
    #[case::high_only(Some(0), Some(1), 4_294_967_296)]
    #[case::low_negative_masked(Some(-1), Some(0), 4_294_967_295)]
    #[case::none_low_some_high(None, Some(0), 4_294_967_295)]
    fn combine_allowable_race_cases(
        #[case] low: Option<i64>,
        #[case] high: Option<i64>,
        #[case] expected: i64,
    ) -> Result<()> {
        verify_that!(combine_allowable_race(low, high), eq(expected))
    }

    #[gtest]
    #[rstest]
    #[case::zero(0, vec![])]
    #[case::minus_one(-1, vec![])]
    #[case::bit0(0b1, vec![1])]
    #[case::bit0_and_2(0b101, vec![1, 3])]
    #[case::high_bit(1 << 30, vec![31])]
    #[case::mixed(0b1010, vec![2, 4])]
    fn decode_difficulty_mask_cases(#[case] mask: i32, #[case] expected: Vec<i32>) -> Result<()> {
        verify_that!(decode_difficulty_mask(mask), eq(&expected))
    }

    #[gtest]
    #[rstest]
    #[case::classic(0, "Classic")]
    #[case::tww(10, "The War Within")]
    #[case::unknown(99, "Unknown")]
    #[case::negative(-1, "Unknown")]
    fn get_expansion_name_cases(#[case] id: i32, #[case] expected: &str) -> Result<()> {
        verify_that!(get_expansion_name(id), eq(expected))
    }

    #[gtest]
    #[rstest]
    #[case::head(1, "Head")]
    #[case::two_hand(17, "Two-Hand")]
    #[case::relic(28, "Relic")]
    #[case::gap_27(27, "Unknown")]
    #[case::unknown(99, "Unknown")]
    fn get_inventory_type_name_cases(#[case] id: i32, #[case] expected: &str) -> Result<()> {
        verify_that!(get_inventory_type_name(id), eq(expected))
    }
}