wowlab_engine_combat/systems/auras/

application_state.rs

//! Aura instance projection, snapshot, refresh, and rolling-periodic state.

use wowlab_engine_domain::{constants::AURA_PANDEMIC_THRESHOLD, rotation::DenseBuffer};
use wowlab_engine_ports::Event;
use wowlab_engine_telemetry::TelemetrySink;
use wowlab_types::{
    constants::MS_PER_SECOND,
    sim::{
        ActorId, AuraIdx, AuraKey, AuraOn, AuraProjectionKey, EnemyIdx, PetIdx, SimTime, SpellIdx,
    },
};

use super::{MAX_AURA_APPLICATION_ACTORS, PERMANENT_AURA_EXPIRES_AT_S, expire_aura};
use crate::{
    context::HookCtx,
    state::{CombatState, DamageEffectRef, LocalAuraIdx, SpellGroup, SpellGroupRule},
    systems::{
        buffs::{self, accumulate_buffs},
        damage_pipeline::{
            DamageFlags, DamageSnapshot, SpellModifierQuery, dynamic_base_powers,
            read_player_stats_for_damage, school_of, spell_scoped_mods_for,
            typed_attack_power_with,
        },
        mastery::MasteryCtx,
        sync_max_charges, sync_player_health_from_stamina, sync_recharge_rates, sync_spell_costs,
        synchronize_active_spell_gates,
    },
};

#[cfg(test)]
pub(super) fn pandemic_carry(base_duration: f64, remaining: f64) -> f64 {
    remaining.min(base_duration * AURA_PANDEMIC_THRESHOLD)
}

pub(super) fn pandemic_carry_ms(base_duration_ms: u32, remaining_ms: u32) -> u32 {
    let carry_limit = wowlab_types::numeric::f64_to_u32_saturating_trunc(
        f64::from(base_duration_ms) * AURA_PANDEMIC_THRESHOLD,
    );

    remaining_ms.min(carry_limit)
}

#[derive(Clone, Copy)]
pub(super) struct AuraSlotRequest<'a> {
    pub aura: &'a crate::state::AuraData,
    pub key: AuraKey,
    pub base_dur_ms: u32,
    pub base_dur: SimTime,
    pub is_permanent: bool,
}

#[inline]
fn resolved_aura_key(aura: &crate::state::AuraData, source: ActorId, affected: ActorId) -> AuraKey {
    AuraKey::new(AuraIdx(aura.aura_id), source, affected, aura.on)
}

#[inline]
pub(crate) fn aura_key_for(
    state: &CombatState,
    local: LocalAuraIdx,
    source: ActorId,
    target: Option<EnemyIdx>,
) -> Option<AuraKey> {
    let aura = state.defs.auras.get(local.as_usize()).copied()?;
    let affected = match aura.on {
        AuraOn::Player => ActorId::Player,
        AuraOn::Target => ActorId::Enemy(target?),
        AuraOn::Pet => ActorId::Pet(match source {
            ActorId::Player => PetIdx::PRIMARY,
            ActorId::Pet(pet) => pet,
            ActorId::External | ActorId::Enemy(_) => return None,
        }),
    };

    Some(resolved_aura_key(&aura, source, affected))
}

pub(crate) fn aura_keys_for_application(
    state: &CombatState,
    local: LocalAuraIdx,
    source: ActorId,
    target: Option<EnemyIdx>,
) -> [Option<AuraKey>; MAX_AURA_APPLICATION_ACTORS] {
    let primary = aura_key_for(state, local, source, target);
    let secondary = state
        .defs
        .auras
        .get(local.as_usize())
        .filter(|aura| aura.propagates_to_pet)
        .map(|aura| {
            AuraKey::new(
                AuraIdx(aura.aura_id),
                source,
                ActorId::Pet(PetIdx::PRIMARY),
                AuraOn::Pet,
            )
        });

    [primary, secondary]
}

pub(crate) fn aura_keys_for_actor_application(
    state: &CombatState,
    local: LocalAuraIdx,
    source: ActorId,
    affected: ActorId,
) -> [Option<AuraKey>; MAX_AURA_APPLICATION_ACTORS] {
    let Some(aura) = state.defs.auras.get(local.as_usize()) else {
        return [None, None];
    };
    let primary = Some(resolved_aura_key(aura, source, affected));
    let secondary = aura.propagates_to_pet.then(|| {
        AuraKey::new(
            AuraIdx(aura.aura_id),
            source,
            ActorId::Pet(PetIdx::PRIMARY),
            AuraOn::Pet,
        )
    });

    [primary, secondary]
}

