wowlab_parsers/parsers/transform/

scaling.rs

// #t(file: rust_inline_test_module_size) private DBC join fixtures cover the full scaling and permanent-enchant transform matrix beside the implementation

const TWO_HAND_ID_OFFSET: i32 = 100_000;
const AMMO_ID_OFFSET: i32 = 200_000;
const ONE_HAND_CASTER_ID_OFFSET: i32 = 300_000;
const TWO_HAND_CASTER_ID_OFFSET: i32 = 400_000;
const EFFECT_CREATE_ITEM: i32 = 24;
const EFFECT_ENCHANT_ITEM_PERMANENTLY: i32 = 53;
const EFFECT_CRAFTING_DATA_ENCHANT: i32 = 301;
const EFFECT_CRAFTING_DATA_ITEM: i32 = 288;
const PERMANENT_ENCHANT_SKILL_LINES: [i32; 9] = [164, 165, 171, 197, 202, 333, 755, 773, 960];

use wowlab_types::data::{
    ArmorLocationFlat, CooldownSetFlat, CooldownSetSpellEntry, CurveFlat, CurvePointFlat,
    EnchantmentFlat, ExpectedStatFlat, ExpectedStatModFlat, GemPropertiesFlat,
    ItemArmorQualityFlat, ItemArmorShieldFlat, ItemArmorTotalFlat, ItemBonusFlat,
    ItemDamageScalingFlat, ItemOffsetCurveFlat, ItemScalingConfigFlat, ItemSquishEraFlat,
    PermanentEnchantFlat, PowerTypeFlat, RandPropPointsFlat, SpecializationSpellFlat,
};

#[cfg(feature = "dbc")]
use super::super::dbc::DbcData;

/// Flatten every `ItemBonus` row in the DBC dataset into `ItemBonusFlat` records.
#[must_use]
pub fn transform_all_item_bonuses(dbc: &DbcData) -> Vec<ItemBonusFlat> {
    dbc.item_bonus
        .values()
        .flatten()
        .map(|row| ItemBonusFlat {
            id: row.ID,
            value_0: row.Value_0,
            value_1: row.Value_1,
            value_2: row.Value_2,
            value_3: row.Value_3,
            parent_item_bonus_list_id: row.ParentItemBonusListID,
            bonus_type: row.Type,
            order_index: row.OrderIndex,
        })
        .collect()
}

/// Flatten every `Curve` row in the DBC dataset into `CurveFlat` records.
#[must_use]
pub fn transform_all_curves(dbc: &DbcData) -> Vec<CurveFlat> {
    dbc.curve
        .values()
        .map(|row| CurveFlat {
            id: row.ID,
            curve_type: row.Type,
            flags: row.Flags,
        })
        .collect()
}

/// Flatten every `CurvePoint` row in the DBC dataset into `CurvePointFlat` records.
#[must_use]
pub fn transform_all_curve_points(dbc: &DbcData) -> Vec<CurvePointFlat> {
    dbc.curve_point
        .values()
        .flatten()
        .map(|row| CurvePointFlat {
            id: row.ID,
            curve_id: row.CurveID,
            order_index: row.OrderIndex,
            pos_0: row.Pos_0,
            pos_1: row.Pos_1,
            pos_pre_squish_0: row.PosPreSquish_0,
            pos_pre_squish_1: row.PosPreSquish_1,
        })
        .collect()
}

/// Flatten every `RandPropPoints` row in the DBC dataset into `RandPropPointsFlat` records.
#[must_use]
pub fn transform_all_rand_prop_points(dbc: &DbcData) -> Vec<RandPropPointsFlat> {
    dbc.rand_prop_points
        .values()
        .map(|row| RandPropPointsFlat {
            id: row.ID,
            damage_replace_stat_f: row.DamageReplaceStatF,
            damage_secondary_f: row.DamageSecondaryF,
            damage_replace_stat: row.DamageReplaceStat,
            damage_secondary: row.DamageSecondary,
            epic_f_0: row.EpicF_0,
            epic_f_1: row.EpicF_1,
            epic_f_2: row.EpicF_2,
            epic_f_3: row.EpicF_3,
            epic_f_4: row.EpicF_4,
            superior_f_0: row.SuperiorF_0,
            superior_f_1: row.SuperiorF_1,
            superior_f_2: row.SuperiorF_2,
            superior_f_3: row.SuperiorF_3,
            superior_f_4: row.SuperiorF_4,
            good_f_0: row.GoodF_0,
            good_f_1: row.GoodF_1,
            good_f_2: row.GoodF_2,
            good_f_3: row.GoodF_3,
            good_f_4: row.GoodF_4,
            epic_0: row.Epic_0,
            epic_1: row.Epic_1,
            epic_2: row.Epic_2,
            epic_3: row.Epic_3,
            epic_4: row.Epic_4,
            superior_0: row.Superior_0,
            superior_1: row.Superior_1,
            superior_2: row.Superior_2,
            superior_3: row.Superior_3,
            superior_4: row.Superior_4,
            good_0: row.Good_0,
            good_1: row.Good_1,
            good_2: row.Good_2,
            good_3: row.Good_3,
            good_4: row.Good_4,
        })
        .collect()
}

