wowlab_engine_combat/systems/auras/

apply.rs

use super::{
    ActorId, AuraKey, Event, HookCtx, LocalAuraIdx, SimTime, SpellGroup, SpellGroupRule,
    application_state, apply_exclusive_group_dependencies, async_stacks, attempt_weapon_enchants,
    aura_keys_for_actor_application, aura_keys_for_application, combine_rolling_multiplier,
    context_aura_key, emit_aura_refresh_event, expire_aura_instance, initialize_or_revive_periodic,
    is_rolling_periodic, process_health_threshold_application, procs, refresh_absorbs,
    refresh_snapshot, rolling_ticks_left, update_aura_slot,
};
use crate::state::AuraMutation;

pub(super) fn schedule_aura_expiry(ctx: &mut HookCtx<'_>, local: LocalAuraIdx, key: AuraKey) {
    let expires_at = ctx
        .program
        .buffer_aura(ctx.instance, local, key)
        .map_or(ctx.now, |a| SimTime::from_secs_f64(a.expires_at));

    ctx.instance.schedule(Event::AuraExpire {
        t: expires_at,
        aura: ctx
            .program
            .aura_event(
                local,
                key,
                ctx.effect_target
                    .map_or(ctx.target, |affected| match affected {
                        ActorId::Enemy(target) => Some(target),
                        ActorId::Player | ActorId::Pet(_) | ActorId::External => None,
                    }),
            )
            .expect("applied aura has a finalized event binding"),
    });
}

pub(super) fn enqueue_aura_apply_effects(
    ctx: &mut HookCtx<'_>,
    local: LocalAuraIdx,
    aura: &crate::state::AuraData,
) {
    if aura.apply_effects.len == 0 {
        return;
    }

    ctx.instance
        .runtime
        .deferred_work
        .push_effect(crate::state::PendingEffectProgram {
            effects: aura.apply_effects,
            profile_spell_id: if aura.apply_profile_spell_id == 0 {
                aura.aura_id
            } else {
                aura.apply_profile_spell_id
            },
            profile_action: ctx.program.damage.aura_apply_profile_action(local),
            repeat: 1,
            source: ctx.source,
            target: ctx.target.or_else(|| ctx.instance.current_target()),
            effect_target: ctx.effect_target,
            flags: ctx.source_damage_flags,
            originating_proc_driver_spell_id: if ctx
                .source_damage_flags
                .contains(crate::DamageFlags::PROC)
            {
                ctx.driver_spell_id()
            } else {
                0
            },
        });
}

pub(super) fn reset_aura_proc_charges(ctx: &mut HookCtx<'_>, local: LocalAuraIdx) {
    for index in 0..ctx.program.impact_effect_procs.len() {
        let proc = ctx
            .program
            .impact_effect_procs
            .get(index)
            .copied()
            .expect("bounded impact proc index");

        if proc.charge_aura != Some(local) || proc.uses_stacks_for_charges {
            continue;
        }

        let charges =
            procs::effective_proc_charges(ctx.program, ctx.instance, ctx.source, proc, index);

        if charges == 0 {
            continue;
        }

        if let Some(remaining) = ctx
            .instance
            .runtime
            .procs
            .impact_effect_charges
            .get_mut(index)
        {
            *remaining = charges;
        }
    }
}

pub(super) fn enqueue_aura_application_proc(
    ctx: &mut HookCtx<'_>,
    local: LocalAuraIdx,
    aura: &crate::state::AuraData,
    key: AuraKey,
) {
    let kind = if ctx.source_damage_flags.contains(crate::DamageFlags::PROC) {
        crate::state::ProcSourceKind::Proc
    } else {
        crate::state::ProcSourceKind::Action
    };
    let originating_proc_driver_spell_id = if kind == crate::state::ProcSourceKind::Proc {
        ctx.driver_spell_id()
    } else {
        0
    };

    ctx.instance
        .runtime
        .deferred_work
        .push_aura_application(crate::state::AuraApplicationEvent {
            aura_spell_id: aura.aura_id,
            action: ctx.program.damage.aura_action(local),
            source: key.source(),
            affected: key.affected(),
            target: ctx.target,
            // Proc suppression belongs to the applied aura because the callback uses its proc
            // metadata rather than the action that invoked it.
            provenance: ctx
                .program
                .damage
                .proc_provenance_local(ctx.program.damage.aura_action(local), kind),
            originating_proc_driver_spell_id,
        });
}

