wowlab_parsers/parsers/transform/

spell.rs

#[cfg(feature = "dbc")]
use wowlab_engine_domain::dbc::{
    AuraSubtypeKind, SpellAttributeKind, SpellEffectKind, aura_subtype_kind, spell_attribute_is,
    spell_attribute_is_any, spell_effect_is, spell_effect_is_any,
};
#[cfg(feature = "dbc")]
use wowlab_types::constants::DEFAULT_GCD_MS_I32;
#[cfg(feature = "dbc")]
use wowlab_types::data::{
    EmpowerStage, KnowledgeSource, LearnSpell, PeriodicType, PowerCostEntry, RefreshBehavior,
    RppmMod, SpellDataFlat, SpellEffect, SpellLabel,
};

#[cfg(feature = "dbc")]
use super::super::dbc::DbcData;
#[cfg(feature = "dbc")]
use super::super::dbc::rows::SpellEffectRow;
#[cfg(feature = "dbc")]
use super::super::errors::TransformError;

#[cfg(all(feature = "dbc", test))]
const TEST_MAX_TARGETS: i32 = 7;

#[cfg(feature = "dbc")]
#[expect(
    clippy::struct_excessive_bools,
    reason = "these independent flags mirror orthogonal spell attributes and are consumed by name"
)]
struct AuraFlags {
    duration_hasted: bool,
    hasted_ticks: bool,
    tick_may_crit: bool,
    tick_on_application: bool,
    pandemic_refresh: bool,
    rolling_periodic: bool,
}

#[cfg(feature = "dbc")]
struct PeriodicInfo {
    periodic_type: Option<PeriodicType>,
    tick_period_ms: i32,
}

#[cfg(feature = "dbc")]
fn extract_aura_flags(attributes: &[i32]) -> AuraFlags {
    AuraFlags {
        duration_hasted: spell_attribute_is(attributes, SpellAttributeKind::HasteAffectsDuration),
        hasted_ticks: spell_attribute_is_any(
            attributes,
            &[
                SpellAttributeKind::SpellHasteAffectsPeriodic,
                SpellAttributeKind::MeleeHasteAffectsPeriodic,
            ],
        ),
        tick_may_crit: spell_attribute_is(attributes, SpellAttributeKind::PeriodicCanCrit),
        tick_on_application: spell_attribute_is(attributes, SpellAttributeKind::TickOnApplication),
        pandemic_refresh: spell_attribute_is(
            attributes,
            SpellAttributeKind::PeriodicRefreshExtendsDuration,
        ),
        rolling_periodic: spell_attribute_is(attributes, SpellAttributeKind::RollingPeriodic),
    }
}

#[cfg(feature = "dbc")]
fn extract_periodic_info(dbc: &DbcData, spell_id: i32) -> PeriodicInfo {
    let effects = dbc
        .spell_effect
        .get(&spell_id)
        .map_or(&[] as &[SpellEffectRow], Vec::as_slice);

    for effect in effects {
        if !spell_effect_is(effect.Effect, SpellEffectKind::ApplyAura) {
            continue;
        }

        let periodic_type = match aura_subtype_kind(effect.EffectAura) {
            Some(AuraSubtypeKind::PeriodicDamage) => Some(PeriodicType::Damage),
            Some(AuraSubtypeKind::PeriodicHeal) => Some(PeriodicType::Heal),
            Some(AuraSubtypeKind::PeriodicLeech) => Some(PeriodicType::Leech),
            Some(AuraSubtypeKind::PeriodicEnergize) => Some(PeriodicType::Energize),
            Some(AuraSubtypeKind::PeriodicTriggerSpell) => Some(PeriodicType::TriggerSpell),
            _ => None,
        };

        if periodic_type.is_some() {
            return PeriodicInfo {
                periodic_type,
                tick_period_ms: effect.EffectAuraPeriod,
            };
        }
    }

    PeriodicInfo {
        periodic_type: None,
        tick_period_ms: 0,
    }
}

#[cfg(feature = "dbc")]
fn effect_radius(dbc: &DbcData, effect: &SpellEffectRow) -> Option<(f32, f32)> {
    let index = [effect.EffectRadiusIndex_0, effect.EffectRadiusIndex_1]
        .into_iter()
        .find(|index| *index > 0)?;

    dbc.spell_radius
        .get(&index)
        .map(|radius| (radius.RadiusMin, radius.RadiusMax))
}

