wowlab_engine_combat/systems/auras/

stacks.rs

use super::{
    ActorId, CombatState, DenseBuffer, 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, refresh_aura_projections,
    refreshed_stacks, revive_tick_chain, synchronize_aura_dependents,
};

/// 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.state.defs.auras[local.as_usize()];
    let Some(key) = context_aura_key(ctx, local) else {
        return;
    };

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

        return;
    }

    let stacks = if let Some(slot) = ctx.buf.aura_mut(key) {
        slot.stacks = refreshed_stacks(&aura, slot.stacks);

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

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

pub(crate) fn consume_aura_stack_by_id(ctx: &mut HookCtx<'_>, aura_id: u32) -> bool {
    let Some(&local) = ctx.state.index.aura_by_id.get(&aura_id) else {
        return false;
    };

    consume_aura_stack(ctx, local)
}

/// Extends an active non-permanent aura without pandemic recomputation.
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.state.defs.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.buf.aura_mut(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 new_expiry =
            SimTime::from_secs_f64(a.expires_at).saturating_add(SimTime::from_millis(extend_ms));

        a.expires_at = new_expiry.as_secs_f64();

        (
            old_expiry,
            new_expiry,
            wowlab_types::numeric::i32_to_u8_saturating(a.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, &aura, key, Some(old_expiry));
    refresh_aura_projections(ctx.buf, ctx.state.current_target());

    emit_aura_refresh_event(ctx.state, ctx.sink, key, aura.aura_id, stacks, ctx.now);
    ctx.state.schedule(Event::AuraExpire {
        t: new_expiry,
        key,
        target: ctx.target,
    });
}

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.buf.aura(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 active = ctx.buf.aura_mut(key).expect("active aura disappeared");

        active.expires_at = new_expiry.as_secs_f64();

        wowlab_types::numeric::i32_to_u8_saturating(active.stacks)
    };

    refresh_aura_projections(ctx.buf, ctx.state.current_target());
    emit_aura_refresh_event(
        ctx.state,
        ctx.sink,
        key,
        ctx.state.aura(local).aura_id,
        stacks,
        ctx.now,
    );
    ctx.state.schedule(Event::AuraExpire {
        t: new_expiry,
        key,
        target: ctx.target,
    });
}

/// 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.state, local, source, target)
        .and_then(|key| view.buf.aura(key))
        .is_some_and(wowlab_engine_domain::rotation::AuraSlot::is_occupied)
}

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

pub(crate) fn aura_stacks_by_id(
    state: &CombatState,
    buf: &DenseBuffer,
    aura_id: u32,
    source: ActorId,
    target: Option<EnemyIdx>,
) -> i32 {
    state
        .aura_local(aura_id)
        .map_or(0, |local| aura_stacks(state, buf, local, source, target))
}

#[inline]
pub(crate) fn bypass_aura_active(
    state: &CombatState,
    buf: &DenseBuffer,
    aura_id: u32,
    source: ActorId,
    target: Option<EnemyIdx>,
) -> bool {
    aura_id != 0 && aura_stacks_by_id(state, buf, aura_id, source, target) > 0
}

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
        .buf
        .aura(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.state.defs.auras[local.as_usize()];

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

        ctx.state
            .runtime
            .deferred_work
            .push_effect(crate::state::PendingEffectProgram {
                effects: aura.on_consume,
                profile_spell_id: aura.aura_id,
                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.buf.aura(key) else {
        return false;
    };

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

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

    if aura.on_consume.len > 0 {
        ctx.state
            .runtime
            .deferred_work
            .push_effect(crate::state::PendingEffectProgram {
                effects: aura.on_consume,
                profile_spell_id: aura.aura_id,
                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 {
        ctx.state
            .runtime
            .pools
            .async_stack_expiries
            .remove_oldest(&key);
    }

    if let Some(active) = ctx.buf.aura_mut(key) {
        active.stacks -= 1;
    }

    synchronize_aura_dependents(ctx);

    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.state, ctx.buf, 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.
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.state.defs.auras[local.as_usize()];
    let Some(key) = context_aura_key(ctx, local) else {
        return 0;
    };
    let Some(slot) = ctx.buf.aura_mut(key) else {
        return 0;
    };

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

    let stacks = std::mem::take(&mut slot.stacks).max(0);

    emit_aura_refresh_event(ctx.state, ctx.sink, key, aura.aura_id, 0, ctx.now);
    synchronize_aura_dependents(ctx);

    stacks
}