wowlab_engine_application/game_data/passives/

masking.rs

use wowlab_engine_ports::SpecDescriptor;
use wowlab_types::data::{EquippedItemRequirement, SpellDataFlat, WeaponStats};

pub(crate) fn should_fold_sheet_stat_passive(spell: &SpellDataFlat) -> bool {
    wowlab_engine_domain::dbc::is_stat_modifier_passive(spell)
        && !updates_passives_on_apply_remove(spell)
}

fn updates_passives_on_apply_remove(spell: &SpellDataFlat) -> bool {
    wowlab_engine_domain::dbc::spell_attribute_is(
        &spell.attributes,
        wowlab_engine_domain::dbc::SpellAttributeKind::UpdatePassivesOnApplyRemove,
    )
}

/// The weapons a passive's equipped-item requirement is tested against.
#[derive(Clone, Copy, Debug)]
pub(crate) struct EquippedWeapons<'a> {
    pub main_hand: &'a WeaponStats,
    pub off_hand: Option<&'a WeaponStats>,
}

impl EquippedWeapons<'_> {
    fn satisfies(self, requirement: EquippedItemRequirement) -> bool {
        std::iter::once(self.main_hand)
            .chain(self.off_hand)
            .any(|weapon| {
                requirement.matches(weapon.item_class, weapon.subclass, weapon.inventory_type)
            })
    }
}

/// Keeps the passives whose contribution is fixed for the whole run.
pub(crate) fn retain_statically_folded_passives(
    passives: &mut Vec<wowlab_engine_domain::dbc::RankedPassive>,
    weapons: EquippedWeapons<'_>,
) {
    passives.retain(|(spell, _)| {
        if !updates_passives_on_apply_remove(spell) {
            return true;
        }

        let satisfied = spell
            .equipped_item_requirement
            .is_some_and(|requirement| weapons.satisfies(requirement));

        tracing::trace!(
            spell_id = spell.id,
            spell_name = spell.name.as_str(),
            satisfied,
            "apply/remove-updating passive tested against the equipped weapons"
        );

        satisfied
    });
}

/// Drops passive effects a description assigns to another specialization.
pub(crate) fn mask_spec_conditional_passive_effects(
    passives: &mut [wowlab_engine_domain::dbc::RankedPassive],
    specialization_order: i32,
) {
    let Ok(order_index) = u8::try_from(specialization_order) else {
        return;
    };

    for (spell, _) in passives.iter_mut() {
        for statement in wowlab_parsers::spell_desc_spec_conditional_effects(&spell.description) {
            let inert = i32::from(statement.inert_effect(order_index)) - 1;

            // #t(rust_log_in_loop) one line per masked effect is the only record of the selection
            tracing::debug!(
                spell_id = spell.id,
                spell_name = spell.name.as_str(),
                spec_index = statement.spec_index,
                order_index,
                inert_effect = statement.inert_effect(order_index),
                "masked the passive effect the description assigns to another specialization"
            );

            spell.effects.retain(|effect| effect.index != inert);
        }
    }
}

/// Drops passive effects declared inert for this specialization.
pub(super) fn mask_declared_passive_effects(
    passives: &mut [wowlab_engine_domain::dbc::RankedPassive],
    descriptor: &SpecDescriptor,
) {
    for (spell_id, effect_index) in descriptor.metadata.masked_passive_effects {
        let spell_id = wowlab_types::numeric::u32_to_i32_saturating(*spell_id);
        let dbc_index = i32::from(*effect_index) - 1;

        for (spell, _) in passives
            .iter_mut()
            .filter(|(spell, _)| spell.id == spell_id)
        {
            let before = spell.effects.len();

            spell.effects.retain(|effect| effect.index != dbc_index);

            debug_assert!(
                spell.effects.len() != before,
                "declared passive effect mask matched no DBC effect"
            );
        }
    }
}

/// Replaces every passive effect value explicitly overridden by the specialization.
pub(crate) fn apply_declared_passive_effect_overrides(
    passives: &mut [wowlab_engine_domain::dbc::RankedPassive],
    descriptor: &SpecDescriptor,
) -> Vec<((u32, u8), f64)> {
    let mut resolved = Vec::with_capacity(descriptor.metadata.passive_effect_overrides.len());

    for declared in descriptor.metadata.passive_effect_overrides {
        let replacement = declared.multiplier
            * match declared.source {
                Some((source_id, source_effect)) => {
                    match declared_effect_base_points(passives, source_id, source_effect) {
                        Some(base_points) => base_points,
                        None => continue,
                    }
                }
                None => declared.value,
            };

        write_effect_base_points(passives, declared.spell_id, declared.effect, replacement);
        resolved.push(((declared.spell_id, declared.effect), replacement));
    }

    resolved
}

fn declared_effect_base_points(
    passives: &[wowlab_engine_domain::dbc::RankedPassive],
    spell_id: u32,
    effect: u8,
) -> Option<f64> {
    let spell_id = wowlab_types::numeric::u32_to_i32_saturating(spell_id);
    let dbc_index = i32::from(effect) - 1;

    passives
        .iter()
        .filter(|(spell, _)| spell.id == spell_id)
        .find_map(|(spell, _)| {
            spell
                .effects
                .iter()
                .find(|effect| effect.index == dbc_index)
                .map(|effect| effect.base_points)
        })
}

fn write_effect_base_points(
    passives: &mut [wowlab_engine_domain::dbc::RankedPassive],
    spell_id: u32,
    effect: u8,
    base_points: f64,
) {
    let spell_id = wowlab_types::numeric::u32_to_i32_saturating(spell_id);
    let dbc_index = i32::from(effect) - 1;

    tracing::debug!(
        spell_id,
        effect_index = effect,
        base_points,
        "declared passive effect override applied"
    );

    for (spell, _) in passives
        .iter_mut()
        .filter(|(spell, _)| spell.id == spell_id)
    {
        for target in spell
            .effects
            .iter_mut()
            .filter(|effect| effect.index == dbc_index)
        {
            target.base_points = base_points;
        }
    }
}