wowlab_engine_combat/builder/spell_builder/

from_data.rs

use wowlab_engine_domain::{constants::OFF_HAND_DAMAGE_MULT, dbc::EffectLookup};
use wowlab_engine_gamedata::ResolvedGameData;
use wowlab_types::{constants::HUNDRED, sim::EffectRef};

use super::SpellDefinitionDraft;
use crate::{
    DamageFlags,
    builder::{
        BuilderError,
        def::{BuilderDamageDef, BuilderSpellEffect},
    },
    systems::damage_flags_from_data,
};

fn damage_geometry_effect(lookup: EffectLookup<'_>) -> EffectRef {
    let effect_type = lookup.effect_type();

    if wowlab_engine_domain::dbc::spell_effect_is_any(
        effect_type,
        &[
            wowlab_engine_domain::dbc::SpellEffectKind::TriggerMissile,
            wowlab_engine_domain::dbc::SpellEffectKind::TriggerSpell,
            wowlab_engine_domain::dbc::SpellEffectKind::TriggerSpellWithValue,
            wowlab_engine_domain::dbc::SpellEffectKind::TriggerSpell2,
        ],
    ) && let Ok(triggered) = wowlab_engine_domain::dbc::resolve_triggered_damage(lookup)
    {
        return EffectRef::new(triggered.spell_id, triggered.damage.effect_index);
    }

    lookup.effect
}

fn append_interrupt_effect(
    spell: &mut SpellDefinitionDraft,
    data: &ResolvedGameData,
    spell_id: wowlab_types::sim::SpellIdx,
    effect_type: i32,
) {
    if wowlab_engine_domain::dbc::spell_effect_is(
        effect_type,
        wowlab_engine_domain::dbc::SpellEffectKind::InterruptCast,
    ) {
        spell
            .followup_effects
            .push(BuilderSpellEffect::InterruptCast {
                lockout_ms: data.aura_duration_ms(spell_id).unwrap_or_default(),
            });
    }
}

fn append_dispel_effect(
    spell: &mut SpellDefinitionDraft,
    lookup: EffectLookup<'_>,
    effect_type: i32,
) {
    let steal = wowlab_engine_domain::dbc::spell_effect_is(
        effect_type,
        wowlab_engine_domain::dbc::SpellEffectKind::StealBeneficialBuff,
    );

    if steal
        || wowlab_engine_domain::dbc::spell_effect_is(
            effect_type,
            wowlab_engine_domain::dbc::SpellEffectKind::Dispel,
        )
    {
        spell.followup_effects.push(BuilderSpellEffect::Dispel {
            dispel_type: lookup.effect_misc_value_0(),
            steal,
        });
    }
}

#[derive(Clone, Copy, Debug, Default)]
struct DamageEquipmentRequirements {
    main_hand: bool,
    off_hand: bool,
    equipped_item: Option<wowlab_types::data::EquippedItemRequirement>,
}

#[expect(
    clippy::struct_excessive_bools,
    reason = "resolved spell behavior mirrors independent DBC flags"
)]
struct ResolvedSpellBehavior {
    cooldown_hasted: bool,
    gcd_haste_type: wowlab_types::combat::GcdHasteType,
    hasted_ticks: bool,
    duration_hasted: bool,
    cannot_crit: bool,
    requires_unshifted: bool,
    allow_while_unshifted: bool,
    requires_stealth: bool,
    requires_behind_target: bool,
    treat_as_area_effect: bool,
    shapeshift_required_mask: u64,
    shapeshift_excluded_mask: u64,
    requires_main_hand: bool,
    requires_off_hand: bool,
    equipped_item_requirement: Option<wowlab_types::data::EquippedItemRequirement>,
    breaks_stealth: bool,
    usable_while_casting: bool,
    usable_while_moving: bool,
    explicit_target_mask: u32,
    required_explicit_target_mask: u32,
}

#[expect(
    clippy::struct_excessive_bools,
    reason = "resolved timing behavior mirrors independent DBC flags"
)]
struct ResolvedTimingBehavior {
    cooldown_hasted: bool,
    gcd_haste_type: wowlab_types::combat::GcdHasteType,
    hasted_ticks: bool,
    duration_hasted: bool,
    cannot_crit: bool,
    breaks_stealth: bool,
    usable_while_casting: bool,
    usable_while_moving: bool,
}