/// Flatten every `ItemScalingConfig` row in the DBC dataset into `ItemScalingConfigFlat` records.
#[must_use]
pub fn transform_all_item_scaling_configs(dbc: &DbcData) -> Vec<ItemScalingConfigFlat> {
    dbc.item_scaling_config
        .values()
        .map(|row| ItemScalingConfigFlat {
            id: row.ID,
            item_offset_curve_id: row.ItemOffsetCurveID,
            item_level: row.ItemLevel,
            required_level: row.RequiredLevel,
            item_squish_era_id: row.ItemSquishEraID,
            flags: row.Flags,
        })
        .collect()
}

/// Flatten every `ItemOffsetCurve` row in the DBC dataset into `ItemOffsetCurveFlat` records.
#[must_use]
pub fn transform_all_item_offset_curves(dbc: &DbcData) -> Vec<ItemOffsetCurveFlat> {
    dbc.item_offset_curve
        .values()
        .map(|row| ItemOffsetCurveFlat {
            id: row.ID,
            curve_id: row.CurveID,
            offset: row.Offset,
        })
        .collect()
}

/// Flatten every `ItemSquishEra` row in the DBC dataset into `ItemSquishEraFlat` records.
#[must_use]
pub fn transform_all_item_squish_eras(dbc: &DbcData) -> Vec<ItemSquishEraFlat> {
    dbc.item_squish_era
        .values()
        .map(|row| ItemSquishEraFlat {
            id: row.ID,
            patch: row.Patch,
            curve_id: row.CurveID,
            flags: row.Flags,
        })
        .collect()
}

/// Flatten every `SpellItemEnchantment` row in the DBC dataset into `EnchantmentFlat` records.
#[must_use]
pub fn transform_all_enchantments(dbc: &DbcData) -> Vec<EnchantmentFlat> {
    dbc.spell_item_enchantment
        .values()
        .map(|row| EnchantmentFlat {
            id: row.ID,
            name: row.Name_lang.clone().unwrap_or_default(),
            duration: row.Duration,
            flags: row.Flags,
            icon_file_data_id: row.IconFileDataID,
            item_level_min: row.ItemLevelMin,
            item_level_max: row.ItemLevelMax,
            item_level: row.ItemLevel,
            charges: row.Charges,
            scaling_class: row.ScalingClass,
            scaling_class_restricted: row.ScalingClassRestricted,
            condition_id: row.Condition_ID,
            min_level: row.MinLevel,
            max_level: row.MaxLevel,
            required_skill_id: row.RequiredSkillID,
            required_skill_rank: row.RequiredSkillRank,
            transmog_use_condition_id: row.TransmogUseConditionID,
            transmog_cost: row.TransmogCost,
            item_visual: row.ItemVisual,
            effect_0: row.Effect_0,
            effect_1: row.Effect_1,
            effect_2: row.Effect_2,
            effect_arg_0: row.EffectArg_0,
            effect_arg_1: row.EffectArg_1,
            effect_arg_2: row.EffectArg_2,
            effect_points_min_0: row.EffectPointsMin_0,
            effect_points_min_1: row.EffectPointsMin_1,
            effect_points_min_2: row.EffectPointsMin_2,
            effect_scaling_points_0: row.EffectScalingPoints_0,
            effect_scaling_points_1: row.EffectScalingPoints_1,
            effect_scaling_points_2: row.EffectScalingPoints_2,
        })
        .collect()
}

fn permanent_enchant_token(name: &str) -> String {
    name.trim_start_matches(['_', '+'])
        .chars()
        .filter(|&character| {
            character.is_ascii_alphanumeric() || matches!(character, '_' | '+' | '.' | '%' | ' ')
        })
        .map(|character| {
            if character == ' ' {
                '_'
            } else {
                character.to_ascii_lowercase()
            }
        })
        .collect()
}

fn permanent_enchant_effect(
    dbc: &DbcData,
    spell_id: i32,
    effect_type: i32,
) -> Option<&crate::parsers::dbc::rows::SpellEffectRow> {
    dbc.spell_effect
        .get(&spell_id)?
        .iter()
        .find(|effect| effect.Effect == effect_type)
}