#[cfg(feature = "dbc")]
fn knowledge_source(spell_id: i32, context: Option<&SpellKnowledgeContext>) -> KnowledgeSource {
    let Some(context) = context else {
        return KnowledgeSource::Unknown;
    };

    if let Some(definition_id) = context
        .talent_spell_id_to_trait_definition_id
        .as_ref()
        .and_then(|talents| talents.get(&spell_id))
    {
        return KnowledgeSource::Talent {
            trait_definition_id: *definition_id,
        };
    }

    if let (Some(class_id), Some(class_spells)) = (context.class_id, &context.class_spell_ids) {
        if class_spells.contains(&spell_id) {
            return KnowledgeSource::Class { class_id };
        }
    }

    context
        .spec_id
        .map_or(KnowledgeSource::Unknown, |spec_id| KnowledgeSource::Spec {
            spec_id,
        })
}

#[cfg(feature = "dbc")]
const fn determine_refresh_behavior(flags: &AuraFlags, tick_period_ms: i32) -> RefreshBehavior {
    if flags.pandemic_refresh {
        RefreshBehavior::Pandemic
    } else if tick_period_ms > 0 {
        RefreshBehavior::Tick
    } else {
        RefreshBehavior::Duration
    }
}

/// Optional class- and spec-scoped knowledge used to enrich a spell with class/spec/talent linkage during transformation.
#[derive(Debug)]
pub struct SpellKnowledgeContext {
    pub class_id: Option<i32>,
    pub class_spell_ids: Option<wowlab_types::sim::FastSet<i32>>,
    pub spec_id: Option<i32>,
    pub talent_spell_id_to_trait_definition_id: Option<wowlab_types::sim::IntMap<i32, i32>>,
}