#[expect(
    clippy::struct_excessive_bools,
    reason = "resolved targeting behavior mirrors independent DBC flags"
)]
struct ResolvedTargetBehavior {
    requires_unshifted: bool,
    allow_while_unshifted: bool,
    requires_stealth: bool,
    requires_behind_target: bool,
    treat_as_area_effect: bool,
    shapeshift_required_mask: u64,
    shapeshift_excluded_mask: u64,
    requires_main_hand: bool,
    requires_off_hand: bool,
    equipped_item_requirement: Option<wowlab_types::data::EquippedItemRequirement>,
    explicit_target_mask: u32,
    required_explicit_target_mask: u32,
}

fn resolve_timing_behavior(
    data: &ResolvedGameData,
    spell_id: u32,
) -> Result<ResolvedTimingBehavior, BuilderError> {
    let idx = wowlab_types::sim::SpellIdx::from_raw(spell_id);
    let missing = |field| crate::builder::BuilderErrorKind::MissingSpellData { spell_id, field };

    Ok(ResolvedTimingBehavior {
        cooldown_hasted: data
            .cooldown_hasted(idx)
            .ok_or_else(|| missing("cooldown_hasted"))?,
        gcd_haste_type: data
            .gcd_haste_type(idx)
            .ok_or_else(|| missing("gcd_haste_type"))?,
        hasted_ticks: data
            .hasted_ticks(idx)
            .ok_or_else(|| missing("hasted_ticks"))?,
        duration_hasted: data
            .duration_hasted(idx)
            .ok_or_else(|| missing("duration_hasted"))?,
        cannot_crit: data
            .cannot_crit(idx)
            .ok_or_else(|| missing("cannot_crit"))?,
        breaks_stealth: data
            .breaks_stealth(idx)
            .ok_or_else(|| missing("breaks_stealth"))?,
        usable_while_casting: data
            .usable_while_casting(idx)
            .ok_or_else(|| missing("usable_while_casting"))?,
        usable_while_moving: data
            .usable_while_moving(idx)
            .ok_or_else(|| missing("usable_while_moving"))?,
    })
}

fn resolve_target_behavior(
    data: &ResolvedGameData,
    spell_id: u32,
) -> Result<ResolvedTargetBehavior, BuilderError> {
    let idx = wowlab_types::sim::SpellIdx::from_raw(spell_id);
    let missing = |field| crate::builder::BuilderErrorKind::MissingSpellData { spell_id, field };

    Ok(ResolvedTargetBehavior {
        requires_unshifted: data
            .requires_unshifted(idx)
            .ok_or_else(|| missing("requires_unshifted"))?,
        allow_while_unshifted: data
            .allow_while_unshifted(idx)
            .ok_or_else(|| missing("allow_while_unshifted"))?,
        requires_stealth: data
            .requires_stealth(idx)
            .ok_or_else(|| missing("requires_stealth"))?,
        requires_behind_target: data
            .requires_behind_target(idx)
            .ok_or_else(|| missing("requires_behind_target"))?,
        treat_as_area_effect: data
            .treat_as_area_effect(idx)
            .ok_or_else(|| missing("treat_as_area_effect"))?,
        shapeshift_required_mask: data
            .shapeshift_required_mask(idx)
            .ok_or_else(|| missing("shapeshift_required_mask"))?,
        shapeshift_excluded_mask: data
            .shapeshift_excluded_mask(idx)
            .ok_or_else(|| missing("shapeshift_excluded_mask"))?,
        requires_main_hand: data
            .requires_main_hand(idx)
            .ok_or_else(|| missing("requires_main_hand"))?,
        requires_off_hand: data
            .requires_off_hand(idx)
            .ok_or_else(|| missing("requires_off_hand"))?,
        equipped_item_requirement: data.equipped_item_requirement(idx),
        explicit_target_mask: data
            .explicit_target_mask(idx)
            .ok_or_else(|| missing("explicit_target_mask"))?,
        required_explicit_target_mask: data
            .required_explicit_target_mask(idx)
            .ok_or_else(|| missing("required_explicit_target_mask"))?,
    })
}

