wowlab_engine_combat/systems/buffs/

totals.rs

use super::{
    ActorId, ActorView, BuffEffect, BuffTotals, CombatInstance, EnemyIdx, PlayerScalingBuffs,
};

/// Sum all active aura buff contributions, scaled by stack count.
#[must_use]
pub fn buff_totals(
    program: &crate::state::CombatProgram,
    state: &CombatInstance,
    target: Option<EnemyIdx>,
) -> BuffTotals {
    actor_buff_totals(ActorView::new(program, state, ActorId::Player), target)
}

pub(crate) fn actor_buff_totals(view: ActorView<'_>, target: Option<EnemyIdx>) -> BuffTotals {
    let mut totals = cached_static_actor_totals(view, false);

    fold_dynamic_actor_totals(
        view,
        target,
        false,
        wowlab_types::sim::SimTime::ZERO,
        &mut totals,
    );
    trace_actor_buff_totals(view, target, false);

    totals
}

pub(crate) fn actor_only_buff_totals(view: ActorView<'_>, target: Option<EnemyIdx>) -> BuffTotals {
    let mut totals = cached_static_actor_totals(view, true);

    fold_dynamic_actor_totals(
        view,
        target,
        true,
        wowlab_types::sim::SimTime::ZERO,
        &mut totals,
    );
    trace_actor_buff_totals(view, target, true);

    totals
}

pub(crate) fn actor_static_buff_totals(view: ActorView<'_>, actor_only: bool) -> BuffTotals {
    cached_static_actor_totals(view, actor_only)
}

pub(crate) fn player_scaling_buffs(view: &crate::context::CombatView<'_>) -> PlayerScalingBuffs {
    let revision = view.instance.player_scaling_revision();

    if let Some(buffs) = view.instance.cached_player_scaling_buffs(revision) {
        return buffs;
    }

    let buffs = PlayerScalingBuffs::from(cached_static_actor_totals(
        view.for_actor(ActorId::Player),
        false,
    ));

    view.instance.cache_player_scaling_buffs(revision, buffs);

    buffs
}

pub(crate) fn actor_dynamic_damage_mult(
    view: ActorView<'_>,
    target: Option<EnemyIdx>,
    actor_only: bool,
    now: wowlab_types::sim::SimTime,
) -> f64 {
    let mut totals = BuffTotals::default();

    fold_dynamic_actor_totals(view, target, actor_only, now, &mut totals);

    totals.damage_mult
}

fn cached_static_actor_totals(view: ActorView<'_>, actor_only: bool) -> BuffTotals {
    let revision = view.instance.actor_aura_revision(view.actor).unwrap_or(0);
    let owner_revision = view
        .instance
        .actor_aura_revision(ActorId::Player)
        .unwrap_or(0);
    let cached = if actor_only {
        view.instance
            .cached_actor_only_buff_totals(view.actor, revision, owner_revision)
    } else {
        view.instance.cached_actor_buff_totals(view.actor, revision)
    };

    if let Some(totals) = cached {
        return totals;
    }

    let mut totals = BuffTotals::default();

    if view.actor == ActorId::Player {
        for &index in view.program.effects.static_total_passive_driver_indexes() {
            // BOUNDS: effect-plan indexes are finalized from this same passive-driver array.
            let effect = &view.program.passive_driver_effects[index].effect;

            if !matches!(
                effect,
                BuffEffect::DynamicDamageMult(..) | BuffEffect::DynamicRegenPercent(..)
            ) {
                totals.add_scaled(effect, 1.0);
            }
        }
    }

    #[cfg(not(feature = "rotation-optimizations"))]
    for entry in view.program.effects.static_total_actor_effects(view.actor) {
        wowlab_types::bench_metrics::record_aura_slot_visit();
        let slot = view.instance.buffer.aura_at(entry.handle);

        if !slot.is_occupied() || (actor_only && player_has_active_aura(view, entry.local)) {
            continue;
        }

        fold_masked_totals(
            view.program.aura(entry.local),
            entry.static_totals_mask,
            f64::from(slot.stacks),
            &mut totals,
        );
    }

    #[cfg(feature = "rotation-optimizations")]
    for_each_active_static_total_aura(view, |local, mask, stacks| {
        if !actor_only || !player_has_active_aura(view, local) {
            fold_masked_totals(view.program.aura(local), mask, stacks, &mut totals);
        }
    });

    if actor_only {
        view.instance
            .cache_actor_only_buff_totals(view.actor, revision, owner_revision, &totals);
    } else {
        view.instance
            .cache_actor_buff_totals(view.actor, revision, &totals);
    }

    totals
}