fn insert_permanent_enchant(
    dbc: &DbcData,
    entries: &mut std::collections::BTreeSet<(String, i32, i32, i32, i32, i32)>,
    tokenized_name: &str,
    rank: i32,
    enchant_id: i32,
    restriction_spell_id: i32,
) {
    if !dbc.spell_item_enchantment.contains_key(&enchant_id) {
        return;
    }

    let Some(restriction) = dbc.spell_equipped_items.get(&restriction_spell_id) else {
        return;
    };

    entries.insert((
        tokenized_name.to_string(),
        rank,
        enchant_id,
        restriction.EquippedItemClass,
        restriction.EquippedItemInvTypes,
        restriction.EquippedItemSubclass,
    ));
}

fn insert_item_permanent_enchants(
    dbc: &DbcData,
    entries: &mut std::collections::BTreeSet<(String, i32, i32, i32, i32, i32)>,
    tokenized_name: &str,
    rank: i32,
    item_id: i32,
) {
    let Some(item_effects) = dbc.item_x_item_effect.get(&item_id) else {
        return;
    };

    for mapping in item_effects {
        let Some(item_effect) = dbc.item_effect.get(&mapping.ItemEffectID) else {
            continue;
        };
        let Some(effect) =
            permanent_enchant_effect(dbc, item_effect.SpellID, EFFECT_ENCHANT_ITEM_PERMANENTLY)
        else {
            continue;
        };

        insert_permanent_enchant(
            dbc,
            entries,
            tokenized_name,
            rank,
            effect.EffectMiscValue_0,
            item_effect.SpellID,
        );
    }
}

/// Build the permanent-enchant index from profession spells and their recipe outputs.
#[must_use]
pub fn transform_all_permanent_enchants(dbc: &DbcData) -> Vec<PermanentEnchantFlat> {
    let mut entries = std::collections::BTreeSet::new();

    for ability in dbc.skill_line_ability.values().flatten() {
        if !PERMANENT_ENCHANT_SKILL_LINES.contains(&ability.SkillLine) {
            continue;
        }

        let Some(name) = dbc
            .spell_name
            .get(&ability.Spell)
            .and_then(|spell| spell.Name_lang.as_deref())
        else {
            continue;
        };
        let tokenized_name = permanent_enchant_token(name);

        if let Some(effect) =
            permanent_enchant_effect(dbc, ability.Spell, EFFECT_ENCHANT_ITEM_PERMANENTLY)
        {
            insert_permanent_enchant(
                dbc,
                &mut entries,
                &tokenized_name,
                0,
                effect.EffectMiscValue_0,
                ability.Spell,
            );
        } else if let Some(effect) =
            permanent_enchant_effect(dbc, ability.Spell, EFFECT_CREATE_ITEM)
        {
            insert_item_permanent_enchants(
                dbc,
                &mut entries,
                &tokenized_name,
                0,
                effect.EffectItemType,
            );
        } else if let Some(effect) =
            permanent_enchant_effect(dbc, ability.Spell, EFFECT_CRAFTING_DATA_ENCHANT)
        {
            if !dbc.crafting_data.contains_key(&effect.EffectMiscValue_0) {
                continue;
            }

            for quality in dbc
                .crafting_data_enchant_quality
                .get(&effect.EffectMiscValue_0)
                .into_iter()
                .flatten()
            {
                let Some(rank) = dbc.crafting_quality.get(&quality.Rank) else {
                    continue;
                };

                insert_permanent_enchant(
                    dbc,
                    &mut entries,
                    &tokenized_name,
                    rank.QualityTier,
                    quality.SpellItemEnchantmentID,
                    ability.Spell,
                );
            }
        } else if let Some(effect) =
            permanent_enchant_effect(dbc, ability.Spell, EFFECT_CRAFTING_DATA_ITEM)
        {
            if !dbc.crafting_data.contains_key(&effect.EffectMiscValue_0) {
                continue;
            }

            for quality in dbc
                .crafting_data_item_quality
                .get(&effect.EffectMiscValue_0)
                .into_iter()
                .flatten()
            {
                let Some(item) = dbc.item.get(&quality.ItemID) else {
                    continue;
                };
                let Some(rank) = dbc.crafting_quality.get(&item.CraftingQualityID) else {
                    continue;
                };

                insert_item_permanent_enchants(
                    dbc,
                    &mut entries,
                    &tokenized_name,
                    rank.QualityTier,
                    quality.ItemID,
                );
            }
        }
    }

    entries
        .into_iter()
        .map(
            |(tokenized_name, rank, enchant_id, item_class, inventory_type_mask, subclass_mask)| {
                PermanentEnchantFlat {
                    enchant_id,
                    rank,
                    item_class,
                    inventory_type_mask,
                    subclass_mask,
                    tokenized_name,
                }
            },
        )
        .collect()
}

/// Flatten every `GemProperties` row in the DBC dataset into `GemPropertiesFlat` records.
#[must_use]
pub fn transform_all_gem_properties(dbc: &DbcData) -> Vec<GemPropertiesFlat> {
    dbc.gem_properties
        .values()
        .map(|row| GemPropertiesFlat {
            id: row.ID,
            enchant_id: row.Enchant_ID,
            gem_type: row.Type,
        })
        .collect()
}