fn resolve_spell_behavior(
    data: &ResolvedGameData,
    spell_id: u32,
) -> Result<ResolvedSpellBehavior, BuilderError> {
    let timing = resolve_timing_behavior(data, spell_id)?;
    let target = resolve_target_behavior(data, spell_id)?;

    Ok(ResolvedSpellBehavior {
        cooldown_hasted: timing.cooldown_hasted,
        gcd_haste_type: timing.gcd_haste_type,
        hasted_ticks: timing.hasted_ticks,
        duration_hasted: timing.duration_hasted,
        cannot_crit: timing.cannot_crit,
        requires_unshifted: target.requires_unshifted,
        allow_while_unshifted: target.allow_while_unshifted,
        requires_stealth: target.requires_stealth,
        requires_behind_target: target.requires_behind_target,
        treat_as_area_effect: target.treat_as_area_effect,
        shapeshift_required_mask: target.shapeshift_required_mask,
        shapeshift_excluded_mask: target.shapeshift_excluded_mask,
        requires_main_hand: target.requires_main_hand,
        requires_off_hand: target.requires_off_hand,
        equipped_item_requirement: target.equipped_item_requirement,
        breaks_stealth: timing.breaks_stealth,
        usable_while_casting: timing.usable_while_casting,
        usable_while_moving: timing.usable_while_moving,
        explicit_target_mask: target.explicit_target_mask,
        required_explicit_target_mask: target.required_explicit_target_mask,
    })
}

#[expect(
    clippy::missing_errors_doc,
    reason = "DBC-backed fluent methods uniformly return BuilderError when required spell data is absent or invalid"
)]
impl SpellDefinitionDraft {
    pub fn additional_damage_ap_from_data(
        self,
        lookup: EffectLookup<'_>,
        multiplier: f64,
    ) -> Result<Self, BuilderError> {
        self.additional_damage_ap_from_data_typed(
            lookup,
            multiplier,
            crate::state::WeaponApType::MainHand,
        )
    }

    pub fn additional_damage_ap_from_data_typed(
        self,
        lookup: EffectLookup<'_>,
        multiplier: f64,
        ap_type: crate::state::WeaponApType,
    ) -> Result<Self, BuilderError> {
        let data = lookup.data;
        let idx = lookup.effect.spell;
        let spell_id = idx.as_u32();
        let effect_index = lookup.effect.effect_index;
        let is_physical = wowlab_engine_domain::dbc::is_physical(data, idx).ok_or(
            crate::builder::BuilderErrorKind::MissingSpellData {
                spell_id,
                field: "is_physical",
            },
        )?;

        Ok(self.additional_damage(
            crate::state::DamageEffectRef::new(spell_id, effect_index),
            BuilderDamageDef::ApCoefficient {
                coef: data.ap_coef(idx, effect_index) * multiplier,
                is_physical,
                ap_type,
            },
            data.base_points(idx, effect_index),
            !data.cannot_crit(idx).unwrap_or(false),
            damage_flags_from_data(data, idx, is_physical),
            DamageEquipmentRequirements::default(),
        ))
    }

    pub fn additional_damage_sp_from_data(
        self,
        lookup: EffectLookup<'_>,
        multiplier: f64,
    ) -> Result<Self, BuilderError> {
        let data = lookup.data;
        let idx = lookup.effect.spell;
        let spell_id = idx.as_u32();
        let effect_index = lookup.effect.effect_index;
        let is_physical = wowlab_engine_domain::dbc::is_physical(data, idx).ok_or(
            crate::builder::BuilderErrorKind::MissingSpellData {
                spell_id,
                field: "is_physical",
            },
        )?;

        Ok(self.additional_damage(
            crate::state::DamageEffectRef::new(spell_id, effect_index),
            BuilderDamageDef::SpCoefficient {
                coef: data.sp_coef(idx, effect_index) * multiplier,
                is_physical,
            },
            data.base_points(idx, effect_index),
            !data.cannot_crit(idx).unwrap_or(false),
            damage_flags_from_data(data, idx, is_physical),
            DamageEquipmentRequirements::default(),
        ))
    }

