wowlab_engine_combat/systems/auras/

expire.rs

// #t(file: rust_duplicate_strings) Parallel expiry branches intentionally use the same concrete-binding invariant diagnostic.

use super::{
    ActiveAbsorb, ActorId, AuraKey, BuffEffect, HUNDRED, HookCtx, LocalAuraIdx, SimTime,
    application_state, context_aura_key, emit_aura_expire_event, is_rolling_periodic,
    restore_active_shapeshift_form,
};
use crate::state::AuraMutation;

/// Expires an aura by local index.
pub fn expire_aura(ctx: &mut HookCtx<'_>, local: LocalAuraIdx) {
    let Some(key) = context_aura_key(ctx, local) else {
        return;
    };

    expire_aura_instance(ctx, local, key);
}

pub(super) fn expire_aura_instance(ctx: &mut HookCtx<'_>, local: LocalAuraIdx, key: AuraKey) {
    let Some(binding) = ctx.program.aura_binding(local, key) else {
        return;
    };

    if !ctx.instance.buffer.aura_at(binding.handle).is_occupied() {
        return;
    }

    // #t(rust_unchecked_indexing) local is validated at build time
    let aura = ctx.program.auras[local.as_usize()];
    let changed = ctx
        .program
        .mutate_aura(ctx.instance, binding, AuraMutation::Expire, ctx.now);
    let pool = binding.index().as_usize();

    if matches!(
        aura.periodic.as_ref().map(|periodic| periodic.effect),
        Some(crate::state::PeriodicKind::ResidualDamage)
    ) {
        ctx.instance
            .runtime
            .pools
            .residual_damage_pools
            .remove(pool);
    }

    if is_rolling_periodic(&aura) {
        ctx.instance.runtime.pools.rolling_tick_mult.remove(pool);
    }

    if aura.async_stacks {
        ctx.instance.runtime.pools.async_stack_expiries.remove(pool);
    }

    ctx.instance
        .runtime
        .health
        .active_absorbs
        .retain(|absorb| absorb.key != key);

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

    if aura.shapeshift_form > 0
        && ctx.instance.buffer.player().shapeshift_form == aura.shapeshift_form
    {
        restore_active_shapeshift_form(ctx);
    }

    if let Some(control) = aura.crowd_control {
        synchronize_control_after_aura_expiry(ctx, local, key, control);
    }

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

    if changed && aura.on_expire.is_some() {
        ctx.instance
            .runtime
            .deferred_work
            .push_aura_expire(crate::state::PendingAuraExpireHook {
                key,
                aura: local,
                target: ctx.target,
            });
    }
}

