wowlab_engine_combat/systems/damage_pipeline/setup/

spell_modifiers.rs

use wowlab_engine_domain::dbc::{
    ModifierOperation, ModifierPropertyKind, aura_subtype_modifier, modifier_property_is,
};
use wowlab_types::constants::HUNDRED;

#[cfg(feature = "rotation-optimizations")]
use crate::systems::buffs::for_each_active_damage_modifier_for_actions;
#[cfg(not(feature = "rotation-optimizations"))]
use crate::{
    state::EffectFamily,
    systems::buffs::{
        for_each_active_damage_modifier_for_action, for_each_planned_actor_effect_damage_binding,
    },
};
use crate::{
    state::{BuffEffect, CombatInstance, DamageEffectRef, DamageSource},
    systems::{
        buffs::{
            dbc_effect_points, for_each_active_spell_modifier_for_action, 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 SpellModifierProfile {
    external: u32,
    local: crate::state::program::LocalDamageActionIdx,
}

impl SpellModifierProfile {
    pub(crate) const fn new(
        external: u32,
        local: crate::state::program::LocalDamageActionIdx,
    ) -> Self {
        Self { external, local }
    }
}

#[derive(Clone, Copy, Debug)]
pub(crate) struct SpellModifierEffect {
    external: DamageEffectRef,
    local: crate::state::program::LocalDamageEffectIdx,
}

impl SpellModifierEffect {
    pub(crate) const fn new(
        external: DamageEffectRef,
        local: crate::state::program::LocalDamageEffectIdx,
    ) -> Self {
        Self { external, local }
    }
}

#[derive(Clone, Copy, Debug)]
pub(crate) struct SpellModifierQuery {
    profile: SpellModifierProfile,
    effect: SpellModifierEffect,
    flags: DamageFlags,
}

impl SpellModifierQuery {
    pub(crate) const fn new(
        profile: SpellModifierProfile,
        effect: SpellModifierEffect,
        flags: DamageFlags,
    ) -> Self {
        Self {
            profile,
            effect,
            flags,
        }
    }

    fn listed(
        self,
        program: &crate::state::CombatProgram,
        binding: &crate::state::program::FinalizedBuffDamageBinding,
    ) -> bool {
        let effect_action = program.damage.effect_at(self.effect.local).action;

        binding.lists_action(self.profile.local) || binding.lists_action(effect_action)
    }

    fn affected(
        self,
        program: &crate::state::CombatProgram,
        source: crate::state::program::LocalDamageEffectIdx,
    ) -> bool {
        let profile_affected = program
            .damage
            .effect_affects_action(source, self.profile.local);
        let effect_action = program.damage.effect_at(self.effect.local).action;
        let effect_affected = self.profile.external != self.effect.external.spell_id
            && program.damage.effect_affects_action(source, effect_action);

        profile_affected || effect_affected
    }

    fn mechanic_mask(
        self,
        program: &crate::state::CombatProgram,
    ) -> wowlab_engine_domain::dbc::MechanicMask {
        let effect = program.damage.effect_at(self.effect.local).mechanic_mask;

        if effect.is_empty() {
            program.damage.action_at(self.profile.local).mechanic_mask
        } else {
            effect
        }
    }

    fn school_mask(
        self,
        program: &crate::state::CombatProgram,
    ) -> wowlab_engine_domain::dbc::SpellSchoolMask {
        program
            .damage
            .action_at(program.damage.effect_at(self.effect.local).action)
            .school_mask
    }
}

struct SpellModifierContext<'a> {
    program: &'a crate::state::CombatProgram,
    state: &'a CombatInstance,
    query: SpellModifierQuery,
    target: Option<wowlab_types::sim::EnemyIdx>,
    now: wowlab_types::sim::SimTime,
}

#[derive(Clone, Copy)]
struct ActiveEffectPointModifier {
    stacks: f64,
    value: f64,
    source: crate::state::program::LocalDamageEffectIdx,
    operation: ModifierOperation,
}

impl ActiveEffectPointModifier {
    fn from_buff(
        stacks: f64,
        effect: BuffEffect,
        binding: &crate::state::program::FinalizedBuffDamageBinding,
    ) -> Option<Self> {
        let BuffEffect::SpellModifierFromEffect {
            value,
            property: ModifierPropertyKind::Points,
            operation,
            ..
        } = effect
        else {
            return None;
        };

        Some(Self {
            stacks,
            value,
            source: binding.source_effect?,
            operation,
        })
    }
}

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

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

        if *mods != before {
            tracing::trace!(
                profile_spell_id = self.query.profile.external,
                effect_spell_id = self.query.effect.external.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,
        binding: &crate::state::program::FinalizedBuffDamageBinding,
        mods: &mut SpellScopedMods,
    ) {
        match effect {
            BuffEffect::DamageMultSpells(value, _) if self.query.listed(self.program, binding) => {
                mods.damage_mult *= value.powf(stacks);
            }
            BuffEffect::DamageMultSpellsActive(value, _)
                if self.query.listed(self.program, binding) =>
            {
                mods.damage_mult *= value;
            }
            BuffEffect::SpellDamageFromEffect {
                percent,
                source_spell_id,
                effect_index,
                periodic,
            } if *periodic == self.query.flags.contains(DamageFlags::PERIODIC)
                && binding
                    .source_effect
                    .is_some_and(|source| self.query.affected(self.program, source)) =>
            {
                let points = dbc_effect_points(
                    self.program,
                    self.state,
                    binding
                        .source_effect
                        .expect("matched source binding exists"),
                    stacks,
                );

                mods.damage_mult *= 1.0 + percent * points / HUNDRED;
            }
            BuffEffect::DamageMultSpellsLinear(value, _)
                if self.query.listed(self.program, binding) =>
            {
                mods.damage_mult *= 1.0 + value / HUNDRED * stacks;
            }
            BuffEffect::DynamicDamageMultSpells(resolve, _)
                if self.query.listed(self.program, binding) =>
            {
                mods.damage_mult *=
                    resolve(self.program, self.state, self.target, self.now).powf(stacks);
            }
            BuffEffect::DamageToTargetAuraMechanicPercent {
                percent,
                mechanic_mask,
            } if self.target.is_some_and(|target| {
                target_aura_mechanic_mask(self.program, self.state, 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.program))
        {
            mods.target_damage_mult *= (1.0 + percent / HUNDRED).max(0.0).powf(stacks);
        }
    }

    fn apply_target(
        &self,
        stacks: f64,
        effect: &BuffEffect,
        binding: &crate::state::program::FinalizedBuffDamageBinding,
        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)
                && binding
                    .source_effect
                    .is_some_and(|source| self.query.affected(self.program, source)) =>
            {
                let points = dbc_effect_points(
                    self.program,
                    self.state,
                    binding
                        .source_effect
                        .expect("matched source binding exists"),
                    stacks,
                );

                mods.target_damage_mult *= 1.0 + percent / HUNDRED * points;
            }
            BuffEffect::MechanicDamageTakenPercent {
                percent,
                mechanic_mask,
            } if self
                .query
                .mechanic_mask(self.program)
                .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.program)) =>
            {
                mods.target_damage_mult *= (1.0 + percent / HUNDRED).powf(stacks);
            }
            _ => {}
        }
    }

    fn apply_critical(
        &self,
        stacks: f64,
        effect: &BuffEffect,
        binding: &crate::state::program::FinalizedBuffDamageBinding,
        mods: &mut SpellScopedMods,
    ) {
        match effect {
            BuffEffect::SpellCritChanceFromEffect {
                percent,
                source_spell_id,
                effect_index,
            } if binding
                .source_effect
                .is_some_and(|source| self.query.affected(self.program, source)) =>
            {
                let points = dbc_effect_points(
                    self.program,
                    self.state,
                    binding
                        .source_effect
                        .expect("matched source binding exists"),
                    stacks,
                );

                mods.crit_chance_pct += percent * points;
            }
            BuffEffect::SpellCritDamageFromEffect {
                percent,
                source_spell_id,
                effect_index,
            } if binding
                .source_effect
                .is_some_and(|source| self.query.affected(self.program, source)) =>
            {
                let points = dbc_effect_points(
                    self.program,
                    self.state,
                    binding
                        .source_effect
                        .expect("matched source binding exists"),
                    stacks,
                );

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

    fn apply_driver_spell_modifiers(&self, mods: &mut SpellScopedMods) {
        #[cfg(not(feature = "rotation-optimizations"))]
        for (index, modifier) in self.program.driver_spell_modifiers.iter().enumerate() {
            let effect_action = self
                .program
                .damage
                .effect_at(self.query.effect.local)
                .action;

            if !self
                .program
                .damage
                .driver_modifier_lists_action(index, self.query.profile.local)
                && !self
                    .program
                    .damage
                    .driver_modifier_lists_action(index, effect_action)
            {
                continue;
            }

            self.apply_driver_spell_modifier(modifier, mods);
        }

        #[cfg(feature = "rotation-optimizations")]
        {
            let effect_action = self
                .program
                .damage
                .effect_at(self.query.effect.local)
                .action;
            let profile_modifiers = self
                .program
                .damage
                .driver_modifiers_for_action(self.query.profile.local);
            let effect_modifiers = self
                .program
                .damage
                .driver_modifiers_for_action(effect_action);

            for_each_sorted_union(profile_modifiers, effect_modifiers, |index| {
                let modifier = self
                    .program
                    .driver_spell_modifiers
                    .get(index)
                    .expect("driver adjacency references a finalized spell modifier");

                self.apply_driver_spell_modifier(modifier, mods);
            });
        }
    }

    fn apply_driver_spell_modifier(
        &self,
        modifier: &crate::state::DriverSpellModifier,
        mods: &mut SpellScopedMods,
    ) {
        let resolved = (modifier.resolve)(crate::HookView {
            program: self.program,
            instance: self.state,
            target: self.target,
            now: self.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 = self.query.profile.external,
            effect_spell_id = self.query.effect.external.spell_id,
            ?resolved,
            "driver-owned spell modifier applied"
        );
    }

    fn apply_effect_point_damage_modifiers(
        &self,
        owner: wowlab_types::sim::ActorId,
        mods: &mut SpellScopedMods,
    ) {
        #[cfg(not(feature = "rotation-optimizations"))]
        for (coordinate, _) in self.program.damage.folded_passive_effects() {
            self.apply_effect_point_damage_modifier(owner, coordinate, mods);
        }

        #[cfg(feature = "rotation-optimizations")]
        {
            let effect_action = self
                .program
                .damage
                .effect_at(self.query.effect.local)
                .action;
            let profile_effects = self
                .program
                .damage
                .folded_passive_effects_for_action(self.query.profile.local);
            let effect_effects = self
                .program
                .damage
                .folded_passive_effects_for_action(effect_action);

            for_each_sorted_union(profile_effects, effect_effects, |coordinate| {
                self.apply_effect_point_damage_modifier(owner, coordinate, mods);
            });
        }
    }

    fn apply_effect_point_damage_modifier(
        &self,
        owner: wowlab_types::sim::ActorId,
        coordinate: crate::state::program::LocalDamageEffectIdx,
        mods: &mut SpellScopedMods,
    ) {
        let passive_effect = self.program.damage.effect_at(coordinate);
        let hit_is_periodic = self.query.flags.contains(DamageFlags::PERIODIC);
        let property = passive_effect.modifier_property;
        let effect_is_periodic =
            if modifier_property_is(property, ModifierPropertyKind::GenericDamage) {
                false
            } else if modifier_property_is(property, ModifierPropertyKind::PeriodicAmount) {
                true
            } else {
                return;
            };

        if effect_is_periodic != hit_is_periodic
            || !self.query.affected(self.program, coordinate)
            || aura_subtype_modifier(passive_effect.aura_subtype)
                .is_none_or(|(operation, _)| operation != ModifierOperation::Percent)
        {
            return;
        }

        let initial = passive_effect.base_points;
        let mut flat = 0.0;
        let mut percent = 1.0;
        let target = passive_effect.action;

        for_each_active_spell_modifier_for_action(
            crate::context::ActorView::new(self.program, self.state, owner),
            target,
            ModifierPropertyKind::Points,
            |stacks, effect, binding| {
                let Some(modifier) = ActiveEffectPointModifier::from_buff(stacks, *effect, binding)
                else {
                    return;
                };

                let affected = self
                    .program
                    .damage
                    .effect_affects_action(modifier.source, target);

                if !affected {
                    return;
                }

                let points =
                    dbc_effect_points(self.program, self.state, modifier.source, 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 {
            return;
        }

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

        mods.damage_mult *= modified_factor / original_factor;
    }
}

#[cfg(feature = "rotation-optimizations")]
fn for_each_sorted_union<T>(left: &[T], right: &[T], mut visit: impl FnMut(T))
where
    T: Copy + Ord,
{
    let mut left_index = 0;
    let mut right_index = 0;

    while left_index < left.len() || right_index < right.len() {
        let effect = match (left.get(left_index), right.get(right_index)) {
            (Some(&left_effect), Some(&right_effect)) if left_effect < right_effect => {
                left_index += 1;

                left_effect
            }
            (Some(&left_effect), Some(&right_effect)) if right_effect < left_effect => {
                right_index += 1;

                right_effect
            }
            (Some(&effect), Some(_)) => {
                left_index += 1;
                right_index += 1;

                effect
            }
            (Some(&effect), None) => {
                left_index += 1;

                effect
            }
            (None, Some(&effect)) => {
                right_index += 1;

                effect
            }
            (None, None) => break,
        };

        visit(effect);
    }
}

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),
    }
}

fn target_aoe_damage_mult(
    program: &crate::state::CombatProgram,
    query: SpellModifierQuery,
    target: Option<wowlab_types::sim::EnemyIdx>,
) -> f64 {
    if !query.flags.contains(DamageFlags::AOE) {
        return 1.0;
    }

    target
        .and_then(|target| program.enemy_definition(target))
        .map_or(1.0, |enemy| {
            1.0 - enemy.creature_aoe_avoidance_pct().clamp(0.0, HUNDRED) / HUNDRED
        })
}

pub(crate) fn spell_scoped_mods_for(
    program: &crate::state::CombatProgram,
    state: &CombatInstance,
    source: wowlab_types::sim::ActorId,
    query: SpellModifierQuery,
    target: Option<wowlab_types::sim::EnemyIdx>,
    now: wowlab_types::sim::SimTime,
) -> SpellScopedMods {
    if !program.damage.has_spell_modifiers {
        return SpellScopedMods::default();
    }

    let mut mods = SpellScopedMods::default();
    let context = SpellModifierContext {
        program,
        state,
        query,
        target,
        now,
    };

    mods.target_damage_mult *= target_aoe_damage_mult(program, query, target);

    let owner = spell_modifier_owner(source);
    let effect_action = program.damage.effect_at(query.effect.local).action;

    if let Some(owner) = owner {
        #[cfg(feature = "rotation-optimizations")]
        for_each_active_damage_modifier_for_actions(
            crate::context::ActorView::new(program, state, owner),
            query.profile.local,
            effect_action,
            |stacks, effect, binding| context.apply(stacks, effect, binding, &mut mods),
        );

        #[cfg(not(feature = "rotation-optimizations"))]
        if query.profile.local == effect_action {
            for_each_active_damage_modifier_for_action(
                crate::context::ActorView::new(program, state, owner),
                query.profile.local,
                |stacks, effect, binding| context.apply(stacks, effect, binding, &mut mods),
            );
        } else {
            for_each_planned_actor_effect_damage_binding(
                crate::context::ActorView::new(program, state, owner),
                EffectFamily::SPELL_MODIFIER,
                |stacks, effect, binding| context.apply(stacks, effect, binding, &mut mods),
            );
        }
    }

    if let Some(target) = target {
        let target_view = crate::context::ActorView::new(
            program,
            state,
            wowlab_types::sim::ActorId::Enemy(target),
        );

        #[cfg(feature = "rotation-optimizations")]
        for_each_active_damage_modifier_for_actions(
            target_view,
            query.profile.local,
            effect_action,
            |stacks, effect, binding| {
                context.apply(stacks, effect, binding, &mut mods);
                context.apply_incoming_damage(stacks, effect, &mut mods);
            },
        );

        #[cfg(not(feature = "rotation-optimizations"))]
        if query.profile.local == effect_action {
            for_each_active_damage_modifier_for_action(
                target_view,
                query.profile.local,
                |stacks, effect, binding| {
                    context.apply(stacks, effect, binding, &mut mods);
                    context.apply_incoming_damage(stacks, effect, &mut mods);
                },
            );
        } else {
            for_each_planned_actor_effect_damage_binding(
                target_view,
                EffectFamily::SPELL_MODIFIER,
                |stacks, effect, binding| {
                    context.apply(stacks, effect, binding, &mut mods);
                    context.apply_incoming_damage(stacks, effect, &mut mods);
                },
            );
        }
    }

    if let Some(owner) = owner {
        context.apply_driver_spell_modifiers(&mut mods);
        context.apply_effect_point_damage_modifiers(owner, &mut mods);
    }

    mods
}

#[cfg(test)]
pub(crate) fn spell_scoped_mods_fixture(
    view: &crate::context::CombatView<'_>,
    spell_id: u32,
    flags: DamageFlags,
) -> SpellScopedMods {
    let effect = DamageEffectRef::new(spell_id, 0);
    let profile_action = view
        .program
        .damage
        .diagnostic_bind_action(spell_id)
        .expect("spell modifier fixture profile belongs to the finalized program");
    let effect_binding = view
        .program
        .damage
        .diagnostic_bind_effect(effect)
        .expect("spell modifier fixture effect belongs to the finalized program");

    spell_scoped_mods_for(
        view.program,
        view.instance,
        wowlab_types::sim::ActorId::Player,
        SpellModifierQuery::new(
            SpellModifierProfile::new(spell_id, profile_action),
            SpellModifierEffect::new(effect, effect_binding),
            flags,
        ),
        view.instance.current_target(),
        wowlab_types::sim::SimTime::ZERO,
    )
}