    /// Append the terminal child damage reached through an exact DBC trigger edge.
    pub fn triggered_damage_from_data(
        self,
        lookup: EffectLookup<'_>,
        multiplier: f64,
    ) -> Result<Self, BuilderError> {
        let data = lookup.data;
        let triggered = wowlab_engine_domain::dbc::resolve_triggered_damage(lookup)?;
        let may_crit = !data.cannot_crit(triggered.spell_id).unwrap_or(false);
        let attribute_flags =
            damage_flags_from_data(data, triggered.spell_id, triggered.damage.is_physical);

        self.additional_triggered_damage(triggered, multiplier, may_crit, attribute_flags)
    }

    /// Applies every DBC cooldown component without collapsing their independent pools.
    pub fn apply_cooldown_pools_from_data(
        self,
        data: &ResolvedGameData,
        spell_id: u32,
    ) -> Result<Self, BuilderError> {
        let idx = wowlab_types::sim::SpellIdx::from_raw(spell_id);
        let missing =
            |field| crate::builder::BuilderErrorKind::MissingSpellData { spell_id, field };
        let cooldown_s = data.cooldown_s(idx).ok_or_else(|| missing("cooldown_s"))?;
        let charges = data.charges(idx).ok_or_else(|| missing("charges"))?;
        let charge_cd_s = data
            .charge_cd_s(idx)
            .ok_or_else(|| missing("charge_cd_s"))?;
        let category_cooldown_s = data
            .category_cooldown_s(idx)
            .ok_or_else(|| missing("category_cooldown_s"))?;

        let mut spell = self
            .cooldown(cooldown_s)
            .charges(charges, charge_cd_s)
            .cooldown_categories(
                data.cooldown_category(idx),
                category_cooldown_s,
                data.charge_category(idx),
            )
            .start_recovery_category(data.start_recovery_category(idx));

        if data.is_empower_spell(idx) {
            spell = spell.apply_empower_from_data(data, spell_id)?;
        }

        Ok(spell)
    }

