wowlab_parsers/parsers/transform/loot/

crafted.rs

use wowlab_engine_domain::dbc::{SpellEffectKind, spell_effect_kind};
use wowlab_types::{
    data::{CraftedProductFlat, Profession},
    sim::IntMap,
};

use super::shared::{item_display_name, item_level, profession_name};
use crate::parsers::dbc::DbcData;

struct CraftedRecipeMaps {
    by_crafting_data_id: IntMap<i32, i32>,
    by_item_id: IntMap<i32, i32>,
}

fn build_recipe_maps(dbc: &DbcData) -> CraftedRecipeMaps {
    let mut by_crafting_data_id: IntMap<i32, i32> = IntMap::default();
    let mut by_item_id: IntMap<i32, i32> = IntMap::default();

    for effects in dbc.spell_effect.values() {
        for effect in effects {
            match spell_effect_kind(effect.Effect) {
                Some(SpellEffectKind::ModifiedCrafting) => {
                    by_crafting_data_id
                        .entry(effect.EffectMiscValue_0)
                        .or_insert(effect.SpellID);
                }
                Some(SpellEffectKind::CreateItem | SpellEffectKind::CreateHeirloom) => {
                    by_item_id
                        .entry(effect.EffectItemType)
                        .or_insert(effect.SpellID);
                }
                _ => {}
            }
        }
    }

    CraftedRecipeMaps {
        by_crafting_data_id,
        by_item_id,
    }
}

fn resolve_recipe_spell(
    maps: &CraftedRecipeMaps,
    crafting_data_id: i32,
    crafted_item_id: i32,
) -> Option<i32> {
    if let Some(spell) = maps.by_crafting_data_id.get(&crafting_data_id).copied() {
        return Some(spell);
    }

    if crafted_item_id == 0 {
        return None;
    }

    maps.by_item_id.get(&crafted_item_id).copied()
}

fn resolve_profession(dbc: &DbcData, recipe_spell_id: i32) -> Option<(i32, i32)> {
    let abilities = dbc.skill_line_ability.get(&recipe_spell_id)?;

    for ability in abilities {
        for prof in dbc.profession.values() {
            if prof.SkillLineID == ability.SkillLine {
                return Some((prof.ID, prof.ProfessionEnumValue));
            }
        }
    }

    None
}

/// Build crafted-product rows, emitting one per quality variant.
// #t(fn: rust_alloc_in_loop) row construction allocates owned Strings per emitted product
// #t(fn: rust_clone_in_loop) shared crafted_item_name / profession_name cloned into each variant row
#[must_use]
pub fn transform_all_crafted_products(dbc: &DbcData) -> Vec<CraftedProductFlat> {
    let recipe_maps = build_recipe_maps(dbc);
    let mut out: Vec<CraftedProductFlat> = Vec::new();

    for crafting_data in dbc.crafting_data.values() {
        let Some(recipe_spell_id) =
            resolve_recipe_spell(&recipe_maps, crafting_data.ID, crafting_data.CraftedItemID)
        else {
            continue;
        };

        let Some((profession_id, profession_enum_value)) = resolve_profession(dbc, recipe_spell_id)
        else {
            continue;
        };

        let crafted_item_name = item_display_name(dbc, crafting_data.CraftedItemID);
        let profession_label = profession_name(profession_enum_value).to_string();

        let Some(variants) = dbc.crafting_data_item_quality.get(&crafting_data.ID) else {
            continue;
        };

        for variant in variants {
            let Some(modified) = dbc.modified_crafting_item.get(&variant.ItemID) else {
                continue;
            };
            let Some(quality) = dbc.crafting_quality.get(&modified.CraftingQualityID) else {
                continue;
            };

            out.push(CraftedProductFlat {
                id: 0,
                crafting_data_id: crafting_data.ID,
                crafted_item_id: crafting_data.CraftedItemID,
                crafted_item_name: crafted_item_name.clone(),
                quality_tier: quality.QualityTier,
                quality_item_id: variant.ItemID,
                quality_item_name: item_display_name(dbc, variant.ItemID),
                quality_item_level: item_level(dbc, variant.ItemID),
                profession_id,
                profession_name: profession_label.clone(),
                profession_enum_value,
                item_bonus_tree_id: crafting_data.ItemBonusTreeID,
            });
        }
    }

    out
}