/// Merge the OneHand/TwoHand/Ammo/caster damage tables, offsetting IDs by 100k per weapon type to avoid collisions.
#[must_use]
pub fn transform_all_item_damage_scaling(dbc: &DbcData) -> Vec<ItemDamageScalingFlat> {
    let one_hand = dbc
        .item_damage_one_hand
        .values()
        .map(|row| ItemDamageScalingFlat {
            id: row.ID,
            weapon_type: "one_hand".to_string(),
            item_level: row.ItemLevel,
            quality_0: row.Quality_0,
            quality_1: row.Quality_1,
            quality_2: row.Quality_2,
            quality_3: row.Quality_3,
            quality_4: row.Quality_4,
            quality_5: row.Quality_5,
            quality_6: row.Quality_6,
        });

    let two_hand = dbc
        .item_damage_two_hand
        .values()
        .map(|row| ItemDamageScalingFlat {
            id: row.ID + TWO_HAND_ID_OFFSET,
            weapon_type: "two_hand".to_string(),
            item_level: row.ItemLevel,
            quality_0: row.Quality_0,
            quality_1: row.Quality_1,
            quality_2: row.Quality_2,
            quality_3: row.Quality_3,
            quality_4: row.Quality_4,
            quality_5: row.Quality_5,
            quality_6: row.Quality_6,
        });

    let ammo = dbc
        .item_damage_ammo
        .values()
        .map(|row| ItemDamageScalingFlat {
            id: row.ID + AMMO_ID_OFFSET,
            weapon_type: "ammo".to_string(),
            item_level: row.ItemLevel,
            quality_0: row.Quality_0,
            quality_1: row.Quality_1,
            quality_2: row.Quality_2,
            quality_3: row.Quality_3,
            quality_4: row.Quality_4,
            quality_5: row.Quality_5,
            quality_6: row.Quality_6,
        });

    let one_hand_caster =
        dbc.item_damage_one_hand_caster
            .values()
            .map(|row| ItemDamageScalingFlat {
                id: row.ID + ONE_HAND_CASTER_ID_OFFSET,
                weapon_type: "one_hand_caster".to_string(),
                item_level: row.ItemLevel,
                quality_0: row.Quality_0,
                quality_1: row.Quality_1,
                quality_2: row.Quality_2,
                quality_3: row.Quality_3,
                quality_4: row.Quality_4,
                quality_5: row.Quality_5,
                quality_6: row.Quality_6,
            });

    let two_hand_caster =
        dbc.item_damage_two_hand_caster
            .values()
            .map(|row| ItemDamageScalingFlat {
                id: row.ID + TWO_HAND_CASTER_ID_OFFSET,
                weapon_type: "two_hand_caster".to_string(),
                item_level: row.ItemLevel,
                quality_0: row.Quality_0,
                quality_1: row.Quality_1,
                quality_2: row.Quality_2,
                quality_3: row.Quality_3,
                quality_4: row.Quality_4,
                quality_5: row.Quality_5,
                quality_6: row.Quality_6,
            });

    one_hand
        .chain(two_hand)
        .chain(ammo)
        .chain(one_hand_caster)
        .chain(two_hand_caster)
        .collect()
}

/// Join `CooldownSet` with `CooldownSetSpell`.
#[must_use]
pub fn transform_all_cooldown_sets(dbc: &DbcData) -> Vec<CooldownSetFlat> {
    dbc.cooldown_set
        .values()
        .map(|set| {
            let spells: Vec<CooldownSetSpellEntry> = dbc
                .cooldown_set_spell
                .get(&set.ID)
                .map(|spell_rows| {
                    spell_rows
                        .iter()
                        .map(|s| CooldownSetSpellEntry {
                            spell_id: s.SpellID,
                            category: s.Category,
                            player_condition_id: s.PlayerConditionID,
                            order_index: s.OrderIndex,
                            flags: s.Flags,
                            spell_category_id: s.SpellCategoryID,
                            equip_slot: s.EquipSlot,
                            field_12_1_0_68209_009: s.Field_12_1_0_68209_009,
                        })
                        .collect()
                })
                .unwrap_or_default();

            CooldownSetFlat {
                id: set.ID,
                chr_specialization: set.ChrSpecialization,
                player_condition_id: set.PlayerConditionID,
                spells,
            }
        })
        .collect()
}