    /// Apply the standard data-driven field set for `spell_id`, erroring on any missing required field.
    // #t(fn: rust_cyclomatic_complexity) base construction composes independent DBC timing, targeting, resource, damage, and healing semantics
    // #t(fn: rust_max_fn_lines) the ordered base-property lowering remains auditable as one DBC-to-runtime transaction
    pub fn apply_base_from_data(
        self,
        data: &ResolvedGameData,
        spell_id: u32,
    ) -> Result<Self, BuilderError> {
        let idx = wowlab_types::sim::SpellIdx::from_raw(spell_id);
        let missing =
            |field| crate::builder::BuilderErrorKind::MissingSpellData { spell_id, field };

        let cast_time_ms = data
            .cast_time_ms(idx)
            .ok_or_else(|| missing("cast_time_ms"))?;
        let behavior = resolve_spell_behavior(data, spell_id)?;
        let gcd_ms = data.gcd_ms(idx).ok_or_else(|| missing("gcd_ms"))?;
        let resources = data
            .spell_resources(idx)
            .ok_or_else(|| missing("spell_resources"))?;
        let damage =
            wowlab_engine_domain::dbc::damage_def(data, idx).ok_or_else(|| missing("damage"))?;
        let geometry = damage_geometry_effect(EffectLookup::new(
            data,
            EffectRef::new(idx, damage.effect_index),
        ));
        let target_plan = wowlab_engine_domain::targeting::compile_target_plan(
            wowlab_engine_domain::targeting::TargetPlanInput {
                spell_id: geometry.spell.as_u32(),
                effect_index: geometry.effect_index,
                effect_type: data.effect_type(geometry.spell, geometry.effect_index),
                target_a: data.implicit_target_a(geometry.spell, geometry.effect_index),
                target_b: data.implicit_target_b(geometry.spell, geometry.effect_index),
            },
        )?;

        let mut spell = self
            .apply_cooldown_pools_from_data(data, spell_id)?
            .cost(resources.primary_cost)
            .optional_cost(resources.primary_optional_cost)
            .gcd(gcd_ms)
            .gain(resources.primary_gain)
            .secondary_cost(resources.secondary_cost)
            .secondary_optional_cost(resources.secondary_optional_cost)
            .secondary_gain(resources.secondary_gain)
            .damage_auto(damage)?
            .damage_effect(geometry.spell.as_u32(), geometry.effect_index);

        if !data.is_empower_spell(idx) {
            spell = spell.cast_time(cast_time_ms);
        }

        spell.cooldown_hasted = behavior.cooldown_hasted;
        spell.gcd_haste_type = behavior.gcd_haste_type;
        spell.damage_may_crit = !behavior.cannot_crit;
        spell.channel_tick_may_crit = !behavior.cannot_crit;
        spell.damage_attribute_flags = damage_flags_from_data(data, idx, damage.is_physical);
        spell.requires_unshifted = behavior.requires_unshifted;
        spell.allow_while_unshifted = behavior.allow_while_unshifted;
        spell.requires_stealth = behavior.requires_stealth;
        spell.requires_behind_target = behavior.requires_behind_target;
        spell.is_aoe |= behavior.treat_as_area_effect
            || wowlab_engine_domain::targeting::target_plan_is_multi_target(&target_plan);
        spell.shapeshift_required_mask = behavior.shapeshift_required_mask;
        spell.shapeshift_excluded_mask = behavior.shapeshift_excluded_mask;
        spell.caster_aura_spell = data.caster_aura_spell(idx).unwrap_or_default();
        spell.caster_aura_state = data
            .caster_aura_state(idx)
            .and_then(wowlab_engine_domain::dbc::AuraState::from_dbc);
        spell.exclude_caster_aura_spell = data.exclude_caster_aura_spell(idx).unwrap_or_default();
        spell.exclude_caster_aura_state = data
            .exclude_caster_aura_state(idx)
            .and_then(wowlab_engine_domain::dbc::AuraState::from_dbc);
        spell.target_aura_spell = data.target_aura_spell(idx).unwrap_or_default();
        spell.target_aura_state = data
            .target_aura_state(idx)
            .and_then(wowlab_engine_domain::dbc::AuraState::from_dbc);
        spell.exclude_target_aura_spell = data.exclude_target_aura_spell(idx).unwrap_or_default();
        spell.exclude_target_aura_state = data
            .exclude_target_aura_state(idx)
            .and_then(wowlab_engine_domain::dbc::AuraState::from_dbc);
        spell.requires_main_hand = behavior.requires_main_hand;
        spell.requires_off_hand = behavior.requires_off_hand;
        spell.equipped_item_requirement = behavior.equipped_item_requirement;
        spell.breaks_stealth = behavior.breaks_stealth;
        spell.usable_while_casting = behavior.usable_while_casting;
        spell.usable_while_moving = behavior.usable_while_moving;
        spell.explicit_target_mask = behavior.explicit_target_mask;
        spell.required_explicit_target_mask = behavior.required_explicit_target_mask;
        spell.resource_cost_pct = resources.primary_cost_pct;
        spell.maximum_resource_cost_pct = resources.primary_max_cost_pct;
        spell.optional_resource_cost_pct = resources.primary_optional_cost_pct;
        spell.health_cost = resources.health_cost;
        spell.health_cost_pct = resources.health_cost_pct;
        spell.health_max_cost_pct = resources.health_max_cost_pct;
        spell.health_optional_cost = resources.health_optional_cost;
        spell.health_optional_cost_pct = resources.health_optional_cost_pct;
        spell.channel_hasted_ticks = behavior.hasted_ticks;
        spell.channel_duration_hasted = behavior.duration_hasted;
        spell.channel_tick_interval_ms = data.aura_tick_ms(idx).unwrap_or_default();
        spell.channel_tick_zero = data.tick_on_application(idx).unwrap_or_default();
        spell.projectile_speed = data
            .projectile_speed(idx)
            .ok_or_else(|| missing("projectile_speed"))?;
        spell.launch_delay_s = data
            .launch_delay_s(idx)
            .ok_or_else(|| missing("launch_delay_s"))?;
        spell.dbc_fixed_travel_time = data
            .fixed_travel_time(idx)
            .ok_or_else(|| missing("fixed_travel_time"))?;

        let mut has_heal = false;
        let mut has_damage = false;

        for effect_index in 1..=data.max_effect_index(idx) {
            let effect_type = data.effect_type(idx, effect_index);

            has_damage |= wowlab_engine_domain::dbc::spell_effect_is_any(
                effect_type,
                &[
                    wowlab_engine_domain::dbc::SpellEffectKind::SchoolDamage,
                    wowlab_engine_domain::dbc::SpellEffectKind::HealthLeech,
                    wowlab_engine_domain::dbc::SpellEffectKind::WeaponDamageNoSchool,
                    wowlab_engine_domain::dbc::SpellEffectKind::WeaponPercentDamage,
                    wowlab_engine_domain::dbc::SpellEffectKind::WeaponDamage,
                    wowlab_engine_domain::dbc::SpellEffectKind::NormalizedWeaponDamage,
                ],
            );

            append_interrupt_effect(&mut spell, data, idx, effect_type);
            append_dispel_effect(
                &mut spell,
                EffectLookup::new(data, EffectRef::new(idx, effect_index)),
                effect_type,
            );

            if !wowlab_engine_domain::dbc::spell_effect_is_any(
                effect_type,
                &[
                    wowlab_engine_domain::dbc::SpellEffectKind::Heal,
                    wowlab_engine_domain::dbc::SpellEffectKind::HealMaxHealthPercent,
                    wowlab_engine_domain::dbc::SpellEffectKind::DirectHealPercent,
                ],
            ) {
                continue;
            }

            has_heal = true;
            let is_percent = wowlab_engine_domain::dbc::spell_effect_is_any(
                effect_type,
                &[
                    wowlab_engine_domain::dbc::SpellEffectKind::HealMaxHealthPercent,
                    wowlab_engine_domain::dbc::SpellEffectKind::DirectHealPercent,
                ],
            );

            spell.followup_effects.push(BuilderSpellEffect::Heal {
                effect: Some(crate::state::DamageEffectRef::new(spell_id, effect_index)),
                base: if is_percent {
                    0.0
                } else {
                    data.base_points(idx, effect_index).max(0.0)
                },
                ap_coef: if is_percent {
                    0.0
                } else {
                    data.ap_coef(idx, effect_index)
                },
                sp_coef: if is_percent {
                    0.0
                } else {
                    data.sp_coef(idx, effect_index)
                },
                percent_of_max: if is_percent {
                    data.base_points(idx, effect_index).max(0.0) / HUNDRED
                } else {
                    0.0
                },
                may_crit: !behavior.cannot_crit,
            });
        }

        if has_heal && !has_damage {
            spell = spell.without_data_damage();
        }

        Ok(spell)
    }

