wowlab_engine_application/game_data/passives/

sources.rs

use std::collections::VecDeque;

use wowlab_engine_domain::dbc::PowerModifiers;
use wowlab_engine_gamedata::ResolvedGameDataBuilder;
use wowlab_engine_ports::{
    DataResolver, DynDataResolver, EngineError, SpecDescriptor, SpellId, TalentSelection,
};
use wowlab_types::{
    data::SpellDataFlat,
    game::{ClassId, RaceId},
    sim::{FastSet, SpellIdx},
};

use super::{PassiveData, stats::apply_talent_effect_overrides};
use crate::game_data::powers::apply_resource_passives;

pub(crate) async fn resolve_race_passive_spells(
    resolver: &DynDataResolver<'_>,
    race: Option<RaceId>,
    class: ClassId,
) -> Vec<SpellDataFlat> {
    let Some(race) = race else {
        return Vec::new();
    };
    let Ok(spell_ids) = resolver
        .get_racial_spells(race.wow_race_id(), i32::from(u8::from(class)))
        .await
    else {
        tracing::warn!(
            ?race,
            ?class,
            "racial spells not found; skipping race passives"
        );

        return Vec::new();
    };
    let mut spells = Vec::with_capacity(spell_ids.len());

    for spell_id in spell_ids {
        let Ok(spell) = resolver.get_spell(spell_id).await else {
            continue;
        };

        if spell.is_passive {
            spells.push(spell);
        }
    }

    spells
}

// #t(fn: rust_builder_param) this mutates the resolved-data accumulator; it is not a factory.
pub(super) async fn resolve_talent_passives(
    builder: &mut ResolvedGameDataBuilder,
    resolver: &DynDataResolver<'_>,
    talents: &[TalentSelection],
    power_modifiers: &PowerModifiers,
    specialization_order: i32,
    passive_data: &mut PassiveData,
) -> Result<(), EngineError> {
    let mut resolved_learned_spells = FastSet::default();
    let mut pending_learned_spells = VecDeque::new();

    for talent in talents {
        tokio::task::yield_now().await;
        pending_learned_spells.clear();
        passive_data
            .active_aura_spell_ids
            .insert(wowlab_types::numeric::u32_to_i32_saturating(
                talent.spell_id,
            ));
        let Ok(mut spell) = resolver
            .get_spell(SpellId::new(wowlab_types::numeric::u32_to_i32_saturating(
                talent.spell_id,
            )))
            .await
        else {
            continue;
        };

        pending_learned_spells.extend(
            spell
                .learn_spells
                .iter()
                .filter(|learned| learned.learn_spell_id > 0)
                .map(|learned| (spell.id, learned.learn_spell_id)),
        );

        apply_talent_effect_overrides(&mut spell, talent, true);
        apply_resource_passives(
            builder,
            power_modifiers,
            &spell,
            talent.ranks,
            Some(specialization_order),
        );

        if spell.is_passive {
            passive_data.passives.push((spell, f64::from(talent.ranks)));
        }

        while let Some((source_spell_id, learned_spell_id)) = pending_learned_spells.pop_front() {
            tokio::task::yield_now().await;

            if !resolved_learned_spells.insert(learned_spell_id) {
                continue;
            }

            passive_data.active_aura_spell_ids.insert(learned_spell_id);
            let learned_spell = resolver
                .get_spell(SpellId::new(learned_spell_id))
                .await
                .map_err(|error| {
                    learned_spell_resolution_error(source_spell_id, learned_spell_id, &error)
                })?;

            pending_learned_spells.extend(
                learned_spell
                    .learn_spells
                    .iter()
                    .filter(|nested| nested.learn_spell_id > 0)
                    .map(|nested| (learned_spell.id, nested.learn_spell_id)),
            );

            apply_resource_passives(
                builder,
                power_modifiers,
                &learned_spell,
                1,
                Some(specialization_order),
            );

            if learned_spell.is_passive {
                passive_data.passives.push((learned_spell, 1.0));
            }
        }
    }

    Ok(())
}

