wowlab_engine_combat/systems/damage_pipeline/setup/

spell_modifiers.rs

use wowlab_engine_domain::{
    dbc::{
        ModifierOperation, ModifierPropertyKind, ResolvedGameDataSemanticExt as _,
        aura_subtype_modifier, modifier_property_is,
    },
    rotation::DenseBuffer,
};
use wowlab_types::constants::HUNDRED;

use crate::{
    state::{BuffEffect, CombatState, DamageEffectRef, DamageSource},
    systems::{
        buffs::{
            dbc_effect_points, for_each_active_actor_aura_effect,
            for_each_active_target_aura_effect, spell_modifier_owner, target_aura_mechanic_mask,
        },
        damage_pipeline::DamageFlags,
    },
};

#[derive(Clone, Copy, Debug, PartialEq)]
// #t(rust_similar_structs) Spell-scoped aura totals and driver callback results are separate pipeline stages with different ownership.
pub(crate) struct SpellScopedMods {
    pub(crate) damage_mult: f64,
    pub(crate) target_damage_mult: f64,
    pub(crate) crit_chance_pct: f64,
    pub(crate) crit_damage_mult: f64,
}

impl Default for SpellScopedMods {
    fn default() -> Self {
        Self {
            damage_mult: 1.0,
            target_damage_mult: 1.0,
            crit_chance_pct: 0.0,
            crit_damage_mult: 1.0,
        }
    }
}

#[derive(Clone, Copy, Debug)]
pub(crate) struct SpellModifierQuery {
    profile_spell_id: u32,
    effect: DamageEffectRef,
    flags: DamageFlags,
}

impl SpellModifierQuery {
    pub(crate) const fn new(
        profile_spell_id: u32,
        effect: DamageEffectRef,
        flags: DamageFlags,
    ) -> Self {
        Self {
            profile_spell_id,
            effect,
            flags,
        }
    }

    fn listed(self, spells: &[u32]) -> bool {
        spells.contains(&self.profile_spell_id) || spells.contains(&self.effect.spell_id)
    }

    fn affected(self, state: &CombatState, source_spell_id: u32, effect_index: u8) -> bool {
        [self.profile_spell_id, self.effect.spell_id]
            .into_iter()
            .any(|spell_id| {
                state.config.game_data.effect_affects_spell(
                    wowlab_types::sim::SpellIdx::from_raw(source_spell_id),
                    effect_index,
                    wowlab_types::sim::SpellIdx::from_raw(spell_id),
                )
            })
    }

    fn mechanic_mask(self, state: &CombatState) -> wowlab_engine_domain::dbc::MechanicMask {
        let data = &state.config.game_data;
        let effect_spell = wowlab_types::sim::SpellIdx::from_raw(self.effect.spell_id);
        let effect = data.effect_mechanic_mask(effect_spell, self.effect.effect_index);

        if effect.is_empty() {
            data.spell_mechanic_mask(wowlab_types::sim::SpellIdx::from_raw(self.profile_spell_id))
        } else {
            effect
        }
    }

    fn school_mask(self, state: &CombatState) -> wowlab_engine_domain::dbc::SpellSchoolMask {
        let data = &state.config.game_data;
        let raw = data
            .school_mask(wowlab_types::sim::SpellIdx::from_raw(self.effect.spell_id))
            .or_else(|| {
                data.school_mask(wowlab_types::sim::SpellIdx::from_raw(self.profile_spell_id))
            })
            .unwrap_or_default();

        wowlab_engine_domain::dbc::SpellSchoolMask::from_dbc(raw)
    }
}

struct SpellModifierContext<'a> {
    state: &'a CombatState,
    buf: &'a DenseBuffer,
    query: SpellModifierQuery,
    target: Option<wowlab_types::sim::EnemyIdx>,
    now: wowlab_types::sim::SimTime,
}

#[derive(Clone, Copy)]
struct ActiveEffectPointModifier {
    stacks: f64,
    value: f64,
    source_spell_id: u32,
    effect_index: u8,
    operation: ModifierOperation,
}