    /// Apply DBC chain targeting and its per-hop multiplier from the primary damage effect.
    pub fn apply_aoe_from_data(mut self, data: &ResolvedGameData) -> Self {
        let Some(effect) = self.damage_effect else {
            return self;
        };
        let idx = wowlab_types::sim::SpellIdx::from_raw(effect.spell_id);
        let geometry = damage_geometry_effect(EffectLookup::new(
            data,
            EffectRef::new(idx, effect.effect_index),
        ));
        let target_plan = wowlab_engine_domain::targeting::compile_target_plan(
            wowlab_engine_domain::targeting::TargetPlanInput {
                spell_id: geometry.spell.as_u32(),
                effect_index: geometry.effect_index,
                effect_type: data.effect_type(geometry.spell, geometry.effect_index),
                target_a: data.implicit_target_a(geometry.spell, geometry.effect_index),
                target_b: data.implicit_target_b(geometry.spell, geometry.effect_index),
            },
        );

        self.is_aoe |= data.treat_as_area_effect(idx).unwrap_or(false)
            || data.treat_as_area_effect(geometry.spell).unwrap_or(false)
            || target_plan
                .as_ref()
                .is_ok_and(wowlab_engine_domain::targeting::target_plan_is_multi_target);
        let max_targets = wowlab_types::numeric::i32_to_u8_saturating(
            data.chain_targets(geometry.spell, geometry.effect_index),
        );
        let chain_multiplier = data.chain_multiplier(geometry.spell, geometry.effect_index);

        self.chain_targets(max_targets)
            .chain_multiplier(chain_multiplier)
    }