pub(super) fn synchronize_control_after_aura_expiry(
    ctx: &mut HookCtx<'_>,
    expired_local: LocalAuraIdx,
    expired_key: AuraKey,
    control: wowlab_engine_domain::dbc::CrowdControlSemantic,
) {
    let actor = expired_key.affected();
    let mut kind_deadline = None::<crate::state::ControlDeadline>;
    let mut group_deadline = None::<crate::state::ControlDeadline>;

    for peer in ctx
        .program
        .aura_dependencies
        .control_peers(expired_local, actor)
    {
        let slot = ctx.instance.buffer.aura_at(peer.handle);

        if !slot.is_active(ctx.now.as_secs_f64()) {
            continue;
        }

        let deadline = if peer.permanent {
            crate::state::ControlDeadline::Permanent
        } else {
            crate::state::ControlDeadline::At(SimTime::from_secs_f64(slot.expires_at))
        };

        if peer.matches_kind {
            kind_deadline = Some(kind_deadline.map_or(deadline, |current| current.later(deadline)));
        }

        if peer.matches_group {
            group_deadline =
                Some(group_deadline.map_or(deadline, |current| current.later(deadline)));
        }
    }

    let control_key = (actor, control.kind);

    if let Some(deadline) = kind_deadline {
        ctx.instance
            .runtime
            .control
            .crowd_control
            .insert(control_key, deadline);
    } else {
        ctx.instance
            .runtime
            .control
            .crowd_control
            .remove(control_key);
    }

    if control.diminishing != wowlab_engine_domain::dbc::DiminishingGroup::None
        && let Some(dr) = ctx
            .instance
            .runtime
            .control
            .diminishing_returns
            .get_mut((actor, control.diminishing))
    {
        dr.last_control_ends = match group_deadline {
            Some(deadline) => deadline,
            None => crate::state::ControlDeadline::At(ctx.now),
        };
    }
}

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

    #[cfg(feature = "rotation-optimizations")]
    if ctx
        .program
        .effects
        .family_aura_plan(crate::state::EffectFamily::ABSORB)
        .mask(local)
        == 0
    {
        return;
    }

    ctx.instance
        .runtime
        .health
        .active_absorbs
        .retain(|absorb| absorb.key != key);

    let stacks = ctx
        .program
        .buffer_aura(ctx.instance, local, key)
        .map_or(1.0, |slot| f64::from(slot.stacks.max(1)));
    let source = key.source();
    let target = key.affected();
    let mut done_percent = 0.0;
    let mut taken_percent = 0.0;

    crate::systems::buffs::for_each_planned_actor_effect(
        ctx.view().for_actor(source),
        crate::state::EffectFamily::ABSORB,
        |effect_stacks, effect| {
            if let BuffEffect::AbsorbDonePercent(percent) = effect {
                done_percent += percent * effect_stacks;
            }
        },
    );
    crate::systems::buffs::for_each_planned_actor_effect(
        ctx.view().for_actor(target),
        crate::state::EffectFamily::ABSORB,
        |effect_stacks, effect| {
            if let BuffEffect::AbsorbTakenPercent(percent) = effect {
                taken_percent += percent * effect_stacks;
            }
        },
    );
    let multiplier =
        (1.0 + done_percent / HUNDRED).max(0.0) * (1.0 + taken_percent / HUNDRED).max(0.0);
    let pool = ctx
        .program
        .aura_binding(local, key)
        .expect("active aura has a finalized concrete binding")
        .index()
        .as_usize();

    for effect in aura.effects.iter().flatten() {
        let BuffEffect::Absorb(effect) = effect else {
            continue;
        };
        let application_order = ctx.instance.runtime.health.next_absorb_application_order;
        let aura_action = ctx.program.damage.aura_action(local);
        let effect_binding = ctx
            .program
            .damage
            .action_effect(aura_action, effect.effect_index)
            .expect("finalized absorb effect coordinate exists");
        let amount = crate::systems::buffs::active_effect_points(
            ctx.view().for_actor(source),
            effect_binding,
            effect.amount,
        );

        ctx.instance.runtime.health.next_absorb_application_order =
            application_order.saturating_add(1);
        ctx.instance
            .runtime
            .health
            .active_absorbs
            .push(ActiveAbsorb {
                key,
                pool,
                kind: effect.kind,
                schools: effect.schools,
                remaining: amount.max(0.0) * stacks * multiplier,
                high_priority: effect.high_priority,
                overkill_script: effect.overkill_script,
                priority: effect.priority,
                application_order,
            });
    }
}

pub(crate) fn expire_auras_on_actor(ctx: &mut HookCtx<'_>, actor: ActorId) {
    #[cfg(feature = "rotation-optimizations")]
    while let Some(binding) = ctx.instance.pop_first_active_aura_binding(actor) {
        ctx.instance
            .buffer
            .aura_at(binding.handle)
            .is_occupied()
            .then_some(())
            .expect("active aura registry contains only occupied concrete bindings");
        expire_aura_instance(ctx, binding.local, binding.key);
    }

    #[cfg(not(feature = "rotation-optimizations"))]
    {
        // Reset/despawn lifecycle intentionally visits every concrete slot for the actor.
        let aura_count = ctx.program.effects.lifecycle_actor_auras(actor).len();

        for index in 0..aura_count {
            let entry = *ctx
                .program
                .effects
                .lifecycle_actor_auras(actor)
                .get(index)
                .expect("bounded actor aura-effect index");

            if !ctx.instance.buffer.aura_at(entry.handle).is_occupied() {
                continue;
            }

            expire_aura_instance(ctx, entry.local, entry.key);
        }
    }
}