impl ActiveEffectPointModifier {
    fn from_buff(stacks: f64, effect: BuffEffect) -> Option<Self> {
        let BuffEffect::SpellModifierFromEffect {
            value,
            source_spell_id,
            effect_index,
            property: ModifierPropertyKind::Points,
            operation,
        } = effect
        else {
            return None;
        };

        Some(Self {
            stacks,
            value,
            source_spell_id,
            effect_index,
            operation,
        })
    }
}

impl SpellModifierContext<'_> {
    fn apply(&self, stacks: f64, effect: &BuffEffect, mods: &mut SpellScopedMods) {
        let before = *mods;

        self.apply_damage(stacks, effect, mods);
        self.apply_target(stacks, effect, mods);
        self.apply_critical(stacks, effect, mods);

        if *mods != before {
            tracing::trace!(
                profile_spell_id = self.query.profile_spell_id,
                effect_spell_id = self.query.effect.spell_id,
                stacks,
                ?effect,
                damage_mult = mods.damage_mult,
                target_damage_mult = mods.target_damage_mult,
                crit_chance_pct = mods.crit_chance_pct,
                crit_damage_mult = mods.crit_damage_mult,
                "spell-scoped aura modifier applied"
            );
        }
    }

    fn apply_damage(&self, stacks: f64, effect: &BuffEffect, mods: &mut SpellScopedMods) {
        match effect {
            BuffEffect::DamageMultSpells(value, spells) if self.query.listed(spells) => {
                mods.damage_mult *= value.powf(stacks);
            }
            BuffEffect::DamageMultSpellsActive(value, spells) if self.query.listed(spells) => {
                mods.damage_mult *= value;
            }
            BuffEffect::SpellDamageFromEffect {
                percent,
                source_spell_id,
                effect_index,
                periodic,
            } if *periodic == self.query.flags.contains(DamageFlags::PERIODIC)
                && self
                    .query
                    .affected(self.state, *source_spell_id, *effect_index) =>
            {
                let points = dbc_effect_points(self.state, *source_spell_id, *effect_index, stacks);

                mods.damage_mult *= 1.0 + percent * points / HUNDRED;
            }
            BuffEffect::DamageMultSpellsLinear(value, spells) if self.query.listed(spells) => {
                mods.damage_mult *= 1.0 + value / HUNDRED * stacks;
            }
            BuffEffect::DynamicDamageMultSpells(resolve, spells) if self.query.listed(spells) => {
                mods.damage_mult *=
                    resolve(self.state, self.buf, self.target, self.now).powf(stacks);
            }
            BuffEffect::DamageToTargetAuraMechanicPercent {
                percent,
                mechanic_mask,
            } if self.target.is_some_and(|target| {
                target_aura_mechanic_mask(self.state, self.buf, target, self.now)
                    .intersects(*mechanic_mask)
            }) =>
            {
                mods.damage_mult *= (1.0 + percent / HUNDRED).powf(stacks);
            }
            _ => {}
        }
    }

    /// Applies an aura-87 (`ModDamageTakenPercent`) effect carried by an aura on the *victim*.
    ///
    /// The player-aura form of the same effect is the defensive half, owned by `incoming_damage`.
    /// Only a debuff on the target scales outgoing damage, so this runs over the target-aura walk.
    fn apply_incoming_damage(&self, stacks: f64, effect: &BuffEffect, mods: &mut SpellScopedMods) {
        if let BuffEffect::IncomingDamagePercent { percent, schools } = effect
            && schools.intersects(self.query.school_mask(self.state))
        {
            mods.target_damage_mult *= (1.0 + percent / HUNDRED).max(0.0).powf(stacks);
        }
    }

    fn apply_target(&self, stacks: f64, effect: &BuffEffect, mods: &mut SpellScopedMods) {
        match effect {
            BuffEffect::DamageTakenFromSource(percent, source)
                if damage_source_matches(*source, self.query.flags) =>
            {
                mods.target_damage_mult *= 1.0 + percent / HUNDRED;
            }
            BuffEffect::DamageTakenFromSourceSpells {
                percent,
                source_spell_id,
                effect_index,
                source,
            } if damage_source_matches(*source, self.query.flags)
                && self
                    .query
                    .affected(self.state, *source_spell_id, *effect_index) =>
            {
                let points = dbc_effect_points(self.state, *source_spell_id, *effect_index, stacks);

                mods.target_damage_mult *= 1.0 + percent / HUNDRED * points;
            }
            BuffEffect::MechanicDamageTakenPercent {
                percent,
                mechanic_mask,
            } if self
                .query
                .mechanic_mask(self.state)
                .intersects(*mechanic_mask) =>
            {
                mods.target_damage_mult *= (1.0 + percent / HUNDRED).powf(stacks);
            }
            BuffEffect::CreatureAoeDamageAvoidance { percent, schools }
                if self.query.flags.contains(DamageFlags::AOE)
                    && schools.intersects(self.query.school_mask(self.state)) =>
            {
                mods.target_damage_mult *= (1.0 + percent / HUNDRED).powf(stacks);
            }
            _ => {}
        }
    }

    fn apply_critical(&self, stacks: f64, effect: &BuffEffect, mods: &mut SpellScopedMods) {
        match effect {
            BuffEffect::SpellCritChanceFromEffect {
                percent,
                source_spell_id,
                effect_index,
            } if self
                .query
                .affected(self.state, *source_spell_id, *effect_index) =>
            {
                let points = dbc_effect_points(self.state, *source_spell_id, *effect_index, stacks);

                mods.crit_chance_pct += percent * points;
            }
            BuffEffect::SpellCritDamageFromEffect {
                percent,
                source_spell_id,
                effect_index,
            } if self
                .query
                .affected(self.state, *source_spell_id, *effect_index) =>
            {
                let points = dbc_effect_points(self.state, *source_spell_id, *effect_index, stacks);

                mods.crit_damage_mult *= 1.0 + percent * points / HUNDRED;
            }
            BuffEffect::CritChanceSpells(value, spells) if self.query.listed(spells) => {
                mods.crit_chance_pct += value * stacks;
            }
            BuffEffect::CritDamageSpells(value, spells) if self.query.listed(spells) => {
                mods.crit_damage_mult *= (1.0 + value / HUNDRED).powf(stacks);
            }
            _ => {}
        }
    }

    fn apply_effect_point_damage_modifiers(
        &self,
        active: &[ActiveEffectPointModifier],
        mods: &mut SpellScopedMods,
    ) {
        let data = &self.state.config.game_data;
        let hit_is_periodic = self.query.flags.contains(DamageFlags::PERIODIC);

        for passive_spell_id in data.folded_passive_spells() {
            let passive = *passive_spell_id;

            for passive_effect_index in 1..=data.max_effect_index(passive) {
                let property = data.effect_misc_value_0(passive, passive_effect_index);
                let effect_is_periodic =
                    if modifier_property_is(property, ModifierPropertyKind::GenericDamage) {
                        false
                    } else if modifier_property_is(property, ModifierPropertyKind::PeriodicAmount) {
                        true
                    } else {
                        continue;
                    };

                if effect_is_periodic != hit_is_periodic
                    || !self.query.affected(
                        self.state,
                        passive_spell_id.as_u32(),
                        passive_effect_index,
                    )
                    || aura_subtype_modifier(data.effect_aura(passive, passive_effect_index))
                        .is_none_or(|(operation, _)| operation != ModifierOperation::Percent)
                {
                    continue;
                }

                let initial = data.base_points(passive, passive_effect_index);
                let mut flat = 0.0;
                let mut percent = 1.0;

                for modifier in active.iter().filter(|modifier| {
                    data.effect_affects_spell(
                        wowlab_types::sim::SpellIdx::from_raw(modifier.source_spell_id),
                        modifier.effect_index,
                        passive,
                    )
                }) {
                    let points = dbc_effect_points(
                        self.state,
                        modifier.source_spell_id,
                        modifier.effect_index,
                        modifier.stacks,
                    );

                    match modifier.operation {
                        ModifierOperation::Flat => flat += modifier.value * points,
                        ModifierOperation::Percent => {
                            percent *= 1.0 + modifier.value * points / HUNDRED;
                        }
                        _ => {}
                    }
                }

                let original_factor = 1.0 + initial / HUNDRED;

                if original_factor.abs() <= f64::EPSILON {
                    continue;
                }

                let modified_factor = 1.0 + (initial + flat) * percent / HUNDRED;

                mods.damage_mult *= modified_factor / original_factor;
            }
        }
    }
}