/// Flatten every `ExpectedStat` row in the DBC dataset into `ExpectedStatFlat` records.
#[must_use]
pub fn transform_all_expected_stats(dbc: &DbcData) -> Vec<ExpectedStatFlat> {
    dbc.expected_stat
        .values()
        .map(|row| ExpectedStatFlat {
            id: row.ID,
            expansion_id: row.ExpansionID,
            lvl: row.Lvl,
            creature_health: row.CreatureHealth,
            player_health: row.PlayerHealth,
            creature_auto_attack_dps: row.CreatureAutoAttackDps,
            creature_armor: row.CreatureArmor,
            player_mana: row.PlayerMana,
            player_primary_stat: row.PlayerPrimaryStat,
            player_secondary_stat: row.PlayerSecondaryStat,
            armor_constant: row.ArmorConstant,
            creature_spell_damage: row.CreatureSpellDamage,
            content_set_id: row.ContentSetID,
        })
        .collect()
}

/// Flatten every `ExpectedStatMod` row in the DBC dataset into `ExpectedStatModFlat` records.
#[must_use]
pub fn transform_all_expected_stat_mods(dbc: &DbcData) -> Vec<ExpectedStatModFlat> {
    dbc.expected_stat_mod
        .values()
        .map(|row| ExpectedStatModFlat {
            id: row.ID,
            creature_health_mod: row.CreatureHealthMod,
            player_health_mod: row.PlayerHealthMod,
            creature_auto_attack_dps_mod: row.CreatureAutoAttackDPSMod,
            creature_armor_mod: row.CreatureArmorMod,
            player_mana_mod: row.PlayerManaMod,
            player_primary_stat_mod: row.PlayerPrimaryStatMod,
            player_secondary_stat_mod: row.PlayerSecondaryStatMod,
            armor_constant_mod: row.ArmorConstantMod,
            creature_spell_damage_mod: row.CreatureSpellDamageMod,
        })
        .collect()
}

/// Flatten every `PowerType` row in the DBC dataset into `PowerTypeFlat` records.
#[must_use]
pub fn transform_all_power_types(dbc: &DbcData) -> Vec<PowerTypeFlat> {
    dbc.power_type
        .values()
        .map(|row| PowerTypeFlat {
            id: row.ID,
            name_global_string_tag: row.NameGlobalStringTag.clone().unwrap_or_default(),
            cost_global_string_tag: row.CostGlobalStringTag.clone().unwrap_or_default(),
            power_type_enum: row.PowerTypeEnum,
            min_power: row.MinPower,
            max_base_power: row.MaxBasePower,
            center_power: row.CenterPower,
            default_power: row.DefaultPower,
            display_modifier: row.DisplayModifier,
            regen_interrupt_time_ms: row.RegenInterruptTimeMS,
            regen_peace: row.RegenPeace,
            regen_combat: row.RegenCombat,
            flags: row.Flags,
        })
        .collect()
}

/// Flatten every `ItemArmorQuality` row in the DBC dataset into `ItemArmorQualityFlat` records.
#[must_use]
pub fn transform_all_item_armor_quality(dbc: &DbcData) -> Vec<ItemArmorQualityFlat> {
    dbc.item_armor_quality
        .values()
        .map(|row| ItemArmorQualityFlat {
            id: row.ID,
            qualitymod_0: row.Qualitymod_0,
            qualitymod_1: row.Qualitymod_1,
            qualitymod_2: row.Qualitymod_2,
            qualitymod_3: row.Qualitymod_3,
            qualitymod_4: row.Qualitymod_4,
            qualitymod_5: row.Qualitymod_5,
            qualitymod_6: row.Qualitymod_6,
        })
        .collect()
}

/// Flatten every `ItemArmorShield` row in the DBC dataset into `ItemArmorShieldFlat` records.
#[must_use]
pub fn transform_all_item_armor_shield(dbc: &DbcData) -> Vec<ItemArmorShieldFlat> {
    dbc.item_armor_shield
        .values()
        .map(|row| ItemArmorShieldFlat {
            id: row.ID,
            item_level: row.ItemLevel,
            quality_0: row.Quality_0,
            quality_1: row.Quality_1,
            quality_2: row.Quality_2,
            quality_3: row.Quality_3,
            quality_4: row.Quality_4,
            quality_5: row.Quality_5,
            quality_6: row.Quality_6,
        })
        .collect()
}

/// Flatten every `ItemArmorTotal` row in the DBC dataset into `ItemArmorTotalFlat` records.
#[must_use]
pub fn transform_all_item_armor_total(dbc: &DbcData) -> Vec<ItemArmorTotalFlat> {
    dbc.item_armor_total
        .values()
        .map(|row| ItemArmorTotalFlat {
            id: row.ID,
            item_level: row.ItemLevel,
            cloth: row.Cloth,
            leather: row.Leather,
            mail: row.Mail,
            plate: row.Plate,
        })
        .collect()
}