pub(super) fn aura_query_key_for(
    state: &CombatState,
    local: LocalAuraIdx,
    source: ActorId,
    target: Option<EnemyIdx>,
) -> Option<AuraKey> {
    let aura = state.defs.auras.get(local.as_usize()).copied()?;
    let query_source = if aura.on == AuraOn::Player && matches!(source, ActorId::Pet(_)) {
        ActorId::Player
    } else {
        source
    };

    aura_key_for(state, local, query_source, target)
}

#[inline]
pub(super) fn context_aura_key(ctx: &HookCtx<'_>, local: LocalAuraIdx) -> Option<AuraKey> {
    if let Some(affected) = ctx.effect_target {
        let aura = ctx.state.defs.auras.get(local.as_usize())?;

        return Some(resolved_aura_key(aura, ctx.source, affected));
    }

    aura_key_for(ctx.state, local, ctx.source, ctx.target)
}

fn emit_aura_event(
    state: &CombatState,
    sink: &mut TelemetrySink,
    key: AuraKey,
    now: SimTime,
    emit: impl FnOnce(&mut TelemetrySink, u32, wowlab_engine_telemetry::AuraTelemetryScope),
) {
    emit(sink, now.as_millis(), state.aura_telemetry_scope(key));
}

pub(crate) fn emit_aura_apply_event(
    state: &CombatState,
    sink: &mut TelemetrySink,
    key: AuraKey,
    aura_id: u32,
    stacks: u8,
    now: SimTime,
) {
    emit_aura_event(state, sink, key, now, |sink, at_ms, scope| {
        sink.emit_aura_apply(aura_id, stacks, at_ms, scope);
    });
}

pub(crate) fn emit_aura_refresh_event(
    state: &CombatState,
    sink: &mut TelemetrySink,
    key: AuraKey,
    aura_id: u32,
    stacks: u8,
    now: SimTime,
) {
    emit_aura_event(state, sink, key, now, |sink, at_ms, scope| {
        sink.emit_aura_refresh(aura_id, stacks, at_ms, scope);
    });
}

pub(super) fn emit_aura_expire_event(
    state: &CombatState,
    sink: &mut TelemetrySink,
    key: AuraKey,
    aura_id: u32,
    now: SimTime,
) {
    emit_aura_event(state, sink, key, now, |sink, at_ms, scope| {
        sink.emit_aura_expire(aura_id, at_ms, scope);
    });
}

pub(super) fn exact_key_for_projection(
    projection: AuraProjectionKey,
    current_target: Option<EnemyIdx>,
) -> Option<AuraKey> {
    let (source, affected) = match projection.on() {
        AuraOn::Player => (ActorId::Player, ActorId::Player),
        AuraOn::Target => (ActorId::Player, ActorId::Enemy(current_target?)),
        AuraOn::Pet => {
            let pet = ActorId::Pet(PetIdx::PRIMARY);

            (pet, pet)
        }
    };

    Some(AuraKey::new(
        projection.aura(),
        source,
        affected,
        projection.on(),
    ))
}

/// Refresh every one-way APL category projection from exact runtime aura state.
pub(crate) fn refresh_aura_projections(buf: &mut DenseBuffer, current_target: Option<EnemyIdx>) {
    let projections: Vec<_> = buf.aura_projection_keys().collect();

    for projection in projections {
        let exact = exact_key_for_projection(projection, current_target)
            .and_then(|key| buf.aura(key).copied())
            .unwrap_or_default();

        if let Some(slot) = buf.aura_projection_mut(projection) {
            *slot = exact;
        }
    }
}

