wowlab_engine_combat/systems/cooldowns/

recharge.rs

#[cfg(feature = "rotation-optimizations")]
use super::CooldownReadinessSnapshot;
use super::{
    BuffEffect, CombatInstance, Event, LocalSpellIdx, MS_PER_SECOND, RECHARGE_EPSILON_S, SimTime,
    SpellData, charge_pool_members, charge_pool_owner, consume_charge,
    effective_category_cooldown_ms, effective_cooldown_ms, effective_recharge_ms,
    for_each_planned_player_effect, grant_charges_state, reduce_charged_cooldown, spell_at,
    start_one_charge_category, start_regular_category, sync_charge_pool,
};

fn projected_ready_at(
    program: &crate::state::CombatProgram,
    state: &CombatInstance,
    spell_local: LocalSpellIdx,
) -> SimTime {
    let spell = spell_at(program, spell_local);
    let own = state.runtime.pools.cooldown_ready_at.ready_at(spell_local);
    let category = spell.cooldown.cooldown_category.map_or(SimTime::ZERO, |_| {
        state
            .runtime
            .pools
            .cooldown_category_ready_at
            .ready_at(spell_local)
    });
    let charge_category = (!spell.is_charged())
        .then_some(spell.cooldown.charge_category)
        .flatten()
        .map_or(SimTime::ZERO, |_| {
            state
                .runtime
                .pools
                .charge_category_ready_at
                .ready_at(spell_local)
        });

    own.max(category).max(charge_category)
}

pub(super) fn project_ready_at(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
    spell_local: LocalSpellIdx,
) {
    let spell = spell_at(program, spell_local);
    let pooled = projected_ready_at(program, state, spell_local).as_secs_f64();

    if let Some(cooldown) = program.buffer_cooldown_mut(state, spell_local) {
        // Charged with no charges left: next recharge IS the ready time (keeps `charges > 0 => ready_at <= now`).
        cooldown.ready_at = if spell.is_charged() && cooldown.current_charges <= 0 {
            pooled.max(cooldown.next_charge_at)
        } else {
            pooled
        };
    }
}

pub(super) fn project_members(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
    members: &[LocalSpellIdx],
) {
    for member in members.iter().copied() {
        project_ready_at(program, state, member);
    }
}

fn ignores_charge_cooldown(
    program: &crate::state::CombatProgram,
    state: &CombatInstance,
    spell: &SpellData,
) -> bool {
    let Some(category) = spell.cooldown.charge_category else {
        return false;
    };
    let mut ignored = false;

    for_each_planned_player_effect(
        program,
        state,
        crate::state::EffectFamily::IGNORED_CHARGE_COOLDOWN,
        |_, effect| {
            if matches!(
                effect,
                BuffEffect::IgnoreChargeCooldownCategory(effect_category)
                    if *effect_category == category.raw()
            ) {
                ignored = true;
            }
        },
    );

    ignored
}

fn start_private_cooldown(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
    spell: &SpellData,
    spell_local: LocalSpellIdx,
    cooldown_ms: u32,
    now: SimTime,
) {
    if spell.is_charged() || cooldown_ms == 0 {
        state.runtime.pools.cooldown_ready_at.reset(spell_local);

        return;
    }

    let ready_at = state.runtime.pools.cooldown_ready_at.start_for(
        spell_local,
        now,
        SimTime::from_millis(cooldown_ms),
    );

    state.schedule(Event::CooldownReady {
        t: ready_at,
        spell: program.scheduled_spell(spell_local),
    });
}

pub(crate) fn start_cooldown(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
    spell_local: LocalSpellIdx,
    now: SimTime,
) -> u32 {
    start_cooldown_in_slot(program, state, spell_local, spell_local, now)
}

