wowlab_engine_combat/systems/auras/

stacks.rs

use super::{
    ActorId, CombatInstance, EnemyIdx, Event, HookCtx, LocalAuraIdx, PERMANENT_AURA_EXPIRES_AT_S,
    SimTime, apply_aura, aura_query_key_for, context_aura_key, emit_aura_refresh_event,
    enqueue_aura_application_proc, expire_aura, refreshed_stacks, revive_tick_chain,
};
use crate::state::AuraMutation;

/// Adds a stack without refreshing the expiry deadline.
pub(crate) fn add_aura_stack(ctx: &mut HookCtx<'_>, local: LocalAuraIdx) {
    // #t(rust_unchecked_indexing) local is validated at build time
    let aura = ctx.program.auras[local.as_usize()];
    let Some(key) = context_aura_key(ctx, local) else {
        return;
    };

    if aura.async_stacks
        || !ctx
            .program
            .buffer_aura(ctx.instance, local, key)
            .is_some_and(wowlab_engine_domain::rotation::AuraSlot::is_occupied)
    {
        apply_aura(ctx, local);

        return;
    }

    let Some(slot) = ctx.program.buffer_aura(ctx.instance, local, key) else {
        return;
    };
    let stacks = refreshed_stacks(&aura, slot.stacks);

    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,
    );
    enqueue_aura_application_proc(ctx, local, &aura, key);
}

/// Extends an active non-permanent aura without pandemic recomputation.
///
/// # Panics
///
/// Panics only if finalization supplied an out-of-range local aura identity.
pub fn extend_aura(ctx: &mut HookCtx<'_>, local: LocalAuraIdx, extend_ms: u32) {
    // #t(rust_unchecked_indexing) local is validated at build time
    let aura = ctx.program.auras[local.as_usize()];
    let Some(key) = context_aura_key(ctx, local) else {
        tracing::trace!(
            aura_id = aura.aura_id,
            source = ?ctx.source,
            target = ?ctx.target,
            extend_ms,
            "AURA_EXTEND_NO_CONTEXT_KEY"
        );

        return;
    };

    let (old_expiry, new_expiry, stacks) = {
        let Some(a) = ctx.program.buffer_aura(ctx.instance, local, key) else {
            tracing::trace!(
                aura_id = aura.aura_id,
                key = ?key,
                extend_ms,
                "AURA_EXTEND_MISSING_INSTANCE"
            );

            return;
        };

        if !a.is_occupied() || a.expires_at >= PERMANENT_AURA_EXPIRES_AT_S || extend_ms == 0 {
            tracing::trace!(
                aura_id = aura.aura_id,
                key = ?key,
                occupied = a.is_occupied(),
                expires_at = a.expires_at,
                extend_ms,
                "AURA_EXTEND_INELIGIBLE"
            );

            return;
        }

        let old_expiry = a.expires_at;
        let stacks = wowlab_types::numeric::i32_to_u8_saturating(a.stacks);
        let new_expiry =
            SimTime::from_secs_f64(a.expires_at).saturating_add(SimTime::from_millis(extend_ms));

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

        (old_expiry, new_expiry, stacks)
    };

    tracing::trace!(
        aura_id = aura.aura_id,
        key = ?key,
        old_expiry,
        new_expiry = new_expiry.as_secs_f64(),
        extend_ms,
        "AURA_EXTENDED"
    );

    revive_tick_chain(ctx, local, &aura, key, Some(old_expiry));
    emit_aura_refresh_event(
        ctx.program,
        ctx.instance,
        ctx.sink,
        key,
        aura.aura_id,
        stacks,
        ctx.now,
    );
    ctx.instance.schedule(Event::AuraExpire {
        t: new_expiry,
        aura: ctx
            .program
            .aura_event(local, key, ctx.target)
            .expect("stacked aura has a finalized event binding"),
    });
}

pub(crate) fn reduce_aura(ctx: &mut HookCtx<'_>, local: LocalAuraIdx, reduce_ms: u32) {
    let Some(key) = context_aura_key(ctx, local) else {
        return;
    };
    let Some(active) = ctx.program.buffer_aura(ctx.instance, local, key) else {
        return;
    };

    if !active.is_occupied() || active.expires_at >= PERMANENT_AURA_EXPIRES_AT_S || reduce_ms == 0 {
        return;
    }

    let expiry = SimTime::from_secs_f64(active.expires_at);
    let reduction = SimTime::from_millis(reduce_ms);

    if expiry <= ctx.now.saturating_add(reduction) {
        expire_aura(ctx, local);

        return;
    }

    let new_expiry = expiry.saturating_sub(reduction);
    let stacks = {
        let stacks = wowlab_types::numeric::i32_to_u8_saturating(active.stacks);

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

        stacks
    };

    emit_aura_refresh_event(
        ctx.program,
        ctx.instance,
        ctx.sink,
        key,
        ctx.program.aura(local).aura_id,
        stacks,
        ctx.now,
    );
    ctx.instance.schedule(Event::AuraExpire {
        t: new_expiry,
        aura: ctx
            .program
            .aura_event(local, key, ctx.target)
            .expect("stacked aura has a finalized event binding"),
    });
}