// #t(fn: rust_unchecked_indexing) i bounded by state.defs.auras.len()
pub(super) fn expire_conflicting_auras(ctx: &mut HookCtx<'_>, local: LocalAuraIdx, group_idx: u8) {
    let mut to_expire: Vec<LocalAuraIdx> = Vec::with_capacity(ctx.state.defs.auras.len());

    for i in 0..ctx.state.defs.auras.len() {
        let i_local = LocalAuraIdx::new(u8::try_from(i).expect("aura count fits in u8"));

        if i_local == local {
            continue;
        }

        if let Some(group) = ctx.state.defs.auras[i].spell_group {
            if group.group_idx == group_idx {
                let Some(other_key) = context_aura_key(ctx, i_local) else {
                    continue;
                };

                if ctx
                    .buf
                    .aura(other_key)
                    .is_some_and(wowlab_engine_domain::rotation::AuraSlot::is_occupied)
                {
                    to_expire.push(i_local);
                }
            }
        }
    }

    for idx in to_expire {
        expire_aura(ctx, idx);
    }
}

// #t(fn: rust_unchecked_indexing) i bounded by state.defs.spells.len() and auras.len()
pub(super) fn sync_exclusive_group_enabled(
    ctx: &mut HookCtx<'_>,
    applied_aura_local: LocalAuraIdx,
    group_idx: u8,
) {
    for spell in &ctx.state.defs.spells {
        let start = spell.followup_effects.start as usize;
        let len = usize::from(spell.followup_effects.len);
        let followups = (start..start.saturating_add(len)).filter_map(|index| {
            match ctx.state.defs.spell_effects.get(index) {
                Some(crate::state::SpellEffectData::ApplyAura { aura_local }) => Some(*aura_local),
                _ => None,
            }
        });

        for aura_local in spell.applies_aura.into_iter().chain(followups) {
            let aura = &ctx.state.defs.auras[aura_local.as_usize()];
            let Some(SpellGroup {
                group_idx: other_group,
                rule: SpellGroupRule::Exclusive,
            }) = aura.spell_group
            else {
                continue;
            };

            if other_group != group_idx {
                continue;
            }

            let enabled = i32::from(aura_local == applied_aura_local);

            if let Some(s) = ctx.buf.spell_mut(SpellIdx(spell.spell_id)) {
                s.is_enabled = enabled;
            }
        }
    }
}

#[inline]
pub(super) fn refreshed_stacks(aura: &crate::state::AuraData, current: i32) -> i32 {
    let max = i32::from(aura.max_stacks);

    if aura.apply_at_max_stacks {
        max
    } else {
        (current + i32::from(aura.doses)).min(max)
    }
}

pub(crate) fn capture_snapshot_for(
    state: &CombatState,
    buf: &DenseBuffer,
    effect: DamageEffectRef,
    source: ActorId,
    target: Option<EnemyIdx>,
    now: SimTime,
) -> DamageSnapshot {
    let spell_id = effect.spell_id;
    let (crit, vers) = read_player_stats_for_damage(buf);
    let totals = accumulate_buffs(state, buf, target);
    let spell_mods = spell_scoped_mods_for(
        state,
        buf,
        source,
        SpellModifierQuery::new(spell_id, effect, DamageFlags::PERIODIC),
        target,
        now,
    );
    let mastery_mult = target.map_or(1.0, |target| {
        (state.config.mastery_hook)(&MasteryCtx {
            state,
            buf,
            spell_id,
            school: school_of(state, spell_id),
            mastery: buffs::current_mastery_points(&crate::CombatView::new(state, buf)),
            player_crit_pct: crit + totals.crit_pct,
            mastery_spell: state.config.mastery_spell,
            is_periodic: true,
            is_pet: matches!(source, ActorId::Pet(_)),
            source,
            target: Some(target),
            now,
        })
    });

    DamageSnapshot {
        ap: typed_attack_power_with(state, buf, crate::state::WeaponApType::MainHand, &totals),
        sp: dynamic_base_powers(state, buf, &totals).1,
        crit_pct: crit + totals.crit_pct + spell_mods.crit_chance_pct,
        vers_pct: vers + totals.vers_pct,
        mastery_mult,
        damage_mult: totals.damage_mult * spell_mods.damage_mult,
    }
}

#[cfg(test)]
pub(crate) fn capture_snapshot_fixture(
    view: crate::context::HookView<'_>,
    spell_id: u32,
    source: ActorId,
) -> DamageSnapshot {
    capture_snapshot_for(
        view.state,
        view.buf,
        DamageEffectRef::new(spell_id, 0),
        source,
        view.target,
        view.now,
    )
}