/// Start `slot_local`'s cooldown timers using `recovery_local`'s own recovery data.
///
/// An aura-332 action replacement shares the base action's slot but keeps its own recovery time.
pub(crate) fn start_cooldown_in_slot(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
    recovery_local: LocalSpellIdx,
    slot_local: LocalSpellIdx,
    now: SimTime,
) -> u32 {
    let spell_local = slot_local;
    let spell = spell_at(program, slot_local);
    let recovery = spell_at(program, recovery_local);
    let charge_members = charge_pool_members(program, spell_local);
    #[cfg(feature = "rotation-optimizations")]
    let charge_readiness_before =
        CooldownReadinessSnapshot::capture(program, state, charge_members.as_slice(), now);
    #[cfg(feature = "rotation-optimizations")]
    let cooldown_category_members: &[LocalSpellIdx] = program
        .cooldown_category_members
        .get(spell_local.as_usize())
        .map_or(&[], Box::as_ref);
    #[cfg(feature = "rotation-optimizations")]
    let category_readiness_before =
        CooldownReadinessSnapshot::capture(program, state, cooldown_category_members, now);
    let charge_owner = charge_pool_owner(program, spell_local);
    let cooldown_local = if spell.is_charged() || spell.cooldown.charge_category.is_some() {
        charge_owner
    } else {
        spell_local
    };
    let (cooldown_ms, cooldown_rate) =
        effective_cooldown_ms(program, state, recovery_local, &recovery);
    let category_cooldown_ms =
        effective_category_cooldown_ms(program, state, recovery_local, &recovery);
    let (recharge_ms, recharge_rate) =
        effective_recharge_ms(program, state, recovery_local, &recovery);
    let ignore_charge_cooldown = ignores_charge_cooldown(program, state, &spell);
    let applied_ms = cooldown_ms
        .max(category_cooldown_ms)
        .max(if spell.cooldown.max_charges > 0 {
            recharge_ms
        } else {
            0
        });

    if let Some(rate) = state
        .runtime
        .recharge_rate_mults
        .get_mut(cooldown_local.as_usize())
    {
        *rate = if spell.is_charged() {
            recharge_rate
        } else {
            cooldown_rate
        };
    }

    start_private_cooldown(program, state, &spell, spell_local, cooldown_ms, now);

    let Some(handle) = program.cooldown_binding(cooldown_local) else {
        return applied_ms;
    };
    let cd = state.buffer.cooldown_mut_at(handle);

    if spell.is_charged() && !ignore_charge_cooldown {
        consume_charge(
            &mut state.runtime.pending_events,
            cd,
            program.scheduled_spell(cooldown_local),
            recharge_ms,
            now,
        );
    } else {
        cd.duration = f64::from(cooldown_ms) / MS_PER_SECOND;
    }

    if spell.is_charged() {
        sync_charge_pool(program, state, charge_owner, charge_members.as_slice());
        project_members(program, state, charge_members.as_slice());
    }

    if !ignore_charge_cooldown {
        start_one_charge_category(
            program,
            state,
            &spell,
            charge_members.as_slice(),
            recharge_ms,
            now,
        );
    }

    start_regular_category(
        program,
        state,
        spell_local,
        &spell,
        category_cooldown_ms,
        now,
    );
    project_ready_at(program, state, spell_local);

    #[cfg(feature = "rotation-optimizations")]
    {
        charge_readiness_before.record(program, state, charge_members.as_slice(), now);
        category_readiness_before.record(program, state, cooldown_category_members, now);
    }

    applied_ms
}