pub(super) fn finish_aura_application(
    ctx: &mut HookCtx<'_>,
    request: application_state::AuraSlotRequest<'_>,
    is_fresh: bool,
) {
    let application_state::AuraSlotRequest {
        aura, local, key, ..
    } = request;

    if is_fresh {
        process_health_threshold_application(
            ctx.program,
            ctx.instance,
            key.affected(),
            &aura.effects,
            ctx.now,
        );
    }

    enqueue_aura_application_proc(ctx, local, aura, key);
}

pub(super) fn apply_spell_group_rule(
    ctx: &mut HookCtx<'_>,
    local: LocalAuraIdx,
    group: SpellGroup,
) {
    match group.rule {
        SpellGroupRule::Exclusive => {
            let Some(key) = context_aura_key(ctx, local) else {
                return;
            };
            let Some(binding) = ctx.program.aura_binding(local, key) else {
                return;
            };

            apply_exclusive_group_dependencies(ctx, binding);
        }
    }
}

/// Applies an aura by local index.
pub fn apply_aura(ctx: &mut HookCtx<'_>, local: LocalAuraIdx) {
    apply_aura_with_duration(ctx, local, None);
}

/// Applies a rolling periodic aura with a multiplier for this application's damage.
pub(crate) fn apply_aura_with_rolling_multiplier(
    ctx: &mut HookCtx<'_>,
    local: LocalAuraIdx,
    rolling_multiplier: f64,
) {
    apply_aura_with_options(ctx, local, None, rolling_multiplier);
}

/// Applies an aura with an optional duration override.
pub fn apply_aura_with_duration(
    ctx: &mut HookCtx<'_>,
    local: LocalAuraIdx,
    duration_ms: Option<u32>,
) {
    apply_aura_with_options(ctx, local, duration_ms, 1.0);
}

pub(super) fn apply_aura_with_options(
    ctx: &mut HookCtx<'_>,
    local: LocalAuraIdx,
    duration_ms: Option<u32>,
    rolling_multiplier: f64,
) {
    if !rolling_multiplier.is_finite() || rolling_multiplier <= 0.0 {
        return;
    }

    if aura_application_blocked(ctx, local) {
        return;
    }

    apply_aura_unblocked(ctx, local, duration_ms, rolling_multiplier);

    // BOUNDS: local identities are constructed from this finalized aura table.

    if let Some(followup) = ctx.program.aura_followups[local.as_usize()] {
        apply_aura_unblocked(ctx, followup, None, 1.0);
    }
}

pub(super) fn aura_application_blocked(ctx: &HookCtx<'_>, aura: LocalAuraIdx) -> bool {
    // BOUNDS: local identities are constructed from this finalized aura table.
    for excluded in ctx.program.aura_exclusions[aura.as_usize()] {
        let Some(local) = excluded else {
            continue;
        };
        let Some(key) = context_aura_key(ctx, local) else {
            continue;
        };

        if ctx
            .program
            .buffer_aura(ctx.instance, local, key)
            .is_some_and(|slot| slot.is_active(ctx.now.as_secs_f64()))
        {
            return true;
        }
    }

    false
}

pub(super) fn apply_aura_unblocked(
    ctx: &mut HookCtx<'_>,
    local: LocalAuraIdx,
    duration_ms: Option<u32>,
    rolling_multiplier: f64,
) {
    // #t(rust_unchecked_indexing) local is validated at build time
    let aura = ctx.program.auras[local.as_usize()];

    if let Some(group) = aura.spell_group {
        apply_spell_group_rule(ctx, local, group);
    }

    let unscaled_dur_ms = duration_ms.unwrap_or_else(|| {
        crate::systems::buffs::effective_aura_duration_ms(
            &ctx.view().combat(),
            local,
            aura.base_duration_ms,
        )
    });
    let base_dur_ms = if aura.duration_hasted && unscaled_dur_ms > 0 {
        if let Some(periodic) = aura.periodic {
            let base_period_ms = crate::systems::buffs::effective_periodic_tick_ms(
                &ctx.view().combat(),
                local,
                periodic.tick_interval_ms,
            );
            let period_ms = crate::systems::buffs::effective_periodic_interval_ms(
                &ctx.view().combat(),
                local,
                periodic.tick_interval_ms,
                periodic.hasted_ticks,
            );

            fixed_tick_periodic_duration_ms(unscaled_dur_ms, base_period_ms, period_ms)
        } else {
            let haste = crate::systems::buffs::current_haste_mult(&ctx.view().combat());

            wowlab_types::numeric::f64_to_u32_saturating_round(f64::from(unscaled_dur_ms) / haste)
                .max(1)
        }
    } else {
        unscaled_dur_ms
    };

    let application_keys = ctx.effect_target.map_or_else(
        || aura_keys_for_application(ctx.program, ctx.instance, local, ctx.source, ctx.target),
        |affected| {
            aura_keys_for_actor_application(ctx.program, ctx.instance, local, ctx.source, affected)
        },
    );

    let mut applied = false;

    for key in application_keys.into_iter().flatten() {
        applied |= apply_aura_instance(ctx, local, &aura, key, base_dur_ms, rolling_multiplier);
    }

    if applied && ctx.source == ActorId::Player {
        attempt_weapon_enchants(ctx);
    }
}