/// Build a fully-resolved `SpellDataFlat` for `spell_id` by joining 20+ DBC tables and applying optional class/spec context.
///
/// # Errors
///
/// Returns [`TransformError`] when `spell_id` is absent from the DBC data.
#[cfg(feature = "dbc")]
// #t(rust_max_fn_lines) spell transform gathers 20+ DBC tables into a single flat struct sequentially
pub fn transform_spell(
    dbc: &DbcData,
    spell_id: i32,
    context: Option<&SpellKnowledgeContext>,
) -> Result<SpellDataFlat, TransformError> {
    let name_row = dbc
        .spell_name
        .get(&spell_id)
        .ok_or_else(|| TransformError::spell_not_found(spell_id))?;

    let spell_row = dbc.spell.get(&spell_id);
    let misc = dbc.spell_misc.get(&spell_id);
    let effects = dbc
        .spell_effect
        .get(&spell_id)
        .map_or(&[] as &[SpellEffectRow], Vec::as_slice);
    let categories = dbc.spell_categories.get(&spell_id).and_then(|rows| {
        rows.iter()
            .find(|row| {
                wowlab_engine_domain::dbc::DifficultyId::try_from(row.DifficultyID).ok()
                    == Some(wowlab_engine_domain::dbc::DifficultyId::Base)
            })
            .or_else(|| rows.first())
    });

    let attributes: Vec<i32> = misc
        .map(super::super::dbc::rows::spell::SpellMiscRow::attributes_vec)
        .unwrap_or_default();

    let (range_min_0, range_min_1, range_max_0, range_max_1) = misc
        .and_then(|m| dbc.spell_range.get(&m.RangeIndex))
        .map_or((0.0, 0.0, 0.0, 0.0), |r| {
            (r.RangeMin_0, r.RangeMin_1, r.RangeMax_0, r.RangeMax_1)
        });

    let (radius_min, radius_max) = effects
        .iter()
        .find_map(|effect| effect_radius(dbc, effect))
        .unwrap_or((0.0, 0.0));

    let cooldown = dbc.spell_cooldowns.get(&spell_id).and_then(|rows| {
        rows.iter()
            .find(|row| {
                wowlab_engine_domain::dbc::DifficultyId::try_from(row.DifficultyID).ok()
                    == Some(wowlab_engine_domain::dbc::DifficultyId::Base)
            })
            .or_else(|| rows.first())
    });
    let recovery_time = cooldown.map_or(0, |c| c.RecoveryTime);
    let category_recovery_time = cooldown.map_or(0, |c| c.CategoryRecoveryTime);
    let start_recovery_time = cooldown.map_or(DEFAULT_GCD_MS_I32, |c| c.StartRecoveryTime);
    let start_recovery_category = categories.map_or(0, |c| c.StartRecoveryCategory);

    let cast_time = misc
        .and_then(|m| dbc.spell_cast_times.get(&m.CastingTimeIndex))
        .map_or(0, |ct| ct.Base);

    let (duration, max_duration) = misc
        .and_then(|m| dbc.spell_duration.get(&m.DurationIndex))
        .map_or((0, 0), |d| (d.Duration, d.MaxDuration));

    let charge_category = categories
        .filter(|c| c.ChargeCategory > 0)
        .and_then(|c| dbc.spell_category.get(&c.ChargeCategory));
    let (max_charges, charge_recovery_time) =
        charge_category.map_or((0, 0), |cat| (cat.MaxCharges, cat.ChargeRecoveryTime));

    let power_costs: Vec<PowerCostEntry> = dbc
        .spell_power
        .get(&spell_id)
        .map(|powers| {
            powers
                .iter()
                .map(|p| PowerCostEntry {
                    power_type: p.PowerType,
                    cost: p.ManaCost,
                    cost_pct: p.PowerCostPct,
                    max_cost_pct: f64::from(p.PowerCostMaxPct),
                    optional_cost: p.OptionalCost,
                    optional_cost_pct: f64::from(p.OptionalCostPct),
                    required_aura_spell_id: p.RequiredAuraSpellID,
                })
                .collect()
        })
        .unwrap_or_default();

    let mana_cost = effects
        .iter()
        .find(|e| {
            spell_effect_is(e.Effect, SpellEffectKind::PowerDrain) && e.EffectMiscValue_0 == 0
        })
        .map_or(0, |e| {
            wowlab_types::numeric::f64_to_i32_saturating_round(e.EffectBasePointsF.abs())
        });

    let class_options = dbc.spell_class_options.get(&spell_id);
    let spell_class_set = class_options.map_or(0, |c| c.SpellClassSet);
    let spell_class_mask_1 = class_options.map_or(0, |c| c.SpellClassMask_0);
    let spell_class_mask_2 = class_options.map_or(0, |c| c.SpellClassMask_1);
    let spell_class_mask_3 = class_options.map_or(0, |c| c.SpellClassMask_2);
    let spell_class_mask_4 = class_options.map_or(0, |c| c.SpellClassMask_3);

    let target_restrictions = dbc.spell_target_restrictions.get(&spell_id);
    let cone_degrees = target_restrictions.map_or(0.0, |t| t.ConeDegrees);
    let target_flags = target_restrictions.map_or(0, |t| t.Targets);
    let max_targets = target_restrictions.map_or(0, |t| t.MaxTargets);

    let aura = dbc.spell_aura_restrictions.get(&spell_id);
    let caster_aura_spell = aura.map_or(0, |a| a.CasterAuraSpell);
    let caster_aura_state = aura.map_or(0, |a| a.CasterAuraState);
    let exclude_caster_aura_spell = aura.map_or(0, |a| a.ExcludeCasterAuraSpell);
    let exclude_caster_aura_state = aura.map_or(0, |a| a.ExcludeCasterAuraState);
    let exclude_target_aura_spell = aura.map_or(0, |a| a.ExcludeTargetAuraSpell);
    let exclude_target_aura_state = aura.map_or(0, |a| a.ExcludeTargetAuraState);
    let target_aura_spell = aura.map_or(0, |a| a.TargetAuraSpell);
    let target_aura_state = aura.map_or(0, |a| a.TargetAuraState);

    let levels = dbc
        .spell_levels
        .get(&spell_id)
        .and_then(|lvls| lvls.first());
    let base_level = levels.map_or(0, |l| l.BaseLevel);
    let max_level = levels.map_or(0, |l| l.MaxLevel);
    let spell_level = levels.map_or(0, |l| l.SpellLevel);
    let max_passive_aura_level = levels.map_or(0, |l| l.MaxPassiveAuraLevel);

    let learn_spells: Vec<LearnSpell> = dbc
        .spell_learn_spell
        .get(&spell_id)
        .map(|v| {
            v.iter()
                .map(|ls| LearnSpell {
                    learn_spell_id: ls.LearnSpellID,
                    overrides_spell_id: ls.OverridesSpellID,
                })
                .collect()
        })
        .unwrap_or_default();

    let replacement_spell_id = dbc
        .spell_replacement
        .get(&spell_id)
        .map_or(0, |r| r.ReplacementSpellID);

    let shapeshift = dbc.spell_shapeshift.get(&spell_id);
    let shapeshift_exclude_0 = shapeshift.map_or(0, |s| s.ShapeshiftExclude_0);
    let shapeshift_exclude_1 = shapeshift.map_or(0, |s| s.ShapeshiftExclude_1);
    let shapeshift_mask_0 = shapeshift.map_or(0, |s| s.ShapeshiftMask_0);
    let shapeshift_mask_1 = shapeshift.map_or(0, |s| s.ShapeshiftMask_1);
    let stance_bar_order = shapeshift.map_or(0, |s| s.StanceBarOrder);

    let totems = dbc.spell_totems.get(&spell_id).and_then(|t| t.first());
    let totem_0 = totems.map_or(0, |t| t.Totem_0);
    let totem_1 = totems.map_or(0, |t| t.Totem_1);
    let required_totem_category_0 = totems.map_or(0, |t| t.RequiredTotemCategoryID_0);
    let required_totem_category_1 = totems.map_or(0, |t| t.RequiredTotemCategoryID_1);

    let (can_empower, empower_stages) =
        dbc.spell_empower
            .get(&spell_id)
            .map_or((false, Vec::new()), |empower| {
                let stages: Vec<EmpowerStage> = dbc
                    .spell_empower_stage
                    .get(&empower.ID)
                    .map(|stages| {
                        let mut sorted: Vec<_> = stages
                            .iter()
                            .map(|s| EmpowerStage {
                                stage: s.Stage,
                                duration_ms: s.DurationMs,
                            })
                            .collect();

                        sorted.sort_by_key(|s| s.stage);

                        sorted
                    })
                    .unwrap_or_default();

                (true, stages)
            });

    let spell_scaling = dbc.spell_scaling.get(&spell_id);
    let min_scaling_level = spell_scaling.map_or(0, |s| s.MinScalingLevel);
    let max_scaling_level = spell_scaling.map_or(0, |s| s.MaxScalingLevel);

    let (effect_bonus_coefficient, bonus_coefficient_from_ap) = effects
        .iter()
        .find(|e| {
            spell_effect_is_any(
                e.Effect,
                &[SpellEffectKind::SchoolDamage, SpellEffectKind::Heal],
            )
        })
        .map_or((0.0, 0.0), |e| {
            (e.EffectBonusCoefficient, e.BonusCoefficientFromAP)
        });

    let effect_trigger_spell: Vec<i32> = effects
        .iter()
        .map(|e| e.EffectTriggerSpell)
        .filter(|&t| t != 0)
        .collect();

    let implicit_target: Vec<i32> = effects
        .iter()
        .flat_map(|e| [e.ImplicitTarget_0, e.ImplicitTarget_1])
        .filter(|&t| t != 0)
        .collect();

    let equipped_item_requirement = dbc.spell_equipped_items.get(&spell_id).map(|row| {
        wowlab_types::data::EquippedItemRequirement {
            item_class: row.EquippedItemClass,
            inventory_type_mask: row.EquippedItemInvTypes,
            subclass_mask: row.EquippedItemSubclass,
        }
    });

    let interrupts = dbc.spell_interrupts.get(&spell_id);
    let interrupt_flags = interrupts.map_or(0, |i| i.InterruptFlags);
    let interrupt_aura_0 = interrupts.map_or(0, |i| i.AuraInterruptFlags_0);
    let interrupt_aura_1 = interrupts.map_or(0, |i| i.AuraInterruptFlags_1);
    let interrupt_channel_0 = interrupts.map_or(0, |i| i.ChannelInterruptFlags_0);
    let interrupt_channel_1 = interrupts.map_or(0, |i| i.ChannelInterruptFlags_1);

    let description_variables_row = dbc
        .spell_x_description_variables
        .get(&spell_id)
        .and_then(|xvars| xvars.first())
        .and_then(|xvar| {
            dbc.spell_description_variables
                .get(&xvar.SpellDescriptionVariablesID)
        });
    let description_variables = description_variables_row
        .map(|dv| dv.Variables.clone())
        .unwrap_or_default();

    let icon_file_data_id = misc.map_or(0, |m| m.SpellIconFileDataID);
    let file_name = super::resolve_icon_file_name(dbc, icon_file_data_id);

    // DBC Passive attribute is authoritative; an instant+apply-aura heuristic mislabels instant self-buffs.
    let is_passive = spell_attribute_is(&attributes, SpellAttributeKind::Passive);

    let spell_effects: Vec<SpellEffect> = effects
        .iter()
        .map(|e| {
            let (radius_min, radius_max) = effect_radius(dbc, e).unwrap_or((0.0, 0.0));

            SpellEffect {
                index: e.EffectIndex,
                effect: e.Effect,
                mechanic: e.EffectMechanic,
                effect_attributes: e.EffectAttributes,
                aura: e.EffectAura,
                base_points: e.EffectBasePointsF,
                period: e.EffectAuraPeriod,
                chain_targets: e.EffectChainTargets,
                chain_multiplier: f64::from(e.EffectChainAmplitude),
                trigger_spell: e.EffectTriggerSpell,
                misc_value_0: e.EffectMiscValue_0,
                misc_value_1: e.EffectMiscValue_1,
                shapeshift_form_flags: dbc
                    .spell_shapeshift_form
                    .get(&e.EffectMiscValue_0)
                    .map_or(0, |form| form.Flags),
                shapeshift_combat_round_time_ms: dbc
                    .spell_shapeshift_form
                    .get(&e.EffectMiscValue_0)
                    .map_or(0, |form| form.CombatRoundTime),
                radius_min,
                radius_max,
                coefficient: e.Coefficient,
                scaling_class: e.ScalingClass,
                points_per_resource: e.EffectPointsPerResource,
                variance: e.Variance,
                bonus_coefficient: e.EffectBonusCoefficient,
                bonus_coefficient_from_ap: e.BonusCoefficientFromAP,
                amplitude: e.EffectAmplitude,
                pvp_multiplier: e.PvpMultiplier,
                effect_class_mask_1: e.EffectSpellClassMask_0,
                effect_class_mask_2: e.EffectSpellClassMask_1,
                effect_class_mask_3: e.EffectSpellClassMask_2,
                effect_class_mask_4: e.EffectSpellClassMask_3,
                implicit_target_a: e.ImplicitTarget_0,
                implicit_target_b: e.ImplicitTarget_1,
            }
        })
        .collect();

    let aura_options = dbc.spell_aura_options.get(&spell_id);
    let aura_max_stacks = aura_options.map_or(1, |ao| ao.CumulativeAura).max(1);
    let proc_charges = aura_options.map_or(0, |ao| ao.ProcCharges);
    let proc_chance = aura_options.map_or(0, |ao| ao.ProcChance);
    let proc_type_mask = aura_options.map_or(0, |ao| {
        let mask = u64::from(u32::from_ne_bytes(ao.ProcTypeMask_0.to_ne_bytes()))
            | (u64::from(u32::from_ne_bytes(ao.ProcTypeMask_1.to_ne_bytes())) << u32::BITS);

        i64::try_from(mask).unwrap_or_default()
    });
    let proc_category_recovery_ms = aura_options.map_or(0, |ao| ao.ProcCategoryRecovery);
    let periodic_info = extract_periodic_info(dbc, spell_id);
    let aura_flags = extract_aura_flags(&attributes);
    let refresh_behavior = determine_refresh_behavior(&aura_flags, periodic_info.tick_period_ms);

    let (rppm_base_rate, rppm_flags, rppm_mods) = aura_options
        .filter(|ao| ao.SpellProcsPerMinuteID > 0)
        .and_then(|ao| {
            dbc.spell_procs_per_minute
                .get(&ao.SpellProcsPerMinuteID)
                .map(|ppm| {
                    let mods: Vec<RppmMod> = dbc
                        .spell_procs_per_minute_mod
                        .get(&ao.SpellProcsPerMinuteID)
                        .map(|mods| {
                            mods.iter()
                                .map(|m| RppmMod {
                                    mod_type: m.Type,
                                    param: m.Param,
                                    coeff: m.Coeff,
                                })
                                .collect()
                        })
                        .unwrap_or_default();

                    (ppm.BaseProcRate, ppm.Flags, mods)
                })
        })
        .unwrap_or((0.0, 0, Vec::new()));

    let knowledge_source = knowledge_source(spell_id, context);

    Ok(SpellDataFlat {
        id: spell_id,
        name: name_row.Name_lang.clone().unwrap_or_default().into(),
        description: spell_row
            .and_then(|s| s.Description_lang.clone())
            .unwrap_or_default(),
        aura_description: spell_row
            .and_then(|s| s.AuraDescription_lang.clone())
            .unwrap_or_default(),
        description_variables,
        file_name: file_name.into(),
        is_passive,
        proc_chance,
        proc_type_mask,
        proc_category_recovery_ms,
        knowledge_source,
        cast_time,
        recovery_time,
        category_recovery_time,
        category_id: categories.map_or(0, |c| c.Category),
        charge_category_id: categories.map_or(0, |c| c.ChargeCategory),
        start_recovery_category,
        start_recovery_time,
        mana_cost,
        power_costs,
        charge_recovery_time,
        max_charges,
        range_max_0,
        range_max_1,
        range_min_0,
        range_min_1,
        cone_degrees,
        target_flags,
        max_targets,
        radius_max,
        radius_min,
        defense_type: categories.map_or(0, |c| c.DefenseType),
        school_mask: misc.map_or(0, |m| m.SchoolMask),
        bonus_coefficient_from_ap,
        effect_bonus_coefficient,
        min_scaling_level,
        max_scaling_level,
        interrupt_aura_0,
        interrupt_aura_1,
        interrupt_channel_0,
        interrupt_channel_1,
        interrupt_flags,
        duration,
        max_duration,
        can_empower,
        empower_stages,
        dispel_type: categories.map_or(0, |c| c.DispelType),
        mechanic: categories.map_or(0, |c| c.Mechanic),
        facing_caster_flags: 0,
        speed: misc.map_or(0.0, |m| m.Speed),
        launch_delay: misc.map_or(0.0, |m| m.LaunchDelay),
        spell_class_mask_1,
        spell_class_mask_2,
        spell_class_mask_3,
        spell_class_mask_4,
        spell_class_set,
        base_level,
        max_level,
        max_passive_aura_level,
        spell_level,
        caster_aura_spell,
        caster_aura_state,
        exclude_caster_aura_spell,
        exclude_caster_aura_state,
        exclude_target_aura_spell,
        exclude_target_aura_state,
        target_aura_spell,
        target_aura_state,
        replacement_spell_id,
        shapeshift_exclude_0,
        shapeshift_exclude_1,
        shapeshift_mask_0,
        shapeshift_mask_1,
        stance_bar_order,
        required_totem_category_0,
        required_totem_category_1,
        totem_0,
        totem_1,
        attributes,
        equipped_item_requirement,
        effect_trigger_spell,
        implicit_target,
        learn_spells,
        effects: spell_effects,
        proc_charges,
        max_stacks: aura_max_stacks,
        periodic_type: periodic_info.periodic_type,
        tick_period_ms: periodic_info.tick_period_ms,
        refresh_behavior,
        duration_hasted: aura_flags.duration_hasted,
        hasted_ticks: aura_flags.hasted_ticks,
        pandemic_refresh: aura_flags.pandemic_refresh,
        rolling_periodic: aura_flags.rolling_periodic,
        tick_may_crit: aura_flags.tick_may_crit,
        tick_on_application: aura_flags.tick_on_application,
        rppm_base_rate,
        rppm_flags,
        rppm_mods,
        labels: dbc
            .spell_label
            .get(&spell_id)
            .map(|rows| rows.iter().map(|r| SpellLabel::from(r.LabelID)).collect())
            .unwrap_or_default(),
    })
}

#[cfg(all(test, feature = "dbc"))]
#[path = "spell/tests.rs"]
mod tests;