fn learned_spell_resolution_error(
    source_spell_id: i32,
    learned_spell_id: i32,
    error: &impl std::fmt::Display,
) -> EngineError {
    EngineError::spec_construction(format!(
        "failed to resolve spell {learned_spell_id} learned from selected talent spell {source_spell_id}: {error}"
    ))
}

pub(super) async fn resolve_race_passives(
    resolver: &DynDataResolver<'_>,
    race: Option<RaceId>,
    class: ClassId,
    passive_data: &mut PassiveData,
) {
    // #t(block: rust_async_loop_no_yield) folds already-resolved rows; every await happened above
    for spell in resolve_race_passive_spells(resolver, race, class).await {
        passive_data.active_aura_spell_ids.insert(spell.id);
        passive_data.passives.push((spell, 1.0));
    }
}

pub(super) async fn resolve_set_bonus_passives(
    resolver: &DynDataResolver<'_>,
    set_bonus_auras: &[u32],
    passives: &mut Vec<wowlab_engine_domain::dbc::RankedPassive>,
    active_aura_spell_ids: &mut FastSet<i32>,
) {
    let mut missing_spell_ids = Vec::with_capacity(set_bonus_auras.len());

    for &set_bonus_id in set_bonus_auras {
        active_aura_spell_ids.insert(wowlab_types::numeric::u32_to_i32_saturating(set_bonus_id));
        let Ok(spell) = resolver
            .get_spell(SpellId::new(wowlab_types::numeric::u32_to_i32_saturating(
                set_bonus_id,
            )))
            .await
        else {
            missing_spell_ids.push(set_bonus_id);
            continue;
        };

        if spell.is_passive {
            passives.push((spell, 1.0));
        }
    }

    if !missing_spell_ids.is_empty() {
        tracing::warn!(
            ?missing_spell_ids,
            "set bonus spells not found; skipping passive damage modifiers"
        );
    }
}

// #t(fn: rust_builder_param) this mutates the resolved-data accumulator; it is not a factory.
pub(super) async fn resolve_spell_overrides(
    builder: &mut ResolvedGameDataBuilder,
    descriptor: &SpecDescriptor,
    resolver: &DynDataResolver<'_>,
) -> Result<Vec<(SpellId, SpellId)>, EngineError> {
    let overrides = resolver
        .get_spell_overrides(wowlab_types::numeric::u32_to_i32_saturating(
            descriptor.spec_id.wow_spec_id(),
        ))
        .await
        .map_err(|error| {
            EngineError::spec_construction(format!("failed to resolve spell overrides: {error}"))
        })?;

    apply_spell_overrides(builder, &overrides)?;

    Ok(overrides)
}

// #t(fn: rust_builder_param) this mutates the resolved-data accumulator; it is not a factory.
pub(crate) fn apply_spell_overrides(
    builder: &mut ResolvedGameDataBuilder,
    overrides: &[(SpellId, SpellId)],
) -> Result<(), EngineError> {
    for (overridden_id, replacement_id) in overrides {
        let overridden = override_spell_idx(*overridden_id, "source")?;
        let replacement = override_spell_idx(*replacement_id, "replacement")?;

        builder.insert_spell_override(overridden, replacement);
    }

    Ok(())
}

fn override_spell_idx(spell_id: SpellId, role: &str) -> Result<SpellIdx, EngineError> {
    SpellIdx::try_from(spell_id).map_err(|error| {
        EngineError::spec_construction(format!("invalid override {role} id: {error}"))
    })
}

