wowlab_engine_combat/handler/

reset.rs

use wowlab_engine_domain::rotation::DenseBuffer;
use wowlab_types::sim::{ActorId, SimTime};

use crate::{
    builder::buffer_init::project_encounter,
    keys::auto_attack_key,
    state::{CombatState, LocalAuraIdx, LocalSpellIdx},
    systems::{aura_keys_for_application, reset_cooldown, sync_spell_costs},
};

pub(super) fn reset_combat(
    state: &mut CombatState,
    buf: &mut DenseBuffer,
    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.instant_cast_pending_at = None;
    state.runtime.casting.instant_off_gcd_casts_at = None;
    state.runtime.casting.instant_off_gcd_spell_ids.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_spell_id = 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_id = 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);

    for target_cooldowns in &mut state.runtime.procs.impact_effect_target_ready_at {
        target_cooldowns.clear();
    }

    for (remaining, proc) in state
        .runtime
        .procs
        .impact_effect_charges
        .iter_mut()
        .zip(&state.defs.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.proc_category_ready_at.clear();
    state.runtime.procs.proc_attempts.clear();
    state.runtime.procs.proc_counters.clear();
    state.runtime.mask_reasons.clear();
    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(state, buf);
    state.runtime.pending.pending_hook_timers.clear();
    state.runtime.pending.pending_spell_impacts.clear();
    let guardian_sources = state
        .runtime
        .companions
        .guardians
        .iter_mut()
        .filter_map(Option::take)
        .map(|guardian| guardian.source)
        .collect::<Vec<_>>();

    for source in guardian_sources {
        let _ = state.deactivate_pet_health(source);
    }

    state.runtime.companions.guardians.clear();
    state.runtime.companions.guardian_generations.clear();
    state.runtime.companions.pet_actions.clear();
    state.runtime.reset_spec_runtime();
    state.reset_enemies();
    buf.player_mut().gcd_end = 0.0;
    buf.player_mut().cast_end = 0.0;
    buf.player_mut().channel_end = 0.0;

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

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

    for proc in &mut state.defs.accumulating_impact_procs {
        proc.accumulator = f64::NAN;
    }

    for proc in &mut state.defs.resource_gain_procs {
        proc.attempts = 0;
    }

    let base_haste = state.config.base_stats.stats.haste;

    reset_resources(state, buf);
    reset_cooldowns(state, buf);
    reset_channels(state, buf);
    reset_auras(buf);
    sync_spell_costs(state, buf);
    reset_auto_attacks(state, buf);
    buf.clear_history();
    buf.player_mut().set_haste(base_haste);

    project_encounter(state, buf, SimTime::ZERO);
}

pub(super) fn reset_resources(state: &mut CombatState, buf: &mut DenseBuffer) {
    let resource_type = state.config.base_stats.resource_type;
    let resource_start = state.config.base_stats.resource_start;
    let base_regen = state.config.base_stats.base_regen;
    let secondary_resource_type = state.config.base_stats.secondary_resource_type;

    state.runtime.resources.primary_base_regen_override = None;

    if let Some(rt) = resource_type {
        if let Some(res) = buf.resource_mut(rt) {
            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 {
        if let Some(res) = buf.resource_mut(rt) {
            res.current = 0.0;
        }
    }
}

fn reset_channels(state: &CombatState, buf: &mut DenseBuffer) {
    for spell in &state.defs.spells {
        if !spell.channel.behavior.is_channel {
            continue;
        }

        if let Some(slot) = buf.spell_mut(wowlab_types::sim::SpellIdx::from_raw(spell.spell_id)) {
            slot.is_channeling = 0;
            slot.channel_end = 0.0;
        }
    }
}

pub(super) fn reset_cooldowns(state: &mut CombatState, buf: &mut DenseBuffer) {
    for i in 0..state.defs.spells.len() {
        let Some(spell) = state.defs.spells.get(i).copied() else {
            continue;
        };
        // Charge registration may mutate definitions after build.

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

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

        reset_cooldown(state, buf, local);
    }
}

fn reset_auras(buf: &mut DenseBuffer) {
    let keys: Vec<_> = buf.aura_keys().collect();

    for key in keys {
        if let Some(a) = buf.aura_mut(key) {
            a.remove();
        }
    }
}

pub(super) fn reset_player_auras(buf: &mut DenseBuffer) {
    let keys: Vec<_> = buf
        .aura_keys()
        .filter(|key| key.affected() == ActorId::Player)
        .collect();

    for key in keys {
        if let Some(aura) = buf.aura_mut(key) {
            aura.remove();
        }
    }
}

pub(super) fn reset_guardians_between_pulls(state: &mut CombatState) {
    let guardian_sources = state
        .runtime
        .companions
        .guardians
        .iter_mut()
        .filter_map(Option::take)
        .map(|guardian| guardian.source)
        .collect::<Vec<_>>();

    for source in guardian_sources {
        let _ = state.deactivate_pet_health(source);
    }
}

fn reset_auto_attacks(state: &CombatState, buf: &mut DenseBuffer) {
    for (i, attack) in state.defs.auto_attacks.iter().enumerate() {
        let key = auto_attack_key(i);

        if let Some(sw) = buf.swing_mut(&key) {
            sw.next_swing_at = if attack.starts_active {
                0.0
            } else {
                f64::INFINITY
            };
        }
    }
}

pub(super) fn set_precombat_aura_stacks(
    state: &CombatState,
    buf: &mut DenseBuffer,
    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(state.aura(local_idx).max_stacks);

    for key in aura_keys_for_application(state, local_idx, ActorId::Player, target)
        .into_iter()
        .flatten()
    {
        buf.ensure_aura_slot(key);

        if let Some(aura) = buf.aura_mut(key) {
            aura.stacks = i32::from(stacks).min(max_stacks);
        }
    }

    crate::systems::refresh_aura_projections(buf, target);
    sync_spell_costs(state, buf);
}