wowlab_engine_combat/systems/cooldowns/

charges.rs

use super::{
    BuffEffect, CombatState, DenseBuffer, Event, LocalSpellIdx, MS_PER_SECOND, SimTime, SpellData,
    effective_recharge_ms, for_each_active_aura_effect, project_members,
};

pub(super) fn spell_at(state: &CombatState, local: LocalSpellIdx) -> SpellData {
    state
        .defs
        .spells
        .get(local.as_usize())
        .copied()
        .expect("local spell index validated during combat construction")
}

pub(super) fn charge_pool_members(
    state: &CombatState,
    spell_local: LocalSpellIdx,
) -> Vec<LocalSpellIdx> {
    let spell = spell_at(state, spell_local);

    spell.cooldown.charge_category.map_or_else(
        || vec![spell_local],
        |category| state.index.charge_categories.members(&category).to_vec(),
    )
}

pub(super) fn charge_pool_owner(state: &CombatState, spell_local: LocalSpellIdx) -> LocalSpellIdx {
    let spell = spell_at(state, spell_local);

    spell
        .cooldown
        .charge_category
        .and_then(|category| state.index.charge_categories.owner(&category).copied())
        .unwrap_or(spell_local)
}

pub(super) fn sync_charge_pool(
    state: &CombatState,
    buf: &mut DenseBuffer,
    owner: LocalSpellIdx,
    members: &[LocalSpellIdx],
) {
    let owner_spell = spell_at(state, owner);
    let Some(source) = buf.cooldown(owner_spell.idx()).copied() else {
        return;
    };

    for member in members.iter().copied().filter(|member| *member != owner) {
        let member_spell = spell_at(state, member);

        if let Some(target) = buf.cooldown_mut(member_spell.idx()) {
            target.current_charges = source.current_charges;
            target.max_charges = source.max_charges;
            target.next_charge_at = source.next_charge_at;
            target.recharge_time = source.recharge_time;
            target.duration = source.duration;
        }
    }
}

pub(super) fn consume_charge(
    state: &mut CombatState,
    cd: &mut wowlab_engine_domain::rotation::CooldownSlot,
    spell: &SpellData,
    recharge_ms: u32,
    now: SimTime,
) {
    cd.duration = f64::from(recharge_ms) / MS_PER_SECOND;
    cd.recharge_time = cd.duration;

    if cd.current_charges <= 0 {
        return;
    }

    let new_charges = cd.current_charges - 1;

    if new_charges == cd.max_charges - 1 {
        let ready_at = now.saturating_add(SimTime::from_millis(recharge_ms));

        state.schedule(Event::CooldownReady {
            t: ready_at,
            cooldown_key: spell.idx(),
        });
        cd.next_charge_at = ready_at.as_secs_f64();
    }

    cd.current_charges = new_charges;
}

/// Immediately restores charges without changing an in-flight recharge.
pub(crate) fn grant_charges(
    state: &CombatState,
    buf: &mut DenseBuffer,
    spell_local: LocalSpellIdx,
    amount: u8,
) {
    let spell = spell_at(state, spell_local);

    if !spell.is_charged() || amount == 0 {
        return;
    }

    let members = charge_pool_members(state, spell_local);
    let owner = charge_pool_owner(state, spell_local);
    let owner_spell = spell_at(state, owner);
    let Some(cd) = buf.cooldown_mut(owner_spell.idx()) else {
        return;
    };

    cd.current_charges = (cd.current_charges + i32::from(amount)).min(cd.max_charges);

    if cd.current_charges >= cd.max_charges {
        cd.next_charge_at = 0.0;
    }

    sync_charge_pool(state, buf, owner, &members);
    project_members(state, buf, &members);
}

pub(super) fn reduce_charged_cooldown(
    state: &mut CombatState,
    cd: &mut wowlab_engine_domain::rotation::CooldownSlot,
    cooldown_key: wowlab_types::sim::SpellIdx,
    recharge_ms: u32,
    mut reduction_s: f64,
    now: SimTime,
) {
    let now_s = now.as_secs_f64();
    let interval_s = f64::from(recharge_ms) / MS_PER_SECOND;

    while reduction_s > 0.0 && cd.current_charges < cd.max_charges {
        if cd.next_charge_at <= 0.0 {
            cd.next_charge_at = now_s + interval_s;
        }

        let remaining_s = (cd.next_charge_at - now_s).max(0.0);

        if reduction_s < remaining_s {
            cd.next_charge_at -= reduction_s;
            state.schedule(Event::CooldownReady {
                t: SimTime::from_secs_f64(cd.next_charge_at),
                cooldown_key,
            });

            return;
        }

        reduction_s -= remaining_s;
        cd.current_charges += 1;

        if cd.current_charges >= cd.max_charges {
            cd.next_charge_at = 0.0;

            return;
        }

        cd.next_charge_at = now_s + interval_s;
    }

    if cd.current_charges < cd.max_charges && cd.next_charge_at > now_s {
        state.schedule(Event::CooldownReady {
            t: SimTime::from_secs_f64(cd.next_charge_at),
            cooldown_key,
        });
    }
}

/// Applies live aura-411 category max-charge deltas to charged spells.
pub(crate) fn sync_max_charges(state: &mut CombatState, buf: &mut DenseBuffer, now: SimTime) {
    for i in 0..state.defs.spells.len() {
        let Some(spell) = state.defs.spells.get(i).copied() else {
            continue;
        };

        if !spell.is_charged() {
            continue;
        }

        let local = LocalSpellIdx::new(u8::try_from(i).expect("spell count fits in u8"));

        if charge_pool_owner(state, local) != local {
            continue;
        }

        let Some(category) = spell.cooldown.charge_category else {
            continue;
        };
        let mut delta = 0.0;

        for_each_active_aura_effect(state, buf, |stacks, effect| {
            if let BuffEffect::MaxChargesCategory(value, effect_category) = effect {
                if *effect_category == category.raw() {
                    delta += value * stacks;
                }
            }
        });
        let new_max = wowlab_types::numeric::f64_to_i32_saturating_round(
            (f64::from(spell.cooldown.max_charges) + delta).max(1.0),
        );
        let (recharge_ms, _) = effective_recharge_ms(state, buf, &spell);
        let mut schedule_recharge_at = None;

        if let Some(cd) = buf.cooldown_mut(spell.idx()) {
            let old_max = cd.max_charges;

            if new_max == old_max {
                continue;
            }

            if new_max > old_max {
                cd.current_charges += new_max - old_max;
            } else {
                cd.current_charges = (cd.current_charges - (old_max - new_max)).max(0);
            }

            cd.max_charges = new_max;
            let now_s = now.as_secs_f64();

            if cd.current_charges < new_max && cd.next_charge_at <= now_s && recharge_ms > 0 {
                let next = now.saturating_add(SimTime::from_millis(recharge_ms));

                cd.next_charge_at = next.as_secs_f64();
                schedule_recharge_at = Some(next);
            }
        }

        if let Some(t) = schedule_recharge_at {
            state.schedule(Event::CooldownReady {
                t,
                cooldown_key: spell.idx(),
            });
        }

        let members = charge_pool_members(state, local);

        sync_charge_pool(state, buf, local, &members);
        project_members(state, buf, &members);
    }
}