pub(super) fn fixed_tick_periodic_duration_ms(
    unscaled_duration_ms: u32,
    base_period_ms: u32,
    period_ms: u32,
) -> u32 {
    unscaled_duration_ms
        .checked_div(base_period_ms)
        .unwrap_or_default()
        .max(1)
        .saturating_mul(period_ms)
}

fn effective_aura_base_duration_ms(
    ctx: &HookCtx<'_>,
    local: LocalAuraIdx,
    affected: ActorId,
    base_duration_ms: u32,
) -> (f64, u32) {
    let multiplier =
        crate::systems::buffs::aura_time_rate_multiplier(ctx.view().for_actor(affected), local);
    let duration_ms = if base_duration_ms == 0 {
        0
    } else {
        wowlab_types::numeric::f64_to_u32_saturating_round(f64::from(base_duration_ms) * multiplier)
            .max(1)
    };

    (multiplier, duration_ms)
}

#[cfg(feature = "rotation-optimizations")]
#[inline]
pub(super) fn aura_time_rate_is_unchanged(
    slot: &wowlab_engine_domain::rotation::AuraSlot,
    desired: f64,
) -> bool {
    slot.is_occupied() && slot.time_rate_multiplier.to_bits() == desired.to_bits()
}

#[inline]
fn set_applied_aura_time_rate(
    ctx: &mut HookCtx<'_>,
    binding: crate::state::program::ConcreteAuraBinding,
    desired: f64,
) {
    #[cfg(feature = "rotation-optimizations")]
    if aura_time_rate_is_unchanged(ctx.instance.buffer.aura_at(binding.handle), desired) {
        return;
    }

    ctx.program.mutate_aura(
        ctx.instance,
        binding,
        AuraMutation::SetTimeRate(desired),
        ctx.now,
    );
}