fn fold_dynamic_actor_totals(
    view: ActorView<'_>,
    target: Option<EnemyIdx>,
    actor_only: bool,
    now: wowlab_types::sim::SimTime,
    totals: &mut BuffTotals,
) {
    if view.actor == ActorId::Player {
        for &index in view.program.effects.dynamic_total_passive_driver_indexes() {
            // BOUNDS: effect-plan indexes are finalized from this same passive-driver array.
            let effect = &view.program.passive_driver_effects[index].effect;

            fold_dynamic_effect(view, target, 1.0, effect, now, totals);
        }
    }

    #[cfg(not(feature = "rotation-optimizations"))]
    for entry in view.program.effects.dynamic_total_actor_effects(view.actor) {
        wowlab_types::bench_metrics::record_aura_slot_visit();
        let slot = view.instance.buffer.aura_at(entry.handle);

        if !slot.is_occupied() || (actor_only && player_has_active_aura(view, entry.local)) {
            continue;
        }

        let aura = view.program.aura(entry.local);
        let mut mask = entry.dynamic_totals_mask;

        while mask != 0 {
            let position = mask.trailing_zeros() as usize;

            mask &= mask - 1;

            // BOUNDS: dynamic_totals_mask is derived from this aura's fixed effect array.

            if let Some(effect) = aura.effects.get(position).and_then(Option::as_ref) {
                fold_dynamic_effect(view, target, f64::from(slot.stacks), effect, now, totals);
            }
        }
    }

    #[cfg(feature = "rotation-optimizations")]
    for_each_active_total_aura(
        view,
        view.program.effects.dynamic_total_aura_plan(),
        |local, mut mask, stacks| {
            if actor_only && player_has_active_aura(view, local) {
                return;
            }

            let aura = view.program.aura(local);

            while mask != 0 {
                let position = mask.trailing_zeros() as usize;

                mask &= mask - 1;

                if let Some(effect) = aura.effects.get(position).and_then(Option::as_ref) {
                    fold_dynamic_effect(view, target, stacks, effect, now, totals);
                }
            }
        },
    );
}

#[cfg(feature = "rotation-optimizations")]
fn for_each_active_static_total_aura(
    view: ActorView<'_>,
    mut visit: impl FnMut(crate::state::LocalAuraIdx, u16, f64),
) {
    view.instance.for_each_active_static_total_aura(
        view.actor,
        view.program
            .effects
            .static_total_aura_plan()
            .relevant_locals(),
        |local, binding, mask| {
            wowlab_types::bench_metrics::record_aura_slot_visit();
            let slot = view.instance.buffer.aura_at(binding.handle);

            debug_assert!(
                slot.is_occupied(),
                "active static-total aura intersection contains only occupied concrete bindings"
            );

            visit(local, mask, f64::from(slot.stacks));
        },
    );
}

#[cfg(feature = "rotation-optimizations")]
fn for_each_active_total_aura(
    view: ActorView<'_>,
    plan: &crate::state::program::ActiveAuraEffectPlan,
    mut visit: impl FnMut(crate::state::LocalAuraIdx, u16, f64),
) {
    view.instance.for_each_active_aura_intersection(
        view.actor,
        (plan.relevant_locals(), &[]),
        |local, binding| {
            wowlab_types::bench_metrics::record_aura_slot_visit();
            let slot = view.instance.buffer.aura_at(binding.handle);

            debug_assert!(
                slot.is_occupied(),
                "active total-aura intersection contains only occupied concrete bindings"
            );

            visit(local, plan.mask(local), f64::from(slot.stacks));
        },
    );
}

