wowlab_engine_combat/builder/combat_builder/

talents.rs

use wowlab_engine_domain::rotation::to_simc_key;
use wowlab_engine_ports::TalentSelection;
use wowlab_types::sim::IntMap;

use super::{BuilderAuraDef, CombatSystemBuilder};
use crate::{AuraDefinitionDraft, BuffEffect, BuilderError, LocalAuraIdx};

fn resolved_aura_effects(
    definitions: &[BuilderAuraDef],
    source_spell_id: u32,
    effect_index: u8,
) -> Vec<BuffEffect> {
    let mut effects = Vec::new();

    if let Some(source) = definitions
        .iter()
        .find(|definition| definition.aura_id == source_spell_id)
    {
        for &effect in source.effects.iter().flatten() {
            if effect.dbc_source() == Some((source_spell_id, effect_index)) {
                effects.push(effect);
            }
        }
    }

    effects
}

fn remove_resolved_effect(definition: &mut BuilderAuraDef, source_spell_id: u32, effect_index: u8) {
    for slot in &mut definition.effects {
        if slot
            .as_ref()
            .and_then(BuffEffect::dbc_source)
            .is_some_and(|source| source == (source_spell_id, effect_index))
        {
            *slot = None;
        }
    }
}

fn aura_effects_full(definition: &BuilderAuraDef) -> BuilderError {
    crate::builder::BuilderErrorKind::AuraEffectsFull {
        aura_name: definition.name.clone(),
        aura_id: definition.aura_id,
        slot_count: crate::state::MAX_AURA_BUFF_EFFECTS,
    }
    .into()
}

fn copy_resolved_effects(
    definition: &mut BuilderAuraDef,
    effects: &[BuffEffect],
) -> Result<(), BuilderError> {
    let available = definition
        .effects
        .iter()
        .filter(|slot| slot.is_none())
        .count();

    if effects.len() > available {
        return Err(aura_effects_full(definition));
    }

    for &effect in effects {
        if crate::state::try_push_effect(&mut definition.effects, effect).is_err() {
            return Err(aura_effects_full(definition));
        }
    }

    Ok(())
}

impl CombatSystemBuilder {
    pub fn talent_selections(mut self, talents: &[TalentSelection]) -> Self {
        self.selected_hero_trees.extend(
            talents
                .iter()
                .filter(|talent| talent.ranks > 0)
                .filter_map(|talent| talent.hero_tree.clone())
                .map(String::into_boxed_str),
        );
        self.selected_hero_trees.sort_unstable();
        self.selected_hero_trees.dedup();

        let aura_id_to_name: IntMap<u32, String> = self
            .aura_ids
            .iter()
            .map(|(name, &id)| (id, name.clone()))
            .collect();

        let spell_id_to_name: IntMap<u32, String> = self
            .spell_ids
            .iter()
            .map(|(name, &id)| (id, name.clone()))
            .collect();

        for talent in talents {
            if talent.ranks == 0 {
                continue;
            }

            self.register_selected_replacement(talent);

            for id in std::iter::once(talent.spell_id).chain(talent.override_spell()) {
                self.selected_talent_spell_ids.push(id);
                self.selected_talent_ranks
                    .entry(id)
                    .and_modify(|rank| *rank = (*rank).max(talent.ranks))
                    .or_insert(talent.ranks);

                if let Some(name) = self.talent_names_by_id.get(&id) {
                    // #t(rust_clone_in_loop) hints own names independently of the builder's lookup map.
                    self.hints.talent_ranks.push((name.clone(), talent.ranks));
                } else if let Some(name) = spell_id_to_name.get(&id) {
                    self.hints
                        .talent_ranks
                        .push((to_simc_key(name), talent.ranks));
                } else if let Some(name) = aura_id_to_name.get(&id) {
                    self.hints
                        .talent_ranks
                        .push((to_simc_key(name), talent.ranks));
                }
            }

            if !talent.precombat_aura {
                continue;
            }

            if let Some(local_idx) = self.register_selected_passive_aura(talent.spell_id) {
                self.precombat_auras.push(local_idx);
                self.talent_aura_stacks.push((local_idx, talent.ranks));
            }
        }

        self
    }

    pub fn talent_spell_ids(mut self, talents: &[(&str, u32)]) -> Self {
        for &(name, id) in talents {
            let key = to_simc_key(name);

            self.talent_spell_ids.push(id);
            // #t(rust_clone_in_loop) the lookup map and exported hints both own the normalized key.
            self.talent_names_by_id.insert(id, key.clone());
            self.hints.talent_ranks.push((key, 0));
        }

        self
    }

    pub fn talent_companion_aura(mut self, talent_spell_id: u32, aura: LocalAuraIdx) -> Self {
        if self.selected_talent_spell_ids.contains(&talent_spell_id)
            && !self.precombat_auras.contains(&aura)
        {
            self.precombat_auras.push(aura);
        }

        self
    }