pub(super) fn store_stronger_snapshot(
    buf: &mut DenseBuffer,
    key: AuraKey,
    snapshot: DamageSnapshot,
) -> bool {
    let Some(aura) = buf.aura_mut(key) else {
        return false;
    };

    if aura.snapshot_has != 0 && snapshot.damage_mult <= aura.snapshot_damage_mult {
        return false;
    }

    aura.snapshot_has = 1;
    aura.snapshot_ap = snapshot.ap;
    aura.snapshot_sp = snapshot.sp;
    aura.snapshot_crit = snapshot.crit_pct;
    aura.snapshot_vers = snapshot.vers_pct;
    aura.snapshot_mastery_mult = snapshot.mastery_mult;
    aura.snapshot_damage_mult = snapshot.damage_mult;

    true
}

/// Refreshes a snapshot with a persistent damage multiplier without compounding it.
pub(crate) fn refresh_aura_snapshot_multiplier(
    ctx: &mut HookCtx<'_>,
    local: LocalAuraIdx,
    multiplier: f64,
) -> bool {
    // BOUNDS: local indices are created from the registered aura definition table.
    let aura = ctx.state.defs.auras[local.as_usize()];

    if aura.periodic.is_none() || multiplier <= 0.0 {
        return false;
    }

    let Some(key) = context_aura_key(ctx, local) else {
        return false;
    };

    if !ctx
        .buf
        .aura(key)
        .is_some_and(wowlab_engine_domain::rotation::AuraSlot::is_occupied)
    {
        return false;
    }

    if aura.is_snapshot {
        let damage_spell_id = aura.periodic.map_or(aura.aura_id, |periodic| {
            periodic.damage_spell_id_or(aura.aura_id)
        });
        let mut snapshot = capture_snapshot_for(
            ctx.state,
            ctx.buf,
            aura.periodic
                .and_then(|periodic| periodic.effect_ref)
                .unwrap_or_else(|| DamageEffectRef::new(damage_spell_id, 0)),
            ctx.source,
            ctx.target,
            ctx.now,
        );

        snapshot.damage_mult *= multiplier;
        let changed = store_stronger_snapshot(ctx.buf, key, snapshot);

        if changed {
            refresh_aura_projections(ctx.buf, ctx.state.current_target());
        }

        return changed;
    }

    let Some(slot) = ctx.buf.aura_mut(key) else {
        return false;
    };

    if slot.snapshot_has != 0 && multiplier <= slot.snapshot_damage_mult {
        return false;
    }

    slot.snapshot_has = 1;
    slot.snapshot_damage_mult = multiplier;
    refresh_aura_projections(ctx.buf, ctx.state.current_target());

    true
}

pub(super) fn revive_tick_chain(
    ctx: &mut HookCtx<'_>,
    aura: &crate::state::AuraData,
    key: AuraKey,
    previous_expiry: Option<f64>,
) {
    if aura.periodic.is_none() {
        return;
    }

    let Some(a) = ctx.buf.aura_mut(key) else {
        return;
    };

    let terminal_at_previous_expiry = previous_expiry.is_some_and(|expiry| a.next_tick >= expiry);

    if !a.is_occupied()
        || (a.next_tick > ctx.now.as_secs_f64() && !terminal_at_previous_expiry)
        || a.tick_interval <= 0.0
    {
        return;
    }

    let next_tick = SimTime::from_secs_f64(ctx.now.as_secs_f64() + a.tick_interval);

    if next_tick.as_secs_f64() <= a.expires_at {
        a.next_tick = next_tick.as_secs_f64();
        ctx.state.schedule(Event::AuraTick {
            t: next_tick,
            key,
            target: ctx.target,
        });
    }
}

pub(super) fn update_aura_slot(
    ctx: &mut HookCtx<'_>,
    request: AuraSlotRequest<'_>,
) -> Option<bool> {
    let AuraSlotRequest { key, .. } = request;
    let a = ctx.buf.aura_mut(key)?;
    let is_fresh = !a.is_occupied();

    if is_fresh {
        initialize_aura_slot(ctx, request);
    } else {
        refresh_aura_slot(ctx, request);
    }

    Some(is_fresh)
}

