wowlab_engine_combat/builder/combat_builder/build/

finish.rs

use wowlab_types::sim::Rotation;

use super::{
    ActionOverrideRegistration, AuraDefinitionDraft, AuraSubtypeKind, BuiltCombatSystem,
    CombatBuildError, CombatSystemBuilder, CooldownBypass, CostBypass, EngineError,
    HeroTalentTreeDesc, ImpactProcRegistration, InitialBufferConfig, RotationCompileInput,
    SpellGate, SpellIdx, SpellOverride, TriggerProgramRegistration, compile_rotation,
    ensure_aura_slots, expand_spell_learn_chains, expand_spell_override_chains,
    lower_builder_state, populate_initial_buffer,
};

pub(in crate::builder::combat_builder) struct CombatBuildResult(
    Result<BuiltCombatSystem, CombatBuildError>,
);

impl CombatBuildResult {
    pub(in crate::builder::combat_builder) fn into_result(
        self,
    ) -> Result<BuiltCombatSystem, CombatBuildError> {
        self.0
    }
}

pub(super) fn apply_hero_tree_spell_gating(
    trees: &[HeroTalentTreeDesc],
    selected_tree_names: &[Box<str>],
    talent_spell_ids: &mut Vec<u32>,
    selected_talent_spell_ids: &mut Vec<u32>,
) {
    for tree in trees {
        let tree_selected = selected_tree_names
            .iter()
            .any(|name| name.eq_ignore_ascii_case(tree.name))
            || tree
                .spells
                .iter()
                .chain(tree.auras.iter())
                .any(|&(_, id)| selected_talent_spell_ids.contains(&id));

        for &(_, id) in tree.spells {
            if !talent_spell_ids.contains(&id) {
                talent_spell_ids.push(id);
            }

            if tree_selected && !selected_talent_spell_ids.contains(&id) {
                selected_talent_spell_ids.push(id);
            }
        }
    }
}