// #t(fn: rust_builder_param) this mutates the resolved-data accumulator; it is not a factory.
pub(super) async fn resolve_baseline_passives(
    builder: &mut ResolvedGameDataBuilder,
    descriptor: &SpecDescriptor,
    resolver: &DynDataResolver<'_>,
    power_modifiers: &PowerModifiers,
    specialization_order: i32,
    passive_data: &mut PassiveData,
) -> Result<Vec<u32>, EngineError> {
    let spec_spell_ids = resolver
        .get_specialization_spells(wowlab_types::numeric::u32_to_i32_saturating(
            descriptor.spec_id.wow_spec_id(),
        ))
        .await
        .map_err(|error| {
            EngineError::spec_construction(format!(
                "failed to resolve specialization spells: {error}"
            ))
        })?;
    let mut resolvable = Vec::with_capacity(spec_spell_ids.len());
    let mut missing_spell_ids = Vec::with_capacity(spec_spell_ids.len());

    for &spec_spell_id in &spec_spell_ids {
        let Ok(spell) = resolver.get_spell(spec_spell_id).await else {
            missing_spell_ids.push(spec_spell_id.as_i32());
            continue;
        };

        passive_data
            .active_aura_spell_ids
            .insert(spec_spell_id.as_i32());
        resolvable.push(wowlab_types::numeric::i32_to_u32_nonnegative(
            spec_spell_id.as_i32(),
        ));
        apply_resource_passives(
            builder,
            power_modifiers,
            &spell,
            1,
            Some(specialization_order),
        );

        if spell.is_passive {
            passive_data.passives.push((spell, 1.0));
        }
    }

    if !missing_spell_ids.is_empty() {
        tracing::warn!(
            ?missing_spell_ids,
            "specialization spells not found; skipping passive damage modifiers"
        );
    }

    for class_passive_id in
        wowlab_engine_domain::dbc::class_passive_spell_ids(descriptor.spec_id.class())
    {
        passive_data
            .active_aura_spell_ids
            .insert(wowlab_types::numeric::u32_to_i32_saturating(
                class_passive_id,
            ));
        let Ok(spell) = resolver
            .get_spell(SpellId::new(wowlab_types::numeric::u32_to_i32_saturating(
                class_passive_id,
            )))
            .await
        else {
            continue;
        };

        apply_resource_passives(
            builder,
            power_modifiers,
            &spell,
            1,
            Some(specialization_order),
        );
        passive_data
            .class_target_debuffs
            .extend(resolve_class_target_debuffs(resolver, &spell, &mut resolvable).await);

        if spell.is_passive {
            passive_data.passives.push((spell, 1.0));
        }
    }

    builder.set_class_target_debuffs(
        passive_data
            .class_target_debuffs
            .iter()
            .copied()
            .map(SpellIdx::from_raw)
            .collect(),
    );

    Ok(resolvable)
}

async fn resolve_class_target_debuffs(
    resolver: &DynDataResolver<'_>,
    passive: &SpellDataFlat,
    resolvable: &mut Vec<u32>,
) -> Vec<u32> {
    let ast = wowlab_parsers::parse_spell_desc(&passive.description).ast;
    let referenced =
        wowlab_parsers::analyze_spell_desc_dependencies(&ast, u32_from_spell_id(passive.id));
    let mut debuffs = Vec::new();

    for spell_id in referenced.spell_ids {
        if spell_id == u32_from_spell_id(passive.id) {
            continue;
        }

        let Ok(referenced_spell) = resolver
            .get_spell(SpellId::new(wowlab_types::numeric::u32_to_i32_saturating(
                spell_id,
            )))
            .await
        else {
            continue;
        };

        if !wowlab_engine_domain::dbc::is_target_damage_taken_debuff(&referenced_spell) {
            continue;
        }

        resolvable.push(spell_id);
        debuffs.push(spell_id);
    }

    tracing::debug!(
        class_passive_id = passive.id,
        ?debuffs,
        "resolved self-provided class damage-taken debuffs"
    );

    debuffs
}

fn u32_from_spell_id(spell_id: i32) -> u32 {
    wowlab_types::numeric::i32_to_u32_nonnegative(spell_id)
}