// #t(fn: rust_max_fn_lines) private, category, and charge recovery reductions form one atomic cooldown transition.
pub(crate) fn reduce_cooldown(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
    spell_local: LocalSpellIdx,
    amount_ms: u32,
    now: SimTime,
) {
    let spell = spell_at(program, spell_local);
    let members = charge_pool_members(program, spell_local);
    #[cfg(feature = "rotation-optimizations")]
    let readiness_before =
        CooldownReadinessSnapshot::capture(program, state, members.as_slice(), now);
    #[cfg(feature = "rotation-optimizations")]
    let cooldown_category_members: &[LocalSpellIdx] = program
        .cooldown_category_members
        .get(spell_local.as_usize())
        .map_or(&[], Box::as_ref);
    #[cfg(feature = "rotation-optimizations")]
    let category_readiness_before =
        CooldownReadinessSnapshot::capture(program, state, cooldown_category_members, now);
    let owner = charge_pool_owner(program, spell_local);
    let reduction_s = f64::from(amount_ms) / MS_PER_SECOND;

    if !spell.is_charged() {
        let ready_at_before = state.runtime.pools.cooldown_ready_at.ready_at(spell_local);
        let ready_at_after = state.runtime.pools.cooldown_ready_at.reduce(
            spell_local,
            SimTime::from_millis(amount_ms),
            now,
        );
        let mut category_ready_at_before = SimTime::ZERO;
        let mut category_ready_at_after = SimTime::ZERO;
        let mut category_reduced = false;
        let mut charge_category_ready_at_before = SimTime::ZERO;
        let mut charge_category_ready_at_after = SimTime::ZERO;
        let mut charge_category_reduced = false;

        if spell.cooldown.charge_category.is_some() {
            charge_category_ready_at_before = state
                .runtime
                .pools
                .charge_category_ready_at
                .ready_at(spell_local);
            charge_category_ready_at_after = state.runtime.pools.charge_category_ready_at.reduce(
                spell_local,
                SimTime::from_millis(amount_ms),
                now,
            );

            for member in members.as_slice().iter().copied() {
                state
                    .runtime
                    .pools
                    .charge_category_ready_at
                    .start(member, charge_category_ready_at_after);
            }

            charge_category_reduced = true;

            if charge_category_ready_at_after > now {
                for member in members.as_slice().iter().copied() {
                    state.schedule(Event::CooldownReady {
                        t: charge_category_ready_at_after,
                        spell: program.scheduled_spell(member),
                    });
                }
            }

            project_members(program, state, members.as_slice());
        }

        // Some DBC spells express their entire cooldown through CategoryRecoveryTime and
        // leave RecoveryTime at zero. In that representation the category is the spell's
        // effective cooldown pool, so reducing only the empty private pool is a no-op.

        if spell.cooldown.cooldown_duration_ms == 0
            && spell.cooldown.category_cooldown_duration_ms > 0
            && spell.cooldown.cooldown_category.is_some()
        {
            category_ready_at_before = state
                .runtime
                .pools
                .cooldown_category_ready_at
                .ready_at(spell_local);
            category_ready_at_after = state.runtime.pools.cooldown_category_ready_at.reduce(
                spell_local,
                SimTime::from_millis(amount_ms),
                now,
            );
            category_reduced = true;

            let category_members: &[LocalSpellIdx] = program
                .cooldown_category_members
                .get(spell_local.as_usize())
                .map_or(&[], Box::as_ref);

            for member in category_members.iter().copied() {
                state
                    .runtime
                    .pools
                    .cooldown_category_ready_at
                    .start(member, category_ready_at_after);
            }

            if category_ready_at_after > now {
                for member in category_members.iter().copied() {
                    state.schedule(Event::CooldownReady {
                        t: category_ready_at_after,
                        spell: program.scheduled_spell(member),
                    });
                }
            }

            project_members(program, state, category_members);
        }

        project_ready_at(program, state, spell_local);

        if ready_at_after > now {
            state.schedule(Event::CooldownReady {
                t: ready_at_after,
                spell: program.scheduled_spell(spell_local),
            });
        }

        tracing::trace!(
            spell_id = spell.spell_id,
            amount_ms,
            ready_at_before = ready_at_before.as_secs_f64(),
            ready_at_after = ready_at_after.as_secs_f64(),
            category_reduced,
            category_ready_at_before = category_ready_at_before.as_secs_f64(),
            category_ready_at_after = category_ready_at_after.as_secs_f64(),
            charge_category_reduced,
            charge_category_ready_at_before = charge_category_ready_at_before.as_secs_f64(),
            charge_category_ready_at_after = charge_category_ready_at_after.as_secs_f64(),
            "COOLDOWN_REDUCTION"
        );

        #[cfg(feature = "rotation-optimizations")]
        {
            readiness_before.record(program, state, members.as_slice(), now);
            category_readiness_before.record(program, state, cooldown_category_members, now);
        }

        return;
    }

    let (recharge_ms, _) = effective_recharge_ms(program, state, spell_local, &spell);
    let Some(handle) = program.cooldown_binding(owner) else {
        return;
    };
    let cd = state.buffer.cooldown_mut_at(handle);
    let next_charge_at_before = cd.next_charge_at;
    let charges_before = cd.current_charges;

    reduce_charged_cooldown(
        &mut state.runtime.pending_events,
        cd,
        program.scheduled_spell(owner),
        recharge_ms,
        reduction_s,
        now,
    );
    let next_charge_at_after = cd.next_charge_at;
    let charges_after = cd.current_charges;

    sync_charge_pool(program, state, owner, members.as_slice());
    project_members(program, state, members.as_slice());
    tracing::trace!(
        spell_id = spell.spell_id,
        amount_ms,
        next_charge_at_before,
        next_charge_at_after,
        charges_before,
        charges_after,
        "COOLDOWN_REDUCTION"
    );

    #[cfg(feature = "rotation-optimizations")]
    readiness_before.record(program, state, members.as_slice(), now);
}