pub(super) fn initialize_aura_slot(ctx: &mut HookCtx<'_>, request: AuraSlotRequest<'_>) {
    let AuraSlotRequest {
        aura,
        key,
        base_dur_ms,
        base_dur,
        is_permanent,
    } = request;
    let Some(a) = ctx.buf.aura_mut(key) else {
        return;
    };

    a.expires_at = if is_permanent {
        PERMANENT_AURA_EXPIRES_AT_S
    } else {
        ctx.now.saturating_add(base_dur).as_secs_f64()
    };
    a.stacks = if aura.apply_at_max_stacks {
        i32::from(aura.max_stacks)
    } else {
        i32::from(aura.doses).min(i32::from(aura.max_stacks))
    };
    a.base_duration = f64::from(base_dur_ms) / MS_PER_SECOND;
    a.max_stacks = i32::from(aura.max_stacks);
    let stacks = wowlab_types::numeric::i32_to_u8_saturating(a.stacks);

    emit_aura_apply_event(ctx.state, ctx.sink, key, aura.aura_id, stacks, ctx.now);
}

pub(super) fn refresh_aura_slot(ctx: &mut HookCtx<'_>, request: AuraSlotRequest<'_>) {
    let AuraSlotRequest {
        aura,
        key,
        base_dur_ms,
        base_dur,
        is_permanent,
    } = request;
    let Some(a) = ctx.buf.aura_mut(key) else {
        return;
    };

    if !is_permanent {
        let expires_ms =
            wowlab_types::numeric::f64_to_u32_saturating_trunc(a.expires_at * MS_PER_SECOND);
        let remaining_ms = expires_ms.saturating_sub(ctx.now.as_millis());
        let carry_ms = match aura.refresh_behavior {
            wowlab_types::data::RefreshBehavior::Pandemic => {
                pandemic_carry_ms(base_dur_ms, remaining_ms)
            }
            wowlab_types::data::RefreshBehavior::Extend => remaining_ms,
            wowlab_types::data::RefreshBehavior::Tick => {
                let interval_ms = wowlab_types::numeric::f64_to_u32_saturating_round(
                    a.tick_interval * MS_PER_SECOND,
                );

                if interval_ms == 0 {
                    0
                } else {
                    remaining_ms % interval_ms
                }
            }
            wowlab_types::data::RefreshBehavior::Clip
            | wowlab_types::data::RefreshBehavior::None
            | wowlab_types::data::RefreshBehavior::Duration => 0,
        };
        // docref:start auras-pandemic-carry
        a.expires_at = ctx
            .now
            .saturating_add(base_dur)
            .saturating_add(SimTime::from_millis(carry_ms))
            .as_secs_f64();
        // docref:end auras-pandemic-carry
    }

    a.stacks = refreshed_stacks(aura, a.stacks);
    let stacks = wowlab_types::numeric::i32_to_u8_saturating(a.stacks);

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

pub(super) fn initialize_or_revive_periodic(
    ctx: &mut HookCtx<'_>,
    request: AuraSlotRequest<'_>,
    is_fresh: bool,
    previous_expiry: Option<f64>,
) {
    let AuraSlotRequest {
        aura,
        key,
        base_dur_ms,
        ..
    } = request;

    let Some(periodic) = aura.periodic.as_ref() else {
        return;
    };

    if !is_fresh {
        revive_tick_chain(ctx, aura, key, previous_expiry);

        return;
    }

    let effective_tick_ms = buffs::effective_periodic_tick_ms(
        &ctx.view().combat(),
        aura.aura_id,
        periodic.tick_interval_ms,
    );
    let base_interval_s = f64::from(effective_tick_ms) / MS_PER_SECOND;
    let tick_interval_ms = buffs::effective_periodic_interval_ms(
        &ctx.view().combat(),
        aura.aura_id,
        periodic.tick_interval_ms,
        periodic.hasted_ticks,
    );
    let tick_interval_now = f64::from(tick_interval_ms) / MS_PER_SECOND;

    if let Some(a) = ctx.buf.aura_mut(key) {
        let time_rate = if a.time_rate_multiplier > 0.0 {
            a.time_rate_multiplier
        } else {
            1.0
        };

        a.base_tick_interval = base_interval_s;
        a.tick_interval = tick_interval_now * time_rate;
        a.next_tick = if periodic.tick_on_application {
            ctx.now.as_secs_f64()
        } else {
            ctx.now.as_secs_f64() + tick_interval_now * time_rate
        };
        a.remaining_ticks = wowlab_types::numeric::f64_to_i32_saturating_ceil(
            f64::from(base_dur_ms) / MS_PER_SECOND / tick_interval_now,
        );
    }

    if let Some(a) = ctx.buf.aura(key) {
        ctx.state.schedule(Event::AuraTick {
            t: SimTime::from_secs_f64(a.next_tick),
            key,
            target: ctx.target,
        });
    }
}

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

    if !aura.is_snapshot || aura.periodic.is_none() {
        return;
    }

    let damage_spell_id = aura
        .periodic
        .map_or(aura.aura_id, |p| p.damage_spell_id_or(aura.aura_id));
    let snapshot = capture_snapshot_for(
        ctx.state,
        ctx.buf,
        aura.periodic
            .and_then(|periodic| periodic.effect_ref)
            .unwrap_or_else(|| DamageEffectRef::new(damage_spell_id, 0)),
        ctx.source,
        ctx.target,
        ctx.now,
    );

    store_stronger_snapshot(ctx.buf, key, snapshot);
}

