wowlab_engine_combat/handler/

reset.rs

use wowlab_types::sim::{ActorId, SimTime};

use crate::{
    builder::buffer_init::project_initial_encounter,
    state::{CombatInstance, LocalAuraIdx, LocalSpellIdx},
    systems::{
        aura_keys_for_application, initialize_all_spell_costs, reset_cooldown,
        reset_cooldown_for_lifecycle,
    },
};

// #t(fn: rust_max_fn_lines) reset is one auditable exhaustive state transaction.
pub(super) fn reset_combat(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
    last_sync: &mut SimTime,
) {
    state.runtime.total_damage = 0.0;
    state.runtime.resources.last_primary_spent = 0.0;
    state.runtime.resources.last_optional_primary_spent = 0.0;
    state.runtime.resources.last_secondary_spent = 0.0;
    state.runtime.casting.selected_candidate = None;
    state.runtime.casting.active_player_candidate = None;
    state.runtime.casting.instant_cast_pending_at = None;
    state.runtime.casting.instant_off_gcd_casts_at = None;
    state.runtime.casting.instant_off_gcd_spells.clear();
    state.runtime.casting.active_channel_target = None;
    state.runtime.casting.channel_generation = 0;
    state.runtime.casting.active_channel_damage_mult = 1.0;
    state.runtime.casting.active_channel = None;
    state.runtime.casting.active_channel_last_tick = SimTime::ZERO;
    state.runtime.casting.active_channel_tick_interval_ms = 0;
    state.runtime.casting.active_channel_ticks_remaining = 0;
    state.runtime.casting.active_channel_on_last_tick = false;
    state.runtime.casting.active_channel_pushback_count = 0;
    state.runtime.casting.free_action_dispatch_depth = 0;
    state.runtime.casting.channel_chain_spell = None;
    state.runtime.casting.active_casts.clear();
    state.runtime.control.school_lockouts.clear();
    state.runtime.control.movement.clear();
    state.runtime.control.movement_generation.clear();
    state.runtime.control.crowd_control.clear();
    state.runtime.control.diminishing_returns.clear();
    state.runtime.health.player_health.reset();

    for health in state.runtime.health.pet_health.iter_mut().flatten() {
        health.reset();
    }

    state.runtime.health.immunity_windows.clear();
    state.runtime.health.active_absorbs.clear();
    state.runtime.health.next_absorb_application_order = 0;
    state.take_runtime_error();
    *last_sync = SimTime::ZERO;
    state.runtime.pending_events.clear();
    state.runtime.procs.proc_heartbeat_scheduled_at = None;
    state.runtime.deferred_work.clear();
    state.runtime.procs.impact_effect_ready_at.fill(0.0);

    state
        .runtime
        .procs
        .impact_effect_target_ready_at
        .fill(SimTime::ZERO);

    for (remaining, proc) in state
        .runtime
        .procs
        .impact_effect_charges
        .iter_mut()
        .zip(&program.impact_effect_procs)
    {
        *remaining = if proc.uses_stacks_for_charges {
            0
        } else {
            proc.charges
        };
    }

    for rng in &mut state.runtime.procs.impact_effect_rng {
        rng.reset();
    }

    state.runtime.procs.system_rppm_ready_at.fill(SimTime::ZERO);
    state
        .runtime
        .procs
        .proc_category_ready_at_dense
        .fill(SimTime::ZERO);
    state.runtime.procs.proc_counters.fill(0);
    reset_rotation_scratch(state);
    #[cfg(not(feature = "rotation-optimizations"))]
    state.runtime.recharge_rate_mults.fill(1.0);
    state.runtime.pools.residual_damage_pools.clear();
    state.runtime.pools.accumulated_damage_pools.clear();
    state.runtime.pools.rolling_tick_mult.clear();
    state.runtime.pools.async_stack_expiries.clear();
    state.runtime.pools.overkill_absorb_ready_at.clear();
    state.runtime.pools.cooldown_ready_at.clear();
    state.runtime.pools.start_recovery_ready_at.clear();
    state.runtime.pools.cooldown_category_ready_at.clear();
    state.runtime.pools.charge_category_ready_at.clear();
    crate::systems::reset_spell_gates(program, state);
    state.runtime.pending.pending_hook_timers.fill(None);
    state.runtime.pending.pending_spell_impacts.fill(None);

    clear_active_guardians(state);

    state.runtime.companions.guardian_generations.fill(0);
    reset_free_guardian_slots(state);
    state.runtime.companions.pet_actions.fill(None);
    state.runtime.reset_spec_runtime();
    state.reset_enemies(program);
    state.buffer.player_mut().gcd_end = 0.0;
    state.buffer.player_mut().cast_end = 0.0;
    state.buffer.player_mut().channel_end = 0.0;

    for tracker in &mut state.runtime.procs.rppm_trackers {
        tracker.last_attempt_time = 0.0;
        tracker.last_proc_time = 0.0;
        tracker.accumulated_blp = 0.0;
    }

    for tracker in &mut state.runtime.procs.threshold_trackers {
        // NaN sentinel: the first roll randomizes the initial state.
        tracker.accumulated = f64::NAN;
    }

    for accumulator in &mut state.runtime.procs.accumulating_impact_accumulators {
        *accumulator = f64::NAN;
    }

    for attempts in &mut state.runtime.procs.resource_gain_attempts {
        *attempts = 0;
    }

    state.runtime.procs.player_cast_hooks_dispatching = false;
    state.runtime.procs.impact_procs_dispatching = false;
    state.runtime.procs.landed_impact_procs_dispatching = false;
    state.runtime.procs.accumulating_impact_procs_dispatching = false;
    state.runtime.procs.impact_effect_procs_dispatching = false;
    state.runtime.procs.resource_gain_procs_dispatching = false;

    reset_resources(program, state);
    reset_cooldowns_for_lifecycle(program, state);
    reset_channels(program, state);
    program.reset_aura_slots(state, super::AuraResetToken(super::AuraResetScope::All));
    initialize_all_spell_costs(program, state);
    reset_auto_attacks(program, state);
    state.buffer.clear_history();
    state
        .buffer
        .player_mut()
        .set_haste(program.config.base_stats.stats.haste);

    #[cfg(feature = "rotation-optimizations")]
    crate::systems::reset_cooldown_projections(state);

    project_initial_encounter(program, state, SimTime::ZERO);

    #[cfg(feature = "rotation-optimizations")]
    state.runtime.rotation_mutations.clear();

    #[cfg(test)]
    state.reset_projection_flush_count();
}