impl CombatSystemBuilder {
    // #t(fn: rust_cyclomatic_complexity) sequential build steps have independent validation and registration paths
    // #t(fn: rust_max_fn_lines) the build method keeps its ordered construction transaction together
    pub(in crate::builder::combat_builder) fn finish_build(
        mut self,
        rotation: &Rotation,
    ) -> CombatBuildResult {
        let result = (|| -> Result<BuiltCombatSystem, CombatBuildError> {
            if let Some(err) = self.pending_error.take() {
                return Err(err.into());
            }

            let encounter = self.encounter.take().ok_or_else(|| {
                EngineError::spec_construction("combat construction requires a resolved encounter")
            })?;

            let updates: Vec<(String, u32)> = self
                .spell_ids
                .iter()
                .filter_map(|(name, &id)| {
                    self.game_data
                        .spell_override(SpellIdx::from_raw(id))
                        .map(|replacement| (name.clone(), replacement.as_u32()))
                })
                .collect();

            for (name, replacement) in updates {
                self.spell_ids.insert(name, replacement);
            }

            expand_spell_learn_chains(&mut self.talent_spell_ids, &self.game_data);
            expand_spell_learn_chains(&mut self.selected_talent_spell_ids, &self.game_data);

            if self.spec_id.is_some() {
                apply_hero_tree_spell_gating(
                    self.hero_talent_trees,
                    &self.selected_hero_trees,
                    &mut self.talent_spell_ids,
                    &mut self.selected_talent_spell_ids,
                );

                for &(name, id) in self
                    .hero_talent_trees
                    .iter()
                    .flat_map(|tree| tree.spells.iter())
                {
                    // #t(rust_alloc_in_loop) required for map key
                    self.spell_ids.entry(name.to_string()).or_insert(id);
                }

                for &(name, id) in self
                    .hero_talent_trees
                    .iter()
                    .flat_map(|tree| tree.auras.iter())
                {
                    // #t(rust_alloc_in_loop) required for map key
                    self.aura_ids.entry(name.to_string()).or_insert(id);
                }
            }

            ActionOverrideRegistration {
                definition: &mut self,
            }
            .apply_dbc_action_overrides();
            self.register_class_target_debuffs();
            self.apply_selected_triggered_aura_values();
            TriggerProgramRegistration {
                definition: &mut self,
            }
            .auto_register_dbc_trigger_programs();
            ImpactProcRegistration {
                definition: &mut self,
            }
            .auto_register_dbc_impact_procs();

            let gating: Vec<SpellGate> = self
                .spells
                .iter()
                .filter(|s| s.gating_aura_id != 0)
                .map(|s| SpellGate {
                    spell_id: s.spell_id,
                    aura_id: s.gating_aura_id,
                    min_stacks: s.gating_aura_min_stacks,
                })
                .collect();

            let cost_bypass: Vec<CostBypass> = self
                .spells
                .iter()
                .filter(|s| s.cost_bypass_aura_id != 0)
                .map(|s| CostBypass {
                    spell_id: s.spell_id,
                    aura_id: s.cost_bypass_aura_id,
                })
                .collect();

            let cooldown_bypass: Vec<CooldownBypass> = self
                .spells
                .iter()
                .filter(|s| s.cooldown_bypass_aura_id != 0)
                .map(|s| CooldownBypass {
                    spell_id: s.spell_id,
                    aura_id: s.cooldown_bypass_aura_id,
                })
                .collect();

            let spell_overrides: Vec<SpellOverride> = self
                .spells
                .iter()
                .filter(|spell| spell.override_aura_id != 0 && spell.override_spell_id != 0)
                .map(|spell| SpellOverride {
                    spell_id: spell.spell_id,
                    replacement_spell_id: spell.override_spell_id,
                    aura_id: spell.override_aura_id,
                    shares_base_cooldown: spell.override_shares_base_cooldown,
                })
                .collect();

            self.hints.primary_resource =
                (!self.resource_name.is_empty()).then(|| self.resource_name.clone());

            let (engine, mut buffer) = compile_rotation(&RotationCompileInput {
                rotation,
                spell_ids: &self.spell_ids,
                aura_ids: &self.aura_ids,
                secondary_resource_name: self.secondary_resource_name.as_deref(),
                hints: &self.hints,
                gating: &gating,
                cost_bypass: &cost_bypass,
                cooldown_bypass: &cooldown_bypass,
                overrides: &spell_overrides,
            })?;

            // Dual wield: an equipped off-hand weapon swings on its own timer. The swing loop
            // maps non-pet defs to hands in order (first = main hand, second = off hand), so a
            // single-player-def spec gets its off-hand swing synthesized from the main-hand def.
            let player_aa_count = self.auto_attacks.iter().filter(|aa| !aa.is_pet).count();

            if player_aa_count == 1 && self.game_data.off_hand().is_some_and(|oh| oh.speed_ms > 0) {
                if let Some(mh_def) = self.auto_attacks.iter().find(|aa| !aa.is_pet).cloned() {
                    self.auto_attacks.push(mh_def);
                }
            }

            let mut names: Vec<Box<str>> = Vec::new();
            let parts = lower_builder_state(
                &self.spells,
                &self.aura_defs,
                &self.auto_attacks,
                &self.impact_effect_procs,
                &mut names,
            );
            let resource_max = self.resource_max;

            let talent_ranks = std::mem::take(&mut self.hints.talent_ranks);
            let mut talent_spell_ids = std::mem::take(&mut self.talent_spell_ids);
            let mut selected_talent_spell_ids = std::mem::take(&mut self.selected_talent_spell_ids);
            let selected_replaced_spell_ids = std::mem::take(&mut self.selected_replaced_spell_ids);

            expand_spell_override_chains(&mut talent_spell_ids, &self.game_data);
            expand_spell_override_chains(&mut selected_talent_spell_ids, &self.game_data);

            let state = self
                .assemble_state(parts, &selected_talent_spell_ids, encounter)
                .into_result()?;
            // Every registered aura gets a buffer slot: `applies_aura`, hooks, and
            // `on_sim_start` must work even when the rotation never reads the aura
            // (rotation compilation only allocates APL-referenced slots, and
            // `apply_aura` silently no-ops on a missing slot).

            for aura in &state.defs.auras {
                ensure_aura_slots(&state, &mut buffer, aura.aura_id, aura.on);
            }

            populate_initial_buffer(
                &state,
                &mut buffer,
                &InitialBufferConfig {
                    resource_max,
                    talent_ranks: &talent_ranks,
                    talent_spell_ids: &talent_spell_ids,
                    selected_talent_spell_ids: &selected_talent_spell_ids,
                    selected_replaced_spell_ids: &selected_replaced_spell_ids,
                },
            );

            Ok(BuiltCombatSystem {
                state,
                rotation: engine,
                buffer,
                names,
            })
        })();

        CombatBuildResult(result)
    }