// #t(fn: rust_cyclomatic_complexity) aura application is one ordered transition across refresh, stack, snapshot, and scheduling policies.
pub(super) fn apply_aura_instance(
    ctx: &mut HookCtx<'_>,
    local: LocalAuraIdx,
    aura: &crate::state::AuraData,
    key: AuraKey,
    base_dur_ms: u32,
    rolling_multiplier: f64,
) -> bool {
    let (time_rate_multiplier, base_dur_ms) =
        effective_aura_base_duration_ms(ctx, local, key.affected(), base_dur_ms);

    if aura.refresh_behavior == wowlab_types::data::RefreshBehavior::None
        && ctx
            .program
            .buffer_aura(ctx.instance, local, key)
            .is_some_and(|slot| slot.is_active(ctx.now.as_secs_f64()))
    {
        return false;
    }

    let base_dur_ms = if let Some(control) = aura.crowd_control {
        let duration = if base_dur_ms == 0 {
            crate::state::CrowdControlDuration::Permanent
        } else {
            crate::state::CrowdControlDuration::Finite(SimTime::from_millis(base_dur_ms))
        };

        match ctx.instance.apply_crowd_control_duration(
            key.affected(),
            control.kind,
            control.diminishing,
            duration,
            ctx.now,
        ) {
            crate::state::CrowdControlApplication::Applied {
                duration: crate::state::CrowdControlDuration::Finite(duration),
                ..
            } => duration.as_millis(),
            crate::state::CrowdControlApplication::Applied {
                duration: crate::state::CrowdControlDuration::Permanent,
                ..
            } => 0,
            crate::state::CrowdControlApplication::Immune => return false,
        }
    } else {
        base_dur_ms
    };
    let base_dur = SimTime::from_millis(base_dur_ms);
    let is_permanent = base_dur_ms == 0;
    let slot_request = application_state::AuraSlotRequest {
        aura,
        local,
        key,
        base_dur_ms,
        base_dur,
        is_permanent,
    };

    if retrigger_unticked_reverse_aura(ctx, local, aura, key) {
        enqueue_aura_application_proc(ctx, local, aura, key);

        return true;
    }

    let previous_expiry = ctx
        .program
        .buffer_aura(ctx.instance, local, key)
        .filter(|slot| slot.is_occupied())
        .map(|slot| slot.expires_at);

    if aura.async_stacks && !is_permanent {
        let is_fresh = async_stacks::apply_async_stacks(ctx, local, key, base_dur_ms, aura.doses);

        initialize_or_revive_periodic(ctx, slot_request, is_fresh, previous_expiry);
        refresh_snapshot(ctx, slot_request);
        refresh_absorbs(ctx, slot_request);

        if aura.shapeshift_form > 0 {
            ctx.instance.buffer.player_mut().shapeshift_form = aura.shapeshift_form;
            tracing::trace!(
                aura_id = aura.aura_id,
                form = aura.shapeshift_form,
                "applied shapeshift form"
            );
        }

        enqueue_aura_apply_effects(ctx, local, aura);
        reset_aura_proc_charges(ctx, local);
        enqueue_aura_application_proc(ctx, local, aura, key);

        return true;
    }

    let rolling_old_ticks_left = if is_rolling_periodic(aura) {
        rolling_ticks_left(ctx, local, key)
    } else {
        0.0
    };
    let Some(is_fresh) = update_aura_slot(ctx, slot_request) else {
        return false;
    };

    if let Some(binding) = ctx.program.aura_binding(local, key) {
        set_applied_aura_time_rate(ctx, binding, time_rate_multiplier);
    }

    initialize_or_revive_periodic(
        ctx,
        slot_request,
        is_fresh
            || aura.refresh_behavior == wowlab_types::data::RefreshBehavior::Clip
            || aura.tick_behavior == crate::state::AuraTickBehavior::Clip,
        previous_expiry,
    );
    refresh_snapshot(ctx, slot_request);
    refresh_absorbs(ctx, slot_request);
    combine_rolling_multiplier(
        ctx,
        slot_request,
        rolling_old_ticks_left,
        rolling_multiplier,
    );

    if ctx.program.stealth_aura == Some(local) {
        ctx.instance.buffer.player_mut().stealthed = 1;
    }

    if aura.shapeshift_form > 0 {
        ctx.instance.buffer.player_mut().shapeshift_form = aura.shapeshift_form;
        tracing::trace!(
            aura_id = aura.aura_id,
            form = aura.shapeshift_form,
            "applied shapeshift form"
        );
    }

    schedule_aura_expiry(ctx, local, key);
    enqueue_aura_apply_effects(ctx, local, aura);
    reset_aura_proc_charges(ctx, local);

    finish_aura_application(ctx, slot_request, is_fresh);

    true
}

pub(super) fn retrigger_unticked_reverse_aura(
    ctx: &mut HookCtx<'_>,
    local: LocalAuraIdx,
    aura: &crate::state::AuraData,
    key: AuraKey,
) -> bool {
    if !aura.reverse || aura.tick_behavior != crate::state::AuraTickBehavior::None {
        return false;
    }

    let Some(current_stacks) = ctx
        .program
        .buffer_aura(ctx.instance, local, key)
        .filter(|slot| slot.is_active(ctx.now.as_secs_f64()))
        .map(|slot| slot.stacks)
    else {
        return false;
    };

    let change = i32::from(aura.doses.max(1));

    if current_stacks <= change {
        expire_aura_instance(ctx, local, key);
    } else {
        let Some(slot) = ctx.program.buffer_aura(ctx.instance, local, key) else {
            return true;
        };
        let stacks = slot.stacks - change;

        if let Some(binding) = ctx.program.aura_binding(local, key) {
            ctx.program.mutate_aura(
                ctx.instance,
                binding,
                AuraMutation::SetStacks(stacks),
                ctx.now,
            );
        }

        let stacks = wowlab_types::numeric::i32_to_u8_saturating(stacks);

        emit_aura_refresh_event(
            ctx.program,
            ctx.instance,
            ctx.sink,
            key,
            aura.aura_id,
            stacks,
            ctx.now,
        );
    }

    true
}