pub(super) fn is_rolling_periodic(aura: &crate::state::AuraData) -> bool {
    aura.periodic.is_some_and(|periodic| {
        matches!(
            periodic.effect,
            crate::state::PeriodicKind::RollingDamageAp { .. }
                | crate::state::PeriodicKind::RollingDamageSp { .. }
        )
    })
}

/// Ticks left on the aura slot at `now`; `0.0` when absent or expired.
pub(super) fn rolling_ticks_left(ctx: &HookCtx<'_>, key: AuraKey) -> f64 {
    ctx.buf.aura(key).map_or(0.0, |slot| {
        if slot.tick_interval <= 0.0 {
            return 0.0;
        }

        ((slot.expires_at - ctx.now.as_secs_f64()) / slot.tick_interval).max(0.0)
    })
}

/// Blends this application into the rolling per-tick multiplier so total damage is preserved without diluting tick value.
pub(super) fn combine_rolling_multiplier(
    ctx: &mut HookCtx<'_>,
    request: AuraSlotRequest<'_>,
    old_ticks_left: f64,
    new_multiplier: f64,
) {
    let AuraSlotRequest {
        aura,
        key,
        base_dur_ms,
        ..
    } = request;

    if !is_rolling_periodic(aura) {
        return;
    }
    // The slot's tick_interval is the cadence ticks actually fire at (haste
    // and cadence modifiers applied) — the same units rolling_ticks_left uses.

    let Some(tick_interval) = ctx
        .buf
        .aura(key)
        .map(|slot| slot.tick_interval)
        .filter(|interval| *interval > 0.0)
    else {
        return;
    };
    let new_base_ticks = f64::from(base_dur_ms) / MS_PER_SECOND / tick_interval;
    let new_ticks_left = rolling_ticks_left(ctx, key);

    ctx.state.runtime.pools.rolling_tick_mult.combine(
        key,
        old_ticks_left,
        new_base_ticks,
        new_ticks_left,
        new_multiplier,
    );
}

pub(super) fn synchronize_aura_dependents(ctx: &mut HookCtx<'_>) {
    refresh_aura_projections(ctx.buf, ctx.state.current_target());
    synchronize_active_spell_gates(ctx.state, ctx.buf);
    sync_spell_costs(ctx.state, ctx.buf);
    sync_player_health_from_stamina(ctx.state, ctx.buf);
    sync_recharge_rates(ctx.state, ctx.buf, ctx.now);
    sync_max_charges(ctx.state, ctx.buf, ctx.now);
    super::reproject_aura_time_rates(ctx);
    super::super::auto_attack::reproject_player_auto_attack_speeds(ctx.state, ctx.buf, ctx.now);
}

pub(super) fn restore_active_shapeshift_form(ctx: &mut HookCtx<'_>) {
    let restored = ctx
        .state
        .defs
        .auras
        .iter()
        .enumerate()
        .rev()
        .find_map(|(index, aura)| {
            if aura.shapeshift_form <= 0 {
                return None;
            }

            let local = LocalAuraIdx::new(u8::try_from(index).ok()?);
            let key = aura_key_for(ctx.state, local, ActorId::Player, None)?;

            ctx.buf
                .aura(key)
                .is_some_and(wowlab_engine_domain::rotation::AuraSlot::is_occupied)
                .then_some(aura.shapeshift_form)
        })
        .unwrap_or(0);

    ctx.buf.player_mut().shapeshift_form = restored;
    tracing::trace!(form = restored, "restored active shapeshift form");
}