/// 1:1 transform of `Profession` rows + name lookup.
#[must_use]
pub fn transform_all_professions(dbc: &DbcData) -> Vec<Profession> {
    dbc.profession
        .values()
        .map(|row| Profession {
            id: row.ID,
            skill_line_id: row.SkillLineID,
            profession_enum_value: row.ProfessionEnumValue,
            name: profession_name(row.ProfessionEnumValue).to_string(),
        })
        .collect()
}

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

    use super::*;
    use crate::parsers::{
        dbc::rows::SpellEffectRow,
        transform::fixtures::{dbc, profession_row, skill_line_ability_row, spell_effect_row},
    };

    #[gtest]
    fn resolve_recipe_spell_priority() -> Result<()> {
        let mut by_crafting_data_id: IntMap<i32, i32> = IntMap::default();
        let mut by_item_id: IntMap<i32, i32> = IntMap::default();

        by_crafting_data_id.insert(1, 1000);
        by_item_id.insert(1, 2000);
        by_item_id.insert(5, 3000);
        let maps = CraftedRecipeMaps {
            by_crafting_data_id,
            by_item_id,
        };

        verify_that!(resolve_recipe_spell(&maps, 1, 1), some(eq(1000)))?;
        verify_that!(resolve_recipe_spell(&maps, 99, 0), none())?;
        verify_that!(resolve_recipe_spell(&maps, 99, 5), some(eq(3000)))?;

        verify_that!(resolve_recipe_spell(&maps, 99, 88), none())
    }

    #[gtest]
    fn build_recipe_maps_keeps_first_and_classifies_effects() -> Result<()> {
        let mut dbc = dbc();

        dbc.spell_effect.insert(
            1,
            vec![
                SpellEffectRow {
                    EffectMiscValue_0: 50,
                    ..spell_effect_row(1000, SpellEffectKind::ModifiedCrafting as i32, 0)
                },
                SpellEffectRow {
                    EffectMiscValue_0: 50,
                    ..spell_effect_row(9999, SpellEffectKind::ModifiedCrafting as i32, 0)
                },
                SpellEffectRow {
                    EffectItemType: 77,
                    ..spell_effect_row(2000, SpellEffectKind::CreateItem as i32, 0)
                },
                SpellEffectRow {
                    EffectItemType: 88,
                    ..spell_effect_row(3000, SpellEffectKind::CreateHeirloom as i32, 0)
                },
            ],
        );

        let maps = build_recipe_maps(&dbc);

        verify_that!(maps.by_crafting_data_id.get(&50), some(eq(&1000)))?;
        verify_that!(maps.by_item_id.get(&77), some(eq(&2000)))?;

        verify_that!(maps.by_item_id.get(&88), some(eq(&3000)))
    }

    #[gtest]
    fn resolve_profession_joins_skill_line() -> Result<()> {
        let mut matched = dbc();

        matched
            .skill_line_ability
            .insert(500, vec![skill_line_ability_row(1, 164, 500)]);
        matched.profession.insert(7, profession_row(7, 164, 2));

        verify_that!(resolve_profession(&matched, 500), some(eq((7, 2))))?;
        verify_that!(resolve_profession(&matched, 999), none())?;

        let mut unmatched = dbc();

        unmatched
            .skill_line_ability
            .insert(600, vec![skill_line_ability_row(2, 999, 600)]);
        unmatched.profession.insert(7, profession_row(7, 164, 2));

        verify_that!(resolve_profession(&unmatched, 600), none())
    }
}