/// Returns whether an aura is active.
#[must_use]
pub fn is_aura_active(
    view: &crate::context::CombatView<'_>,
    local: LocalAuraIdx,
    source: ActorId,
    target: Option<EnemyIdx>,
) -> bool {
    aura_query_key_for(view.program, view.instance, local, source, target)
        .and_then(|key| view.program.buffer_aura(view.instance, local, key))
        .is_some_and(wowlab_engine_domain::rotation::AuraSlot::is_occupied)
}

pub(crate) fn aura_stacks(
    program: &crate::state::CombatProgram,
    state: &CombatInstance,
    local: LocalAuraIdx,
    source: ActorId,
    target: Option<EnemyIdx>,
) -> i32 {
    aura_query_key_for(program, state, local, source, target)
        .and_then(|key| program.buffer_aura(state, local, key))
        .map_or(0, |a| if a.is_occupied() { a.stacks } else { 0 })
}

#[cfg(test)]
pub(crate) fn aura_stacks_by_id(
    program: &crate::state::CombatProgram,
    state: &CombatInstance,
    aura_id: u32,
    source: ActorId,
    target: Option<EnemyIdx>,
) -> i32 {
    program.aura_local(aura_id).map_or(0, |local| {
        aura_stacks(program, state, local, source, target)
    })
}

pub(crate) fn consume_aura(ctx: &mut HookCtx<'_>, local: LocalAuraIdx) -> bool {
    let Some(key) = context_aura_key(ctx, local) else {
        return false;
    };
    let stacks = ctx
        .program
        .buffer_aura(ctx.instance, local, key)
        .map_or(0, |aura| if aura.is_occupied() { aura.stacks } else { 0 });

    if stacks <= 0 {
        return false;
    }
    // BOUNDS: local indices are created from the registered aura definition table.

    let aura = ctx.program.auras[local.as_usize()];

    if aura.on_consume.len > 0 {
        let repeat = wowlab_types::numeric::i32_to_u8_saturating(stacks);

        ctx.instance
            .runtime
            .deferred_work
            .push_effect(crate::state::PendingEffectProgram {
                effects: aura.on_consume,
                profile_spell_id: aura.aura_id,
                profile_action: ctx.program.damage.aura_action(local),
                repeat,
                source: ctx.source,
                target: ctx.target,
                effect_target: ctx.effect_target,
                flags: crate::DamageFlags::empty(),
                originating_proc_driver_spell_id: 0,
            });
    }

    expire_aura(ctx, local);

    true
}

pub(crate) fn consume_aura_stack(ctx: &mut HookCtx<'_>, local: LocalAuraIdx) -> bool {
    let Some(key) = context_aura_key(ctx, local) else {
        return false;
    };
    let Some(active) = ctx.program.buffer_aura(ctx.instance, local, key) else {
        return false;
    };

    if !active.is_occupied() {
        return false;
    }

    let active_stacks = active.stacks;
    let expires = active_stacks <= 1;
    // BOUNDS: local indices are created from the registered aura definition table.
    let aura = ctx.program.auras[local.as_usize()];

    if aura.on_consume.len > 0 {
        ctx.instance
            .runtime
            .deferred_work
            .push_effect(crate::state::PendingEffectProgram {
                effects: aura.on_consume,
                profile_spell_id: aura.aura_id,
                profile_action: ctx.program.damage.aura_action(local),
                repeat: 1,
                source: ctx.source,
                target: ctx.target,
                effect_target: ctx.effect_target,
                flags: crate::DamageFlags::empty(),
                originating_proc_driver_spell_id: 0,
            });
    }

    if expires {
        expire_aura(ctx, local);

        return true;
    }

    if aura.async_stacks {
        let pool = ctx
            .program
            .aura_pool_index(local, key)
            .expect("async aura has a finalized pool binding");

        ctx.instance
            .runtime
            .pools
            .async_stack_expiries
            .remove_oldest(pool);
    }

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

    true
}

/// Consumes up to `count` stacks without refreshing the remaining duration.
pub(crate) fn consume_aura_stacks(ctx: &mut HookCtx<'_>, local: LocalAuraIdx, count: i32) -> i32 {
    let to_consume =
        aura_stacks(ctx.program, ctx.instance, local, ctx.source, ctx.target).min(count.max(0));
    let mut consumed = 0;

    for _ in 0..to_consume {
        if !consume_aura_stack(ctx, local) {
            break;
        }

        consumed += 1;
    }

    consumed
}

/// Drains every stack without expiring the aura or stopping its periodic tick chain.
#[cfg(test)]
pub(crate) fn take_aura_stacks(ctx: &mut HookCtx<'_>, local: LocalAuraIdx) -> i32 {
    // #t(rust_unchecked_indexing) local is validated at build time.
    let aura = ctx.program.auras[local.as_usize()];
    let Some(key) = context_aura_key(ctx, local) else {
        return 0;
    };
    let Some(slot) = ctx.program.buffer_aura(ctx.instance, local, key) else {
        return 0;
    };

    if !slot.is_occupied() {
        return 0;
    }

    let stacks = slot.stacks.max(0);

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

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

    stacks
}