    /// Set AP-coefficient damage, resolving coef + physical flag from data; errors if the school mask is missing on populated data.
    pub fn damage_ap_from_data(self, lookup: EffectLookup<'_>) -> Result<Self, BuilderError> {
        let data = lookup.data;
        let idx = lookup.effect.spell;
        let spell_id = idx.as_u32();
        let effect_index = lookup.effect.effect_index;
        let coef = lookup.ap_coef();
        let is_physical = wowlab_engine_domain::dbc::is_physical(data, idx).ok_or(
            crate::builder::BuilderErrorKind::MissingSpellData {
                spell_id,
                field: "is_physical",
            },
        )?;
        let flags = damage_flags_from_data(data, idx, is_physical);

        Ok(self
            .damage_ap(coef, flags)
            .damage_effect(spell_id, effect_index))
    }

    /// Like [`Self::damage_ap_from_data`] with an explicit weapon-AP composite.
    pub fn damage_ap_from_data_typed(
        self,
        lookup: EffectLookup<'_>,
        ap_type: crate::state::WeaponApType,
    ) -> Result<Self, BuilderError> {
        let data = lookup.data;
        let idx = lookup.effect.spell;
        let spell_id = idx.as_u32();
        let effect_index = lookup.effect.effect_index;
        let coef = lookup.ap_coef();
        let is_physical = wowlab_engine_domain::dbc::is_physical(data, idx).ok_or(
            crate::builder::BuilderErrorKind::MissingSpellData {
                spell_id,
                field: "is_physical",
            },
        )?;
        let flags = damage_flags_from_data(data, idx, is_physical);

        Ok(self
            .damage_ap_typed(coef, flags, ap_type)
            .damage_effect(spell_id, effect_index))
    }

    /// Set SP-coefficient damage, resolving coef + physical flag from data; errors if the school mask is missing on populated data.
    pub fn damage_sp_from_data(self, lookup: EffectLookup<'_>) -> Result<Self, BuilderError> {
        let data = lookup.data;
        let idx = lookup.effect.spell;
        let spell_id = idx.as_u32();
        let effect_index = lookup.effect.effect_index;
        let coef = lookup.sp_coef();
        let is_physical = wowlab_engine_domain::dbc::is_physical(data, idx).ok_or(
            crate::builder::BuilderErrorKind::MissingSpellData {
                spell_id,
                field: "is_physical",
            },
        )?;
        let flags = damage_flags_from_data(data, idx, is_physical);

        Ok(self
            .damage_sp(coef, flags)
            .damage_effect(spell_id, effect_index))
    }

    /// Set AP-coefficient channel-tick damage, resolving coef + physical flag from game data.
    pub fn channel_tick_damage_ap_from_data(
        self,
        lookup: EffectLookup<'_>,
    ) -> Result<Self, BuilderError> {
        let data = lookup.data;
        let idx = lookup.effect.spell;
        let spell_id = idx.as_u32();
        let coef = lookup.ap_coef();
        let is_physical = wowlab_engine_domain::dbc::is_physical(data, idx).ok_or(
            crate::builder::BuilderErrorKind::MissingSpellData {
                spell_id,
                field: "is_physical",
            },
        )?;
        let flags = damage_flags_from_data(data, idx, is_physical);

        Ok(self
            .channel_tick_damage_ap(coef, flags)
            .channel_tick_source(spell_id))
    }

    /// Set SP-coefficient channel-tick damage, resolving coef + physical flag from game data.
    pub fn channel_tick_damage_sp_from_data(
        self,
        lookup: EffectLookup<'_>,
    ) -> Result<Self, BuilderError> {
        let data = lookup.data;
        let idx = lookup.effect.spell;
        let spell_id = idx.as_u32();
        let coef = lookup.sp_coef();
        let is_physical = wowlab_engine_domain::dbc::is_physical(data, idx).ok_or(
            crate::builder::BuilderErrorKind::MissingSpellData {
                spell_id,
                field: "is_physical",
            },
        )?;
        let flags = damage_flags_from_data(data, idx, is_physical);

        Ok(self
            .channel_tick_damage_sp(coef, flags)
            .channel_tick_source(spell_id))
    }