fn reset_rotation_scratch(state: &mut CombatInstance) {
    if let Some(reasons) = &mut state.runtime.mask_reasons {
        reasons.clear();
    }

    state.runtime.scratch.rotation_masks.clear();
    state.runtime.scratch.locked_action_masks.clear();
    state.runtime.scratch.rotation_candidates.clear();

    if let Some(reasons) = &mut state.runtime.scratch.rotation_trace_reasons {
        reasons.clear();
    }

    #[cfg(test)]
    {
        state.runtime.rotation_spells_scanned = 0;
    }
}

pub(super) fn reset_resources(program: &crate::state::CombatProgram, state: &mut CombatInstance) {
    let resource_type = program.config.base_stats.resource_type;
    let resource_start = program.config.base_stats.resource_start;
    let base_regen = program.config.base_stats.base_regen;
    let secondary_resource_type = program.config.base_stats.secondary_resource_type;

    state.runtime.resources.primary_base_regen_override = None;

    if let Some(rt) = resource_type
        && let Some(handle) = program.resource_binding(rt)
    {
        let res = state.buffer.resource_mut_at(handle);

        if resource_start >= 0.0 {
            res.current = resource_start;
        } else {
            res.current = res.max;
        }

        res.regen_per_sec = base_regen;

        if rt == wowlab_types::combat::ResourceType::Runes {
            state.runtime.resources.runes.reset_to(
                wowlab_types::numeric::f64_to_u32_saturating_round(res.current) as usize,
                SimTime::ZERO,
            );
        }
    }

    if let Some(rt) = secondary_resource_type
        && let Some(res) = program.buffer_resource_mut(state, rt)
    {
        res.current = 0.0;
    }
}

