wowlab_engine_combat/systems/auras/

apply.rs

use super::{
    ActorId, AuraKey, Event, HookCtx, LocalAuraIdx, SimTime, SpellGroup, SpellGroupRule,
    application_state, 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, expire_conflicting_auras,
    initialize_or_revive_periodic, is_rolling_periodic, process_health_threshold_application,
    procs, refresh_absorbs, refresh_pet_actions_after_aura_change, refresh_snapshot,
    rolling_ticks_left, sync_exclusive_group_enabled, synchronize_aura_dependents,
    update_aura_slot,
};

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

    ctx.state.schedule(Event::AuraExpire {
        t: expires_at,
        key,
        target: ctx
            .effect_target
            .map_or(ctx.target, |affected| match affected {
                ActorId::Enemy(target) => Some(target),
                ActorId::Player | ActorId::Pet(_) | ActorId::External => None,
            }),
    });
}

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

    ctx.state
        .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
            },
            repeat: 1,
            source: ctx.source,
            target: ctx.target.or_else(|| ctx.state.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) {
    let configured_procs = ctx
        .state
        .defs
        .impact_effect_procs
        .iter()
        .copied()
        .enumerate()
        .filter(|(_, proc)| proc.charge_aura == Some(local) && !proc.uses_stacks_for_charges)
        .map(|(index, proc)| {
            (
                index,
                procs::effective_proc_charges(ctx.state, ctx.buf, ctx.source, proc),
            )
        });
    let resets = configured_procs
        .filter(|(_, charges)| *charges > 0)
        .collect::<Vec<_>>();

    for (index, charges) in resets {
        if let Some(remaining) = ctx.state.runtime.procs.impact_effect_charges.get_mut(index) {
            *remaining = charges;
        }
    }
}

pub(super) fn enqueue_aura_application_proc(
    ctx: &mut HookCtx<'_>,
    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.state
        .runtime
        .deferred_work
        .push_aura_application(crate::state::AuraApplicationEvent {
            aura_spell_id: aura.aura_id,
            source: key.source(),
            affected: key.affected(),
            target: ctx.target,
            // SimC's buff callback passes buff->proc_data, so suppression policy
            // belongs to the applied aura rather than the action that invoked it.
            provenance: crate::state::ProcProvenance::from_spell(
                &ctx.state.config.game_data,
                aura.aura_id,
                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, key, .. } = request;

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

    enqueue_aura_application_proc(ctx, aura, key);
}

pub(super) fn apply_spell_group_rule(
    ctx: &mut HookCtx<'_>,
    local: LocalAuraIdx,
    group: SpellGroup,
) {
    match group.rule {
        SpellGroupRule::Exclusive => {
            expire_conflicting_auras(ctx, local, group.group_idx);
            sync_exclusive_group_enabled(ctx, local, group.group_idx);
        }
    }
}

/// 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;
    }

    // #t(rust_unchecked_indexing) local is validated at build time
    let aura = ctx.state.defs.auras[local.as_usize()];

    if aura_application_blocked(ctx, &aura) {
        return;
    }

    apply_aura_unblocked(ctx, local, duration_ms, rolling_multiplier);

    if aura.application_followup_aura_id != 0
        && let Some(followup) = ctx.state.aura_local(aura.application_followup_aura_id)
    {
        apply_aura_unblocked(ctx, followup, None, 1.0);
    }
}

pub(super) fn aura_application_blocked(ctx: &HookCtx<'_>, aura: &crate::state::AuraData) -> bool {
    for aura_id in aura.application_excluded_auras {
        if aura_id == 0 {
            continue;
        }

        let Some(local) = ctx.state.aura_local(aura_id) else {
            continue;
        };
        let Some(key) = context_aura_key(ctx, local) else {
            continue;
        };

        if ctx
            .buf
            .aura(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.state.defs.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(),
            aura.aura_id,
            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(),
                aura.aura_id,
                periodic.tick_interval_ms,
            );
            let period_ms = crate::systems::buffs::effective_periodic_interval_ms(
                &ctx.view().combat(),
                aura.aura_id,
                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.state, local, ctx.source, ctx.target),
        |affected| aura_keys_for_actor_application(ctx.state, 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<'_>,
    aura_id: u32,
    affected: ActorId,
    base_duration_ms: u32,
) -> (f64, u32) {
    let multiplier =
        crate::systems::buffs::aura_time_rate_multiplier(ctx.view().for_actor(affected), aura_id);
    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)
}

// #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, aura.aura_id, key.affected(), base_dur_ms);

    ctx.buf.ensure_aura_slot(key);

    if aura.refresh_behavior == wowlab_types::data::RefreshBehavior::None
        && ctx
            .buf
            .aura(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.state.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,
        key,
        base_dur_ms,
        base_dur,
        is_permanent,
    };

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

        return true;
    }

    let previous_expiry = ctx
        .buf
        .aura(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.buf.player_mut().shapeshift_form = aura.shapeshift_form;
            tracing::trace!(
                aura_id = aura.aura_id,
                form = aura.shapeshift_form,
                "applied shapeshift form"
            );
        }

        synchronize_aura_dependents(ctx);
        refresh_pet_actions_after_aura_change(ctx.state, ctx.buf, ctx.now);
        enqueue_aura_apply_effects(ctx, aura);
        reset_aura_proc_charges(ctx, local);
        enqueue_aura_application_proc(ctx, aura, key);

        return true;
    }

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

    if let Some(slot) = ctx.buf.aura_mut(key) {
        slot.time_rate_multiplier = 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.state.defs.stealth_aura_id == Some(aura.aura_id) {
        ctx.buf.player_mut().stealthed = 1;
    }

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

    synchronize_aura_dependents(ctx);
    schedule_aura_expiry(ctx, key);
    refresh_pet_actions_after_aura_change(ctx.state, ctx.buf, ctx.now);
    enqueue_aura_apply_effects(ctx, 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
        .buf
        .aura(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 stacks = if let Some(slot) = ctx.buf.aura_mut(key) {
            slot.stacks -= change;

            wowlab_types::numeric::i32_to_u8_saturating(slot.stacks)
        } else {
            return true;
        };

        emit_aura_refresh_event(ctx.state, ctx.sink, key, aura.aura_id, stacks, ctx.now);
        synchronize_aura_dependents(ctx);
        refresh_pet_actions_after_aura_change(ctx.state, ctx.buf, ctx.now);
    }

    true
}