    /// Retains or copies one data-derived aura effect only when `talent_spell_id` is selected.
    ///
    /// Call this after [`Self::talent_selections`].
    /// The source identifies an effect already lowered from resolved game data.
    /// A different `aura` receives copies that preserve the DBC source coordinate.
    /// Content does not provide a replacement payload.
    pub fn talent_gated_aura_effect(
        mut self,
        talent_spell_id: u32,
        aura: LocalAuraIdx,
        source_spell_id: u32,
        effect_index: u8,
    ) -> Self {
        if self.pending_error.is_some() {
            return self;
        }

        let selected = self.selected_talent_spell_ids.contains(&talent_spell_id);
        let source_effects = resolved_aura_effects(&self.aura_defs, source_spell_id, effect_index);
        let Some(definition) = self.aura_defs.get_mut(aura.as_usize()) else {
            self.pending_error = Some(
                crate::builder::BuilderErrorKind::GameData(
                    wowlab_engine_ports::EngineError::spec_construction(format!(
                        "talent-gated DBC effect references missing local aura {}",
                        aura.raw()
                    )),
                )
                .into(),
            );

            return self;
        };
        let source_is_target = definition.aura_id == source_spell_id;

        if source_is_target {
            if !selected {
                remove_resolved_effect(definition, source_spell_id, effect_index);
            }
        } else if selected {
            if let Err(error) = copy_resolved_effects(definition, &source_effects) {
                self.pending_error = Some(error);

                return self;
            }
        }

        if source_effects.is_empty() {
            let source = wowlab_types::sim::SpellIdx::from_raw(source_spell_id);
            let max_effect_index = self.game_data.max_effect_index(source);

            if max_effect_index > 0 {
                self.pending_error = Some(
                    crate::builder::BuilderErrorKind::GameData(
                        wowlab_engine_ports::EngineError::spec_construction(format!(
                            "source aura {source_spell_id} did not lower DBC effect {effect_index} \
                             for target {} (max effect {max_effect_index}, aura subtype {})",
                            definition.name,
                            self.game_data.effect_aura(source, effect_index),
                        )),
                    )
                    .into(),
                );
            }
        }

        self
    }

    pub fn set_bonus_auras(mut self, spell_ids: &[u32]) -> Self {
        let aura_id_to_local = self.aura_id_to_local();

        for &spell_id in spell_ids {
            if let Some(&local_idx) = aura_id_to_local.get(&spell_id) {
                self.precombat_auras.push(local_idx);
            }
        }

        self
    }

    fn register_selected_replacement(&mut self, talent: &TalentSelection) {
        let Some(replaced_spell_id) = talent.replaced_spell() else {
            return;
        };

        if self
            .selected_replaced_spell_ids
            .contains(&replaced_spell_id)
        {
            return;
        }

        self.selected_replaced_spell_ids.push(replaced_spell_id);

        if talent.precombat_aura {
            return;
        }

        for spell_id in self.spell_ids.values_mut() {
            if *spell_id == replaced_spell_id {
                *spell_id = talent.spell_id;
            }
        }
    }

    fn register_selected_passive_aura(&mut self, spell_id: u32) -> Option<LocalAuraIdx> {
        if let Some(index) = self
            .aura_defs
            .iter()
            .position(|definition| definition.aura_id == spell_id)
        {
            return Some(LocalAuraIdx::new(
                u8::try_from(index).expect("validated aura count fits in u8"),
            ));
        }

        if self
            .game_data
            .is_folded_passive(wowlab_types::sim::SpellIdx::from_raw(spell_id))
        {
            return None;
        }

        let name = self
            .talent_names_by_id
            .get(&spell_id)
            .cloned()
            .unwrap_or_else(|| format!("talent_{spell_id}"));
        let builder = match AuraDefinitionDraft::new(&name, spell_id)
            .on_player()
            .apply_base_from_data(&self.game_data, spell_id)
        {
            Ok(builder) => builder,
            Err(error) => {
                self.pending_error = Some(error);

                return None;
            }
        };
        let local = LocalAuraIdx::new(
            u8::try_from(self.aura_defs.len()).expect("validated aura count fits in u8"),
        );

        self.aura_ids.insert(name, spell_id);
        self.aura_defs.push(builder.finalize());

        Some(local)
    }

    fn aura_id_to_local(&self) -> IntMap<u32, LocalAuraIdx> {
        let mut locals = IntMap::default();

        for (index, definition) in self.aura_defs.iter().enumerate() {
            let index = u8::try_from(index).expect("validated aura count fits in u8");

            locals.insert(definition.aura_id, LocalAuraIdx::new(index));
        }

        locals
    }
}