    /// Registers the class's self-provided damage-taken debuffs as permanent target auras.
    ///
    /// A lone monk still applies Mystic Touch and a lone demon hunter still brands its target.
    /// `optimal_raid` governs only the external raid provider (`sc_demon_hunter.cpp:2577`).
    /// The debuff's DBC duration is infinite, so a precombat application is its whole lifecycle.
    fn register_class_target_debuffs(&mut self) {
        let debuffs: Vec<SpellIdx> = self.game_data.class_target_debuffs().to_vec();

        for debuff in debuffs {
            if self
                .aura_defs
                .iter()
                .any(|aura| aura.aura_id == debuff.as_u32())
            {
                continue;
            }

            // #t(rust_alloc_in_loop) each registered aura requires its own stable map key
            let name = format!("class debuff {}", debuff.as_u32());
            let draft = match AuraDefinitionDraft::new(&name, debuff.as_u32())
                .apply_base_from_data(&self.game_data, debuff.as_u32())
            {
                Ok(draft) => draft.on_target(),
                Err(error) => {
                    self.pending_error = Some(error);

                    return;
                }
            };
            let Ok(index) = u8::try_from(self.aura_defs.len()) else {
                return;
            };

            // #t(rust_log_in_loop) each construction-time registration identifies the exact class aura
            tracing::debug!(
                aura_id = debuff.as_u32(),
                local_index = index,
                "registered self-provided class damage-taken debuff"
            );
            self.aura_ids.insert(name, debuff.as_u32());
            self.aura_defs.push(draft.finalize());
            self.precombat_auras
                .push(crate::state::LocalAuraIdx::new(index));
        }
    }

    fn apply_selected_triggered_aura_values(&mut self) {
        let mut forwarded = std::collections::BTreeMap::<u32, Option<(u32, f64)>>::new();

        for &driver_spell_id in &self.selected_talent_spell_ids {
            let driver = SpellIdx::from_raw(driver_spell_id);

            for effect_index in 1..=self.game_data.max_effect_index(driver) {
                if self.game_data.effect_aura(driver, effect_index)
                    != AuraSubtypeKind::TriggerSpellWithValue as i32
                {
                    continue;
                }

                let Some(triggered) = self.game_data.trigger_spell(driver, effect_index) else {
                    continue;
                };
                let value = self.game_data.base_points(driver, effect_index);
                let entry = forwarded
                    .entry(triggered.as_u32())
                    .or_insert(Some((driver_spell_id, value)));

                if entry.is_some_and(|(_, existing)| existing.to_bits() != value.to_bits()) {
                    *entry = None;
                }
            }
        }

        for (aura_id, source) in forwarded {
            let Some((driver_spell_id, value)) = source else {
                // #t(rust_log_in_loop) each conflict identifies the exact forwarded aura value
                tracing::debug!(
                    aura_id,
                    "DBC_TRIGGER_VALUE_CONFLICT: selected drivers forward different values"
                );
                continue;
            };
            let Some(aura) = self
                .aura_defs
                .iter_mut()
                .find(|aura| aura.aura_id == aura_id)
            else {
                continue;
            };
            let patched = crate::builder::aura_builder::apply_forwarded_effect_value(
                aura.aura_id,
                &mut aura.effects,
                &self.game_data,
                value,
            );

            if patched > 0 {
                // #t(rust_log_in_loop) each patch identifies the exact driver-to-aura rewrite
                tracing::debug!(
                    driver_spell_id,
                    aura_id,
                    value,
                    patched,
                    "forwarded selected trigger value into registered aura effects"
                );
            }
        }
    }
}