fn recharge_cooldown(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
    spell_local: LocalSpellIdx,
    charges: u8,
) {
    if charges == 0 {
        return;
    }

    let spell = spell_at(program, spell_local);

    if spell.is_charged() {
        grant_charges_state(program, state, spell_local, charges);

        return;
    }

    let Some(_) = spell.cooldown.charge_category else {
        reset_cooldown_state(program, state, spell_local);

        return;
    };
    let members = charge_pool_members(program, spell_local);

    state
        .runtime
        .pools
        .charge_category_ready_at
        .reset(spell_local);

    for member in members.as_slice() {
        state.runtime.pools.cooldown_ready_at.reset(*member);
        state.runtime.pools.charge_category_ready_at.reset(*member);
    }

    project_members(program, state, members.as_slice());
}

pub(crate) fn mutate_cooldown(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
    spell_local: LocalSpellIdx,
    operation: wowlab_engine_domain::dbc::CooldownMutation,
    now: SimTime,
) {
    match operation {
        wowlab_engine_domain::dbc::CooldownMutation::ReduceRemaining { amount_ms } => {
            reduce_cooldown(program, state, spell_local, amount_ms, now);
        }
        wowlab_engine_domain::dbc::CooldownMutation::Recharge { charges } => {
            #[cfg(feature = "rotation-optimizations")]
            let members = charge_pool_members(program, spell_local);
            #[cfg(feature = "rotation-optimizations")]
            let readiness_before =
                CooldownReadinessSnapshot::capture(program, state, members.as_slice(), now);

            recharge_cooldown(program, state, spell_local, charges);

            #[cfg(feature = "rotation-optimizations")]
            readiness_before.record(program, state, members.as_slice(), now);
        }
    }
}

pub(crate) fn reset_cooldown(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
    spell_local: LocalSpellIdx,
    _now: SimTime,
) {
    #[cfg(feature = "rotation-optimizations")]
    let members = charge_pool_members(program, spell_local);
    #[cfg(feature = "rotation-optimizations")]
    let readiness_before =
        CooldownReadinessSnapshot::capture(program, state, members.as_slice(), _now);

    reset_cooldown_state(program, state, spell_local);

    #[cfg(feature = "rotation-optimizations")]
    readiness_before.record(program, state, members.as_slice(), _now);
}

pub(crate) fn reset_cooldown_for_lifecycle(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
    spell_local: LocalSpellIdx,
) {
    reset_cooldown_state(program, state, spell_local);
}