/// Flatten every `SpecializationSpells` row in the DBC dataset into `SpecializationSpellFlat` records.
#[must_use]
pub fn transform_all_specialization_spells(dbc: &DbcData) -> Vec<SpecializationSpellFlat> {
    dbc.specialization_spells
        .values()
        .flatten()
        .map(|row| SpecializationSpellFlat {
            id: row.ID,
            spec_id: row.SpecID,
            spell_id: row.SpellID,
            overrides_spell_id: row.OverridesSpellID,
        })
        .collect()
}

/// Flatten every `ArmorLocation` row in the DBC dataset into `ArmorLocationFlat` records.
#[must_use]
pub fn transform_all_armor_location(dbc: &DbcData) -> Vec<ArmorLocationFlat> {
    dbc.armor_location
        .values()
        .map(|row| ArmorLocationFlat {
            id: row.ID,
            cloth_modifier: row.Clothmodifier,
            leather_modifier: row.Leathermodifier,
            chain_modifier: row.Chainmodifier,
            plate_modifier: row.Platemodifier,
            modifier: row.Modifier,
        })
        .collect()
}

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

    use super::*;
    use crate::parsers::{
        dbc::rows::{
            CooldownSetRow, CooldownSetSpellRow, CraftingDataEnchantQualityRow,
            CraftingDataItemQualityRow, CraftingDataRow, CraftingQualityRow, ItemDamageAmmoRow,
            ItemDamageOneHandCasterRow, ItemDamageOneHandRow, ItemDamageTwoHandCasterRow,
            ItemDamageTwoHandRow, ItemEffectRow, ItemXItemEffectRow, SpellEquippedItemsRow,
            SpellItemEnchantmentRow,
        },
        transform::fixtures::{
            dbc, item_row, skill_line_ability_row, spell_effect_row, spell_name_row,
        },
    };

    fn enchantment_row(id: i32) -> SpellItemEnchantmentRow {
        SpellItemEnchantmentRow {
            ID: id,
            Name_lang: None,
            HordeName_lang: None,
            Duration: 0,
            EffectArg_0: 0,
            EffectArg_1: 0,
            EffectArg_2: 0,
            Flags: 0,
            EffectScalingPoints_0: 0.0,
            EffectScalingPoints_1: 0.0,
            EffectScalingPoints_2: 0.0,
            IconFileDataID: 0,
            ItemLevelMin: 0,
            ItemLevelMax: 0,
            TransmogUseConditionID: 0,
            TransmogCost: 0,
            EffectPointsMin_0: 0.0,
            EffectPointsMin_1: 0.0,
            EffectPointsMin_2: 0.0,
            ItemVisual: 0,
            RequiredSkillID: 0,
            RequiredSkillRank: 0,
            ItemLevel: 0,
            Charges: 0,
            Effect_0: 0,
            Effect_1: 0,
            Effect_2: 0,
            ScalingClass: 0,
            ScalingClassRestricted: 0,
            Condition_ID: 0,
            MinLevel: 0,
            MaxLevel: 0,
        }
    }

    fn equipped_items(
        spell_id: i32,
        inventory_type_mask: i32,
        subclass_mask: i32,
    ) -> SpellEquippedItemsRow {
        SpellEquippedItemsRow {
            ID: spell_id,
            SpellID: spell_id,
            EquippedItemClass: 4,
            EquippedItemInvTypes: inventory_type_mask,
            EquippedItemSubclass: subclass_mask,
        }
    }

    fn add_effect(dbc: &mut DbcData, spell_id: i32, kind: i32, misc: i32, item_id: i32) {
        let mut effect = spell_effect_row(spell_id, kind, 0);

        effect.EffectMiscValue_0 = misc;
        effect.EffectItemType = item_id;
        dbc.spell_effect.insert(spell_id, vec![effect]);
    }

    fn add_item_enchant(
        dbc: &mut DbcData,
        item_id: i32,
        item_effect_id: i32,
        spell_id: i32,
        enchant_id: i32,
        inventory_type_mask: i32,
        subclass_mask: i32,
    ) {
        dbc.item_x_item_effect.insert(
            item_id,
            vec![ItemXItemEffectRow {
                ID: item_effect_id,
                ItemEffectID: item_effect_id,
                ItemID: item_id,
            }],
        );
        dbc.item_effect.insert(
            item_effect_id,
            ItemEffectRow {
                ID: item_effect_id,
                LegacySlotIndex: 0,
                TriggerType: 0,
                Charges: 0,
                CoolDownMSec: 0,
                CategoryCoolDownMSec: 0,
                SpellCategoryID: 0,
                SpellID: spell_id,
                ChrSpecializationID: 0,
            },
        );
        add_effect(
            dbc,
            spell_id,
            EFFECT_ENCHANT_ITEM_PERMANENTLY,
            enchant_id,
            0,
        );
        dbc.spell_equipped_items.insert(
            spell_id,
            equipped_items(spell_id, inventory_type_mask, subclass_mask),
        );
    }

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

        for (spell_id, name, effect_type) in [
            (100, "Plain Enchant", EFFECT_ENCHANT_ITEM_PERMANENTLY),
            (200, "Created Item Enchant", EFFECT_CREATE_ITEM),
            (
                300,
                "Enchant Ring - Eyes of the Eagle",
                EFFECT_CRAFTING_DATA_ENCHANT,
            ),
            (400, "Forest Hunter's Armor Kit", EFFECT_CRAFTING_DATA_ITEM),
        ] {
            dbc.spell_name
                .insert(spell_id, spell_name_row(spell_id, Some(name)));
            dbc.skill_line_ability.insert(
                spell_id,
                vec![skill_line_ability_row(spell_id, 333, spell_id)],
            );
            add_effect(
                &mut dbc,
                spell_id,
                effect_type,
                spell_id + 1_000,
                spell_id + 2_000,
            );
        }

        dbc.spell_item_enchantment
            .insert(1_100, enchantment_row(1_100));
        dbc.spell_equipped_items
            .insert(100, equipped_items(100, 1 << 16, 1 << 2));

        dbc.spell_item_enchantment
            .insert(1_200, enchantment_row(1_200));
        add_item_enchant(&mut dbc, 2_200, 3_200, 4_200, 1_200, 1 << 13, 1 << 3);

        dbc.crafting_data.insert(
            1_300,
            CraftingDataRow {
                ID: 1_300,
                Type: 0,
                CraftingDifficultyID: 0,
                CraftedItemID: 0,
                ItemBonusTreeID: 0,
            },
        );
        dbc.crafting_quality.insert(
            13,
            CraftingQualityRow {
                ID: 13,
                QualityTier: 2,
                CraftingQualityAtlasSetID: 0,
            },
        );
        dbc.crafting_data_enchant_quality.insert(
            1_300,
            vec![CraftingDataEnchantQualityRow {
                ID: 1,
                Rank: 13,
                SpellItemEnchantmentID: 7_967,
                ItemID: 0,
                CraftingDataID: 1_300,
            }],
        );
        dbc.spell_item_enchantment
            .insert(7_967, enchantment_row(7_967));
        dbc.spell_equipped_items
            .insert(300, equipped_items(300, 1 << 11, 0x1f));

        dbc.crafting_data.insert(
            1_400,
            CraftingDataRow {
                ID: 1_400,
                Type: 0,
                CraftingDifficultyID: 0,
                CraftedItemID: 0,
                ItemBonusTreeID: 0,
            },
        );
        dbc.crafting_quality.insert(
            14,
            CraftingQualityRow {
                ID: 14,
                QualityTier: 2,
                CraftingQualityAtlasSetID: 0,
            },
        );
        let mut quality_item = item_row(2_400, 8, 8, 0);

        quality_item.CraftingQualityID = 14;
        dbc.item.insert(2_400, quality_item);
        dbc.crafting_data_item_quality.insert(
            1_400,
            vec![CraftingDataItemQualityRow {
                ID: 2,
                ItemID: 2_400,
                CraftingDataID: 1_400,
            }],
        );
        dbc.spell_item_enchantment
            .insert(8_159, enchantment_row(8_159));
        add_item_enchant(&mut dbc, 2_400, 3_400, 4_400, 8_159, 1 << 7, 0x1e);

        let result = transform_all_permanent_enchants(&dbc);

        verify_that!(
            result,
            unordered_elements_are![
                eq(&PermanentEnchantFlat {
                    enchant_id: 1_100,
                    rank: 0,
                    item_class: 4,
                    inventory_type_mask: 1 << 16,
                    subclass_mask: 1 << 2,
                    tokenized_name: "plain_enchant".to_string(),
                }),
                eq(&PermanentEnchantFlat {
                    enchant_id: 1_200,
                    rank: 0,
                    item_class: 4,
                    inventory_type_mask: 1 << 13,
                    subclass_mask: 1 << 3,
                    tokenized_name: "created_item_enchant".to_string(),
                }),
                eq(&PermanentEnchantFlat {
                    enchant_id: 7_967,
                    rank: 2,
                    item_class: 4,
                    inventory_type_mask: 1 << 11,
                    subclass_mask: 0x1f,
                    tokenized_name: "enchant_ring__eyes_of_the_eagle".to_string(),
                }),
                eq(&PermanentEnchantFlat {
                    enchant_id: 8_159,
                    rank: 2,
                    item_class: 4,
                    inventory_type_mask: 1 << 7,
                    subclass_mask: 0x1e,
                    tokenized_name: "forest_hunters_armor_kit".to_string(),
                }),
            ]
        )
    }

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

        dbc.item_damage_one_hand.insert(
            10,
            ItemDamageOneHandRow {
                ID: 10,
                ItemLevel: 100,
                Quality_0: 0.0,
                Quality_1: 0.0,
                Quality_2: 0.0,
                Quality_3: 0.0,
                Quality_4: 0.0,
                Quality_5: 0.0,
                Quality_6: 0.0,
            },
        );
        dbc.item_damage_two_hand.insert(
            10,
            ItemDamageTwoHandRow {
                ID: 10,
                ItemLevel: 100,
                Quality_0: 0.0,
                Quality_1: 0.0,
                Quality_2: 0.0,
                Quality_3: 0.0,
                Quality_4: 0.0,
                Quality_5: 0.0,
                Quality_6: 0.0,
            },
        );
        dbc.item_damage_ammo.insert(
            10,
            ItemDamageAmmoRow {
                ID: 10,
                ItemLevel: 100,
                Quality_0: 0.0,
                Quality_1: 0.0,
                Quality_2: 0.0,
                Quality_3: 0.0,
                Quality_4: 0.0,
                Quality_5: 0.0,
                Quality_6: 0.0,
            },
        );
        dbc.item_damage_one_hand_caster.insert(
            10,
            ItemDamageOneHandCasterRow {
                ID: 10,
                ItemLevel: 100,
                Quality_0: 0.0,
                Quality_1: 0.0,
                Quality_2: 0.0,
                Quality_3: 0.0,
                Quality_4: 0.0,
                Quality_5: 0.0,
                Quality_6: 0.0,
            },
        );
        dbc.item_damage_two_hand_caster.insert(
            10,
            ItemDamageTwoHandCasterRow {
                ID: 10,
                ItemLevel: 100,
                Quality_0: 0.0,
                Quality_1: 0.0,
                Quality_2: 0.0,
                Quality_3: 0.0,
                Quality_4: 0.0,
                Quality_5: 0.0,
                Quality_6: 0.0,
            },
        );

        let result = transform_all_item_damage_scaling(&dbc);

        verify_that!(result, len(eq(5)))?;
        verify_that!(
            result,
            contains(matches_pattern!(ItemDamageScalingFlat {
                id: eq(&10),
                weapon_type: eq("one_hand"),
                ..
            }))
        )?;
        verify_that!(
            result,
            contains(matches_pattern!(ItemDamageScalingFlat {
                id: eq(&100_010),
                weapon_type: eq("two_hand"),
                ..
            }))
        )?;
        verify_that!(
            result,
            contains(matches_pattern!(ItemDamageScalingFlat {
                id: eq(&200_010),
                weapon_type: eq("ammo"),
                ..
            }))
        )?;
        verify_that!(
            result,
            contains(matches_pattern!(ItemDamageScalingFlat {
                id: eq(&300_010),
                weapon_type: eq("one_hand_caster"),
                ..
            }))
        )?;

        verify_that!(
            result,
            contains(matches_pattern!(ItemDamageScalingFlat {
                id: eq(&400_010),
                weapon_type: eq("two_hand_caster"),
                ..
            }))
        )
    }

    fn cooldown_set_spell(cooldown_set_id: i32, spell_id: i32) -> CooldownSetSpellRow {
        CooldownSetSpellRow {
            ID: 0,
            CooldownSetID: cooldown_set_id,
            SpellID: spell_id,
            Category: 7,
            PlayerConditionID: 0,
            OrderIndex: 0,
            Flags: 0,
            SpellCategoryID: 30,
            EquipSlot: 13,
            Field_12_1_0_68209_009: 1,
        }
    }

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

        dbc.cooldown_set.insert(
            1,
            CooldownSetRow {
                ID: 1,
                ChrSpecialization: 63,
                Field: 0,
                PlayerConditionID: 160_935,
            },
        );
        dbc.cooldown_set.insert(
            2,
            CooldownSetRow {
                ID: 2,
                ChrSpecialization: 64,
                Field: 0,
                PlayerConditionID: 0,
            },
        );
        dbc.cooldown_set_spell.insert(
            1,
            vec![cooldown_set_spell(1, 100), cooldown_set_spell(1, 200)],
        );

        let result = transform_all_cooldown_sets(&dbc);

        verify_that!(
            result,
            contains(matches_pattern!(CooldownSetFlat {
                id: eq(&1),
                player_condition_id: eq(&160_935),
                spells: all!(
                    len(eq(2)),
                    contains(matches_pattern!(CooldownSetSpellEntry {
                        spell_id: eq(&100),
                        category: eq(&7),
                        spell_category_id: eq(&30),
                        equip_slot: eq(&13),
                        field_12_1_0_68209_009: eq(&1),
                        ..
                    }))
                ),
                ..
            }))
        )?;

        verify_that!(
            result,
            contains(matches_pattern!(CooldownSetFlat {
                id: eq(&2),
                spells: len(eq(0)),
                ..
            }))
        )
    }
}