fn reset_channels(program: &crate::state::CombatProgram, state: &mut CombatInstance) {
    for (index, spell) in program.spells.iter().enumerate() {
        if !spell.channel.behavior.is_channel {
            continue;
        }

        let local = LocalSpellIdx::new(
            u8::try_from(index).expect("spell count is finalized below local u8 capacity"),
        );
        let slot = state
            .buffer
            .spell_mut_at(program.buffer_bindings.spell(local));

        slot.is_channeling = 0;
        slot.channel_end = 0.0;
    }
}

fn for_each_resettable_cooldown(
    program: &crate::state::CombatProgram,
    mut reset: impl FnMut(LocalSpellIdx),
) {
    for i in 0..program.spells.len() {
        let Some(spell) = program.spells.get(i).copied() else {
            continue;
        };
        // Draft-time charge registration is frozen in the finalized program.

        if !spell.cooldown.has_cooldown && !spell.is_charged() {
            continue;
        }

        let local = LocalSpellIdx::new(u8::try_from(i).expect("spell count validated below 256"));

        reset(local);
    }
}

pub(super) fn reset_cooldowns(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
    now: SimTime,
) {
    for_each_resettable_cooldown(program, |local| {
        reset_cooldown(program, state, local, now);
    });
}

fn reset_cooldowns_for_lifecycle(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
) {
    for_each_resettable_cooldown(program, |local| {
        reset_cooldown_for_lifecycle(program, state, local);
    });
}

pub(super) fn reset_player_auras(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
) {
    program.reset_aura_slots(state, super::AuraResetToken(super::AuraResetScope::Player));
}

pub(super) fn reset_guardians_between_pulls(
    _program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
) {
    clear_active_guardians(state);
}

fn clear_active_guardians(state: &mut CombatInstance) {
    while let Some(slot) = state.runtime.companions.active_guardian_slots.pop() {
        let index = usize::from(slot);

        // BOUNDS: active slots are inserted only from the finalized guardian arena's free-slot stack.

        if let Some(guardian) = state.runtime.companions.guardians[index].take() {
            let _ = state.deactivate_pet_health(guardian.source);
        }

        state.runtime.companions.free_guardian_slots.push(slot);
    }
}

fn reset_free_guardian_slots(state: &mut CombatInstance) {
    state.runtime.companions.free_guardian_slots.clear();

    for slot in (0..state.runtime.companions.guardians.len()).rev() {
        state
            .runtime
            .companions
            .free_guardian_slots
            .push(u16::try_from(slot).expect("guardian arena fits u16"));
    }
}

fn reset_auto_attacks(program: &crate::state::CombatProgram, state: &mut CombatInstance) {
    for (i, attack) in program.auto_attacks.iter().enumerate() {
        if let Some(sw) = program.buffer_swing_mut(state, i) {
            sw.next_swing_at = if attack.starts_active {
                0.0
            } else {
                f64::INFINITY
            };
        }
    }
}

pub(super) fn set_precombat_aura_stacks(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
    local_idx: LocalAuraIdx,
    stacks: u8,
    target: Option<wowlab_types::sim::EnemyIdx>,
) {
    // Precombat is an explicit application boundary: lock the selected concrete target now.
    let max_stacks = i32::from(program.aura(local_idx).max_stacks);

    for key in aura_keys_for_application(program, state, local_idx, ActorId::Player, target)
        .into_iter()
        .flatten()
    {
        if let Some(binding) = program.aura_binding(local_idx, key) {
            program.mutate_aura(
                state,
                binding,
                crate::state::AuraMutation::SetStacks(i32::from(stacks).min(max_stacks)),
                SimTime::ZERO,
            );
        }
    }

    initialize_all_spell_costs(program, state);
}