wowlab_engine_combat/systems/cooldowns/

recharge.rs

use super::{
    BuffEffect, CombatState, DenseBuffer, 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_active_aura_effect, grant_charges, reduce_charged_cooldown, spell_at,
    start_one_charge_category, start_regular_category, sync_charge_pool,
};

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

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

pub(super) fn project_ready_at(
    state: &CombatState,
    buf: &mut DenseBuffer,
    spell_local: LocalSpellIdx,
) {
    let spell = spell_at(state, spell_local);
    let pooled = projected_ready_at(state, spell_local).as_secs_f64();

    if let Some(cooldown) = buf.cooldown_mut(spell.idx()) {
        // 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(
    state: &CombatState,
    buf: &mut DenseBuffer,
    members: &[LocalSpellIdx],
) {
    for member in members.iter().copied() {
        project_ready_at(state, buf, member);
    }
}

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

    for_each_active_aura_effect(state, buf, |_, effect| {
        if matches!(
            effect,
            BuffEffect::IgnoreChargeCooldownCategory(effect_category)
                if *effect_category == category.raw()
        ) {
            ignored = true;
        }
    });

    ignored
}

fn start_private_cooldown(
    state: &mut CombatState,
    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,
        cooldown_key: spell.idx(),
    });
}

pub(crate) fn start_cooldown(
    state: &mut CombatState,
    buf: &mut DenseBuffer,
    spell_local: LocalSpellIdx,
    now: SimTime,
) -> u32 {
    start_cooldown_in_slot(state, buf, 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.
/// `SimC` hands it the base's shared `cooldown_t` (`sc_demon_hunter.cpp:6927`).
/// It then writes the executing spell's own duration in on every cast (`:7002`).
pub(crate) fn start_cooldown_in_slot(
    state: &mut CombatState,
    buf: &mut DenseBuffer,
    recovery_local: LocalSpellIdx,
    slot_local: LocalSpellIdx,
    now: SimTime,
) -> u32 {
    let spell_local = slot_local;
    let spell = spell_at(state, slot_local);
    let recovery = spell_at(state, recovery_local);
    let charge_members = charge_pool_members(state, spell_local);
    let charge_owner = charge_pool_owner(state, spell_local);
    let cooldown_local = if spell.is_charged() || spell.cooldown.charge_category.is_some() {
        charge_owner
    } else {
        spell_local
    };
    let cooldown_spell = spell_at(state, cooldown_local);
    let idx = cooldown_spell.idx();
    let (cooldown_ms, cooldown_rate) = effective_cooldown_ms(state, buf, &recovery);
    let category_cooldown_ms = effective_category_cooldown_ms(state, buf, &recovery);
    let (recharge_ms, recharge_rate) = effective_recharge_ms(state, buf, &recovery);
    let ignore_charge_cooldown = ignores_charge_cooldown(state, buf, &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(state, &spell, spell_local, cooldown_ms, now);

    let Some(cd) = buf.cooldown_mut(idx) else {
        return applied_ms;
    };

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

    if spell.is_charged() {
        sync_charge_pool(state, buf, charge_owner, &charge_members);
        project_members(state, buf, &charge_members);
    }

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

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

    applied_ms
}

pub(crate) fn reduce_cooldown(
    state: &mut CombatState,
    buf: &mut DenseBuffer,
    spell_local: LocalSpellIdx,
    amount_ms: u32,
    now: SimTime,
) {
    let spell = spell_at(state, spell_local);
    let members = charge_pool_members(state, spell_local);
    let owner = charge_pool_owner(state, 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 let Some(category) = spell.cooldown.charge_category {
            charge_category_ready_at_before = state
                .runtime
                .pools
                .charge_category_ready_at
                .ready_at(&category);
            charge_category_ready_at_after = state.runtime.pools.charge_category_ready_at.reduce(
                category,
                SimTime::from_millis(amount_ms),
                now,
            );
            charge_category_reduced = true;

            if charge_category_ready_at_after > now {
                for member in members.iter().copied() {
                    state.schedule(Event::CooldownReady {
                        t: charge_category_ready_at_after,
                        cooldown_key: spell_at(state, member).idx(),
                    });
                }
            }

            project_members(state, buf, &members);
        }

        // 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
            && let Some(category) = spell.cooldown.cooldown_category
        {
            category_ready_at_before = state
                .runtime
                .pools
                .cooldown_category_ready_at
                .ready_at(&category);
            category_ready_at_after = state.runtime.pools.cooldown_category_ready_at.reduce(
                category,
                SimTime::from_millis(amount_ms),
                now,
            );
            category_reduced = true;

            let category_members = state.index.cooldown_categories.members(&category).to_vec();

            if category_ready_at_after > now {
                for member in category_members.iter().copied() {
                    state.schedule(Event::CooldownReady {
                        t: category_ready_at_after,
                        cooldown_key: spell_at(state, member).idx(),
                    });
                }
            }

            project_members(state, buf, &category_members);
        }

        project_ready_at(state, buf, spell_local);

        if ready_at_after > now {
            state.schedule(Event::CooldownReady {
                t: ready_at_after,
                cooldown_key: spell.idx(),
            });
        }

        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"
        );

        return;
    }

    let owner_spell = spell_at(state, owner);
    let (recharge_ms, _) = effective_recharge_ms(state, buf, &spell);
    let Some(cd) = buf.cooldown_mut(owner_spell.idx()) else {
        return;
    };
    let next_charge_at_before = cd.next_charge_at;
    let charges_before = cd.current_charges;

    reduce_charged_cooldown(state, cd, owner_spell.idx(), recharge_ms, reduction_s, now);
    let next_charge_at_after = cd.next_charge_at;
    let charges_after = cd.current_charges;

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

fn recharge_cooldown(
    state: &mut CombatState,
    buf: &mut DenseBuffer,
    spell_local: LocalSpellIdx,
    charges: u8,
) {
    if charges == 0 {
        return;
    }

    let spell = spell_at(state, spell_local);

    if spell.is_charged() {
        grant_charges(state, buf, spell_local, charges);

        return;
    }

    let Some(category) = spell.cooldown.charge_category else {
        reset_cooldown(state, buf, spell_local);

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

    state
        .runtime
        .pools
        .charge_category_ready_at
        .reset(&category);

    for member in &members {
        state.runtime.pools.cooldown_ready_at.reset(member);
    }

    project_members(state, buf, &members);
}

pub(crate) fn mutate_cooldown(
    state: &mut CombatState,
    buf: &mut DenseBuffer,
    spell_local: LocalSpellIdx,
    operation: wowlab_engine_domain::dbc::CooldownMutation,
    now: SimTime,
) {
    match operation {
        wowlab_engine_domain::dbc::CooldownMutation::ReduceRemaining { amount_ms } => {
            reduce_cooldown(state, buf, spell_local, amount_ms, now);
        }
        wowlab_engine_domain::dbc::CooldownMutation::Recharge { charges } => {
            recharge_cooldown(state, buf, spell_local, charges);
        }
    }
}

pub(crate) fn reset_cooldown(
    state: &mut CombatState,
    buf: &mut DenseBuffer,
    spell_local: LocalSpellIdx,
) {
    let spell = spell_at(state, spell_local);
    let members = charge_pool_members(state, spell_local);
    let owner = charge_pool_owner(state, spell_local);
    let target_local = if spell.is_charged() {
        owner
    } else {
        spell_local
    };
    let target_spell = spell_at(state, target_local);
    let idx = target_spell.idx();

    if let Some(category) = spell
        .cooldown
        .charge_category
        .filter(|_| !spell.is_charged())
    {
        state
            .runtime
            .pools
            .charge_category_ready_at
            .reset(&category);

        for member in &members {
            state.runtime.pools.cooldown_ready_at.reset(member);
        }
    } else {
        state.runtime.pools.cooldown_ready_at.reset(&spell_local);
    }

    let Some(cd) = buf.cooldown_mut(idx) else {
        return;
    };

    // Re-derive the full slot from defs: post-build charge registration (talent fns) must reach the slot read by the rotation.

    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(state, buf, owner, &members);
        project_members(state, buf, &members);
    } else if spell.cooldown.charge_category.is_some() {
        project_members(state, buf, &members);
    } else {
        project_ready_at(state, buf, spell_local);
    }
}

pub(crate) fn check_recharge(
    state: &mut CombatState,
    buf: &mut DenseBuffer,
    spell_local: LocalSpellIdx,
    now: SimTime,
) {
    let spell = spell_at(state, spell_local);

    if !spell.is_charged() {
        return;
    }

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

    if spell_local != owner {
        return;
    }

    let owner_spell = spell_at(state, owner);
    let idx = owner_spell.idx();
    let (recharge_ms, recharge_rate) = effective_recharge_ms(state, buf, &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 Some(cd) = buf.cooldown_mut(idx) else {
        return;
    };

    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.schedule(Event::CooldownReady {
            t: next_ready,
            cooldown_key: idx,
        });

        next_ready.as_secs_f64()
    } else {
        0.0
    };

    cd.current_charges = new_charges;
    cd.next_charge_at = next_at;
    sync_charge_pool(state, buf, owner, &members);
}