wowlab_engine_combat/builder/combat_builder/build/

overrides.rs

use super::*;

pub(super) struct ActionOverrideRegistration<'a> {
    pub(super) definition: &'a mut CombatSystemBuilder,
}

impl ActionOverrideRegistration<'_> {
    pub(super) fn apply_dbc_action_overrides(&mut self) {
        let mut registrations = Vec::with_capacity(self.definition.aura_defs.len());

        for aura in &self.definition.aura_defs {
            let aura_id = SpellIdx::from_raw(aura.aura_id);

            for effect_index in 1..=self.definition.game_data.max_effect_index(aura_id) {
                let Some(replacement) = self
                    .definition
                    .game_data
                    .override_action_spell(aura_id, effect_index)
                else {
                    continue;
                };

                let explicit_base = self
                    .definition
                    .game_data
                    .effect_misc_value_0(aura_id, effect_index);

                registrations.push((aura.aura_id, effect_index, replacement, explicit_base));
            }
        }

        for (aura_id, effect_index, replacement, explicit_base) in registrations {
            // Redirecting a base action onto a replacement the loadout never unlocked makes the
            // base action uncastable for the whole aura window.
            if self.is_unselected_talent_spell(replacement.as_u32()) {
                continue;
            }

            let base_spell_indices: Vec<usize> = self
                .definition
                .spells
                .iter()
                .enumerate()
                .filter_map(|(index, spell)| {
                    let directly_named = explicit_base > 0
                        && u32::try_from(explicit_base).ok() == Some(spell.spell_id);
                    let affect_listed = self.definition.game_data.effect_affects_spell(
                        SpellIdx::from_raw(aura_id),
                        effect_index,
                        SpellIdx::from_raw(spell.spell_id),
                    );

                    (directly_named || affect_listed).then_some(index)
                })
                .collect();

            let Some(&template_index) = base_spell_indices.first() else {
                continue;
            };

            self.ensure_replacement_spell(template_index, replacement);

            if self.definition.pending_error.is_some()
                || !self
                    .definition
                    .spells
                    .iter()
                    .any(|spell| spell.spell_id == replacement.as_u32())
            {
                continue;
            }

            let charges = self
                .definition
                .game_data
                .proc_charges(SpellIdx::from_raw(aura_id))
                .unwrap_or(0);
            // A charged override aura grants exactly one replacement cast and is the only gate on
            // it, so the replacement runs on its own recovery and the cast spends the charge. A
            // chargeless form/stance aura only re-skins the button for its whole duration, so the
            // base recovery governs and the aura survives the cast.
            let persistent_form = charges == 0;

            for index in base_spell_indices {
                // BOUNDS: every index was produced by enumerating definition.spells above.
                let spell = &mut self.definition.spells[index];

                if spell.override_aura_id == 0 {
                    spell.override_aura_id = aura_id;
                    spell.override_spell_id = replacement.as_u32();
                    spell.override_shares_base_cooldown = persistent_form;
                    spell.override_preserves_aura = persistent_form;
                }
            }
        }
    }

    /// Whether `spell_id` is a talent-gated spell the decoded loadout did not select.
    ///
    /// These are exactly the spells `populate_spell_slots` initializes with `is_enabled = 0`.
    fn is_unselected_talent_spell(&self, spell_id: u32) -> bool {
        self.definition.talent_spell_ids.contains(&spell_id)
            && !self
                .definition
                .selected_talent_spell_ids
                .contains(&spell_id)
    }

    fn replacement_aura(
        &mut self,
        base_spell_index: usize,
        replacement: SpellIdx,
    ) -> Option<crate::state::LocalAuraIdx> {
        // BOUNDS: callers pass indices produced by enumerating definition.spells.
        let base_spell = &self.definition.spells[base_spell_index];
        let base_aura_local = base_spell.applies_aura?;
        // BOUNDS: applies_aura indices are assigned from definition.aura_defs during construction.
        let base_aura = &self.definition.aura_defs[base_aura_local.as_usize()];

        if base_aura.aura_id != base_spell.spell_id {
            return Some(base_aura_local);
        }

        if let Some(index) = self
            .definition
            .aura_defs
            .iter()
            .position(|aura| aura.aura_id == replacement.as_u32())
        {
            return Some(crate::state::LocalAuraIdx::new(
                u8::try_from(index).expect("validated aura count fits in u8"),
            ));
        }

        let has_applied_aura =
            (1..=self.definition.game_data.max_effect_index(replacement)).any(|effect_index| {
                wowlab_engine_domain::dbc::spell_effect_is(
                    self.definition
                        .game_data
                        .effect_type(replacement, effect_index),
                    wowlab_engine_domain::dbc::SpellEffectKind::ApplyAura,
                )
            });

        if !has_applied_aura {
            return Some(base_aura_local);
        }

        let name = format!("{} override", base_aura.name);
        let draft = match AuraDefinitionDraft::new(&name, replacement.as_u32())
            .apply_base_from_data(&self.definition.game_data, replacement.as_u32())
        {
            Ok(draft) => draft,
            Err(error) => {
                self.definition.pending_error = Some(error);

                return None;
            }
        };
        let draft = match base_aura.on {
            AuraOn::Player => draft.on_player(),
            AuraOn::Target => draft.on_target(),
            AuraOn::Pet => draft.on_pet(),
        };
        let local = crate::state::LocalAuraIdx::new(
            u8::try_from(self.definition.aura_defs.len()).expect("validated aura count fits in u8"),
        );

        self.definition.aura_ids.insert(name, replacement.as_u32());
        self.definition.aura_defs.push(draft.finalize());

        Some(local)
    }

    fn ensure_replacement_spell(&mut self, base_spell_index: usize, replacement: SpellIdx) {
        if let Some(index) = self
            .definition
            .spells
            .iter()
            .position(|spell| spell.spell_id == replacement.as_u32())
        {
            // A replacement the manifest already declares still executes as the base action, so
            // the base spell's cast hook runs for both. Only inherit when the declaration brings no
            // hook of its own.
            // BOUNDS: hook vectors are kept positionally aligned with definition.spells.
            if self.definition.cast_hooks[index].is_none() {
                // BOUNDS: index and base_spell_index both refer to aligned spell/hook entries.
                self.definition.cast_hooks[index] = self.definition.cast_hooks[base_spell_index];
            }

            return;
        }

        let replacement_aura = self.replacement_aura(base_spell_index, replacement);

        if self.definition.pending_error.is_some() {
            return;
        }

        // BOUNDS: callers pass indices produced by enumerating definition.spells.

        let base_spell_id = self.definition.spells[base_spell_index].spell_id;
        // BOUNDS: the same validated index selects the replacement template.
        let mut spell = self.definition.spells[base_spell_index].clone();

        spell.spell_id = replacement.as_u32();
        spell.name = format!("{} override", spell.name);
        spell.applies_aura = replacement_aura;
        spell.override_aura_id = 0;
        spell.override_spell_id = 0;
        spell.override_aura_min_stacks = 0;
        spell.override_shares_base_cooldown = false;
        spell.override_preserves_aura = false;

        if spell.damage_effect.spell_id == base_spell_id {
            spell.damage_effect.spell_id = replacement.as_u32();
        }

        if spell.channel_tick_spell_id == base_spell_id {
            spell.channel_tick_spell_id = replacement.as_u32();
        }

        // BOUNDS: hook vectors are kept positionally aligned with definition.spells.

        let hook = self.definition.cast_hooks[base_spell_index];
        // BOUNDS: empower-release hooks are kept positionally aligned with definition.spells.
        let empower_release_hook = self.definition.empower_release_hooks[base_spell_index];
        // BOUNDS: tick hooks are kept positionally aligned with definition.spells.
        let tick_hook = self.definition.tick_hooks[base_spell_index];

        self.definition.spells.push(spell);
        self.definition.cast_hooks.push(hook);
        self.definition
            .empower_release_hooks
            .push(empower_release_hook);
        self.definition.tick_hooks.push(tick_hook);
    }
}