fn reset_cooldown_state(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
    spell_local: LocalSpellIdx,
) {
    let spell = spell_at(program, spell_local);
    let members = charge_pool_members(program, spell_local);
    let owner = charge_pool_owner(program, spell_local);
    let target_local = if spell.is_charged() {
        owner
    } else {
        spell_local
    };

    if spell
        .cooldown
        .charge_category
        .as_ref()
        .is_some_and(|_| !spell.is_charged())
    {
        for member in members.as_slice() {
            state.runtime.pools.cooldown_ready_at.reset(*member);
            state.runtime.pools.charge_category_ready_at.reset(*member);
        }
    } else {
        state.runtime.pools.cooldown_ready_at.reset(spell_local);
    }

    let Some(handle) = program.cooldown_binding(target_local) else {
        return;
    };
    let cd = state.buffer.cooldown_mut_at(handle);

    // Rehydrate the complete runtime slot from the immutable finalized spell definition.

    if spell.is_charged() {
        let recharge_s = f64::from(spell.cooldown.recharge_ms) / MS_PER_SECOND;

        cd.duration = recharge_s;
        cd.current_charges = i32::from(spell.cooldown.max_charges);
        cd.max_charges = i32::from(spell.cooldown.max_charges);
        cd.next_charge_at = 0.0;
        cd.recharge_time = recharge_s;
    } else {
        cd.duration = f64::from(spell.cooldown.cooldown_duration_ms) / MS_PER_SECOND;
        cd.max_charges = i32::from(spell.cooldown.max_charges);
    }

    if spell.is_charged() {
        sync_charge_pool(program, state, owner, members.as_slice());
        project_members(program, state, members.as_slice());
    } else if spell.cooldown.charge_category.is_some() {
        project_members(program, state, members.as_slice());
    } else {
        project_ready_at(program, state, spell_local);
    }
}

pub(crate) fn check_recharge(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
    spell_local: LocalSpellIdx,
    now: SimTime,
) {
    let spell = spell_at(program, spell_local);

    if !spell.is_charged() {
        return;
    }

    let members = charge_pool_members(program, spell_local);
    let owner = charge_pool_owner(program, spell_local);

    if spell_local != owner {
        return;
    }

    #[cfg(feature = "rotation-optimizations")]
    let readiness_before =
        CooldownReadinessSnapshot::capture(program, state, members.as_slice(), now);

    let (recharge_ms, recharge_rate) = effective_recharge_ms(program, state, spell_local, &spell);
    let recharge_duration_s = f64::from(recharge_ms) / MS_PER_SECOND;

    if let Some(rate) = state.runtime.recharge_rate_mults.get_mut(owner.as_usize()) {
        *rate = recharge_rate;
    }

    let scheduled_spell = program.scheduled_spell(owner);

    let Some(handle) = program.cooldown_binding(owner) else {
        return;
    };
    let cd = state.buffer.cooldown_mut_at(handle);

    let charges = cd.current_charges;
    // The slot max is authoritative: live auras can raise it above the def max.
    let max = cd.max_charges;

    if charges >= max {
        return;
    }

    if now.as_secs_f64() + RECHARGE_EPSILON_S < cd.next_charge_at {
        return;
    }

    let new_charges = charges + 1;
    // Re-arm below maximum or later charges never recover.
    let next_at = if new_charges < max {
        cd.duration = recharge_duration_s;
        cd.recharge_time = recharge_duration_s;
        let next_ready = now.saturating_add(SimTime::from_millis(recharge_ms));

        state.runtime.pending_events.push(Event::CooldownReady {
            t: next_ready,
            spell: scheduled_spell,
        });

        next_ready.as_secs_f64()
    } else {
        0.0
    };

    cd.current_charges = new_charges;
    cd.next_charge_at = next_at;
    sync_charge_pool(program, state, owner, members.as_slice());

    #[cfg(feature = "rotation-optimizations")]
    readiness_before.record(program, state, members.as_slice(), now);
}