    /// Set an aura-conditional AP channel-tick payload from game data.
    pub fn channel_tick_damage_alt_ap_from_data(
        self,
        lookup: EffectLookup<'_>,
        aura_id: u32,
    ) -> Result<Self, BuilderError> {
        let data = lookup.data;
        let idx = lookup.effect.spell;
        let spell_id = idx.as_u32();
        let coef = lookup.ap_coef();
        let is_physical = wowlab_engine_domain::dbc::is_physical(data, idx).ok_or(
            crate::builder::BuilderErrorKind::MissingSpellData {
                spell_id,
                field: "is_physical",
            },
        )?;

        Ok(self.channel_tick_damage_alt_ap(
            coef,
            damage_flags_from_data(data, idx, is_physical),
            spell_id,
            aura_id,
        ))
    }

    /// Set an aura-conditional SP channel-tick payload from game data.
    pub fn channel_tick_damage_alt_sp_from_data(
        self,
        lookup: EffectLookup<'_>,
        aura_id: u32,
    ) -> Result<Self, BuilderError> {
        let data = lookup.data;
        let idx = lookup.effect.spell;
        let spell_id = idx.as_u32();
        let coef = lookup.sp_coef();
        let is_physical = wowlab_engine_domain::dbc::is_physical(data, idx).ok_or(
            crate::builder::BuilderErrorKind::MissingSpellData {
                spell_id,
                field: "is_physical",
            },
        )?;

        Ok(self.channel_tick_damage_alt_sp(
            coef,
            damage_flags_from_data(data, idx, is_physical),
            spell_id,
            aura_id,
        ))
    }

    fn apply_empower_from_data(
        mut self,
        data: &ResolvedGameData,
        spell_id: u32,
    ) -> Result<Self, BuilderError> {
        let cast_times_ms =
            data.require_empower_cast_times_ms(wowlab_types::sim::SpellIdx::from_raw(spell_id))?;

        u8::try_from(cast_times_ms.len()).map_err(|source| {
            crate::builder::BuilderErrorKind::InvalidEmpowerRankCount {
                spell_id,
                rank_count: cast_times_ms.len(),
                source,
            }
        })?;

        self.cast_time_ms = cast_times_ms.first().copied().unwrap_or(0);
        self.empower_cast_times_ms = cast_times_ms;

        Ok(self)
    }

    fn additional_damage(
        mut self,
        effect: crate::state::DamageEffectRef,
        damage: BuilderDamageDef,
        base_points: f64,
        may_crit: bool,
        attribute_flags: DamageFlags,
        equipment: DamageEquipmentRequirements,
    ) -> Self {
        self.followup_effects.push(BuilderSpellEffect::Damage {
            effect,
            damage,
            base_points,
            may_crit,
            attribute_flags,
            requires_main_hand: equipment.main_hand,
            requires_off_hand: equipment.off_hand,
            equipped_item_requirement: equipment.equipped_item,
        });

        self
    }

    fn additional_triggered_damage(
        self,
        triggered: wowlab_engine_domain::dbc::TriggeredDamage,
        multiplier: f64,
        may_crit: bool,
        attribute_flags: DamageFlags,
    ) -> Result<Self, BuilderError> {
        if self.followup_effects.iter().any(|effect| {
            matches!(
                effect,
                BuilderSpellEffect::Damage { effect, .. }
                    if effect.spell_id == triggered.spell_id.as_u32()
                        && effect.effect_index == triggered.damage.effect_index
            )
        }) {
            return Ok(self);
        }

        let damage = BuilderDamageDef::from_resolved(triggered.damage, OFF_HAND_DAMAGE_MULT)
            .ok_or(crate::builder::BuilderErrorKind::UnsupportedDamageKind)?
            .scaled(multiplier);
        let base_points = crate::state::resolved_damage_base_points(triggered.damage, multiplier);

        Ok(self.additional_damage(
            crate::state::DamageEffectRef::new(
                triggered.spell_id.as_u32(),
                triggered.damage.effect_index,
            ),
            damage,
            base_points,
            may_crit,
            attribute_flags,
            DamageEquipmentRequirements {
                main_hand: triggered.requires_main_hand,
                off_hand: triggered.requires_off_hand,
                equipped_item: triggered.equipped_item_requirement,
            },
        ))
    }
}

#[cfg(test)]
#[path = "from_data/tests.rs"]
mod tests;