fn fold_masked_totals(
    aura: &crate::state::AuraData,
    mut mask: u16,
    stacks: f64,
    totals: &mut BuffTotals,
) {
    while mask != 0 {
        let position = mask.trailing_zeros() as usize;

        mask &= mask - 1;

        // BOUNDS: the supplied mask is derived from this aura's fixed effect array.

        if let Some(effect) = aura.effects.get(position).and_then(Option::as_ref) {
            totals.add_scaled(effect, stacks);
        }
    }
}

fn fold_dynamic_effect(
    view: ActorView<'_>,
    target: Option<EnemyIdx>,
    stacks: f64,
    effect: &BuffEffect,
    now: wowlab_types::sim::SimTime,
    totals: &mut BuffTotals,
) {
    match effect {
        BuffEffect::DynamicDamageMult(resolve) => {
            totals.damage_mult *= resolve(view.program, view.instance, target, now).powf(stacks);
        }
        BuffEffect::DynamicRegenPercent(resolve) => {
            totals.regen_pct += resolve(view.program, view.instance) * stacks;
        }
        _ => {}
    }
}

fn player_has_active_aura(view: ActorView<'_>, local: crate::state::LocalAuraIdx) -> bool {
    view.program
        .effects
        .owner_duplicate_handles(local)
        .iter()
        .any(|handle| view.instance.buffer.aura_at(*handle).is_occupied())
}

/// Complete per-effect diagnostics deliberately separate from the cached ordinary path.
fn trace_actor_buff_totals(view: ActorView<'_>, target: Option<EnemyIdx>, actor_only: bool) {
    if !tracing::enabled!(tracing::Level::TRACE) {
        return;
    }

    if view.actor == ActorId::Player {
        for driver in &view.program.passive_driver_effects {
            // #t(rust_log_in_loop) trace mode intentionally emits one complete diagnostic per contributing passive driver.
            tracing::trace!(
                driver_spell_id = driver.driver_spell_id,
                ?target,
                effect = ?driver.effect,
                "planned passive buff contribution"
            );
        }
    }

    super::for_each_planned_actor_aura_effect(
        view,
        crate::state::EffectFamily::GENERAL_TOTALS,
        |key, local, stacks, effect| {
            if actor_only && player_has_active_aura(view, local) {
                return;
            }

            // #t(rust_log_in_loop) trace mode intentionally emits one complete diagnostic per active aura effect.
            tracing::trace!(
                aura_id = key.aura().as_u32(),
                ?key,
                stacks,
                ?target,
                scaled = ?effect.scaled(stacks),
                "planned buff contribution"
            );
        },
    );
}

/// Independent uncached recomputation oracle for cache differential tests.
#[cfg(test)]
pub(crate) fn reference_uncached_actor_buff_totals(
    view: ActorView<'_>,
    target: Option<EnemyIdx>,
) -> BuffTotals {
    let mut totals = BuffTotals::default();

    if view.actor == ActorId::Player {
        for driver in &view.program.passive_driver_effects {
            fold_dynamic_effect(
                view,
                target,
                1.0,
                &driver.effect,
                wowlab_types::sim::SimTime::ZERO,
                &mut totals,
            );
            totals.add_scaled(&driver.effect, 1.0);
        }
    }

    for entry in view.program.effects.lifecycle_actor_auras(view.actor) {
        let slot = view.instance.buffer.aura_at(entry.handle);

        if !slot.is_occupied() {
            continue;
        }

        for effect in view.program.aura(entry.local).effects.iter().flatten() {
            fold_dynamic_effect(
                view,
                target,
                f64::from(slot.stacks),
                effect,
                wowlab_types::sim::SimTime::ZERO,
                &mut totals,
            );
            totals.add_scaled(effect, f64::from(slot.stacks));
        }
    }

    totals
}