fn damage_source_matches(source: DamageSource, flags: DamageFlags) -> bool {
    match source {
        DamageSource::Player => !flags.intersects(DamageFlags::PET | DamageFlags::GUARDIAN),
        DamageSource::Pet => {
            flags.contains(DamageFlags::PET) && !flags.contains(DamageFlags::GUARDIAN)
        }
        DamageSource::Guardian => flags.contains(DamageFlags::GUARDIAN),
    }
}

pub(crate) fn spell_scoped_mods_for(
    state: &CombatState,
    buf: &DenseBuffer,
    source: wowlab_types::sim::ActorId,
    query: SpellModifierQuery,
    target: Option<wowlab_types::sim::EnemyIdx>,
    now: wowlab_types::sim::SimTime,
) -> SpellScopedMods {
    let mut mods = SpellScopedMods::default();
    let mut effect_point_modifiers = Vec::new();
    let context = SpellModifierContext {
        state,
        buf,
        query,
        target,
        now,
    };

    if query.flags.contains(DamageFlags::AOE)
        && let Some(target) = target
        && let Some(enemy) = state.enemy_definition(target)
    {
        mods.target_damage_mult *=
            1.0 - enemy.creature_aoe_avoidance_pct().clamp(0.0, HUNDRED) / HUNDRED;
    }

    let mut apply_source_effect = |stacks, effect: &BuffEffect| {
        context.apply(stacks, effect, &mut mods);

        if let Some(modifier) = ActiveEffectPointModifier::from_buff(stacks, *effect) {
            effect_point_modifiers.push(modifier);
        }
    };

    let owner = spell_modifier_owner(source);

    if let Some(owner) = owner {
        for_each_active_actor_aura_effect(
            crate::context::ActorView::new(state, buf, owner),
            &mut apply_source_effect,
        );
    }

    if let Some(target) = target {
        for_each_active_target_aura_effect(state, buf, target, |stacks, effect| {
            context.apply(stacks, effect, &mut mods);
            context.apply_incoming_damage(stacks, effect, &mut mods);
        });
    }

    if owner.is_some() {
        for modifier in &state.defs.driver_spell_modifiers {
            if !context.query.listed(modifier.spells) {
                continue;
            }

            let resolved = (modifier.resolve)(crate::HookView {
                state,
                buf,
                target,
                now,
            });

            mods.damage_mult *= resolved.damage_mult;
            mods.target_damage_mult *= resolved.target_damage_mult;
            mods.crit_chance_pct += resolved.crit_chance_pct;
            mods.crit_damage_mult *= resolved.crit_damage_mult;

            // #t(rust_log_in_loop) Each applied driver identity is required for modifier attribution in trace diagnostics.
            tracing::trace!(
                driver_spell_id = modifier.driver_spell_id,
                profile_spell_id = context.query.profile_spell_id,
                effect_spell_id = context.query.effect.spell_id,
                ?resolved,
                "driver-owned spell modifier applied"
            );
        }

        context.apply_effect_point_damage_modifiers(&effect_point_modifiers, &mut mods);
    }

    mods
}

#[cfg(test)]
pub(crate) fn spell_scoped_mods_fixture(
    view: &crate::context::CombatView<'_>,
    spell_id: u32,
    flags: DamageFlags,
) -> SpellScopedMods {
    spell_scoped_mods_for(
        view.state,
        view.buf,
        wowlab_types::sim::ActorId::Player,
        SpellModifierQuery::new(spell_id, DamageEffectRef::new(spell_id, 0), flags),
        view.state.current_target(),
        wowlab_types::sim::SimTime::ZERO,
    )
}