wowlab_engine_combat/systems/cooldowns/

charges.rs

#[cfg(feature = "rotation-optimizations")]
use super::CooldownReadinessSnapshot;
use super::{
    BuffEffect, CombatInstance, Event, LocalSpellIdx, MS_PER_SECOND, SimTime, SpellData,
    effective_recharge_ms, for_each_planned_player_effect, project_members,
};

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

pub(super) struct ChargePoolMembers<'a> {
    single: [LocalSpellIdx; 1],
    shared: Option<&'a [LocalSpellIdx]>,
}

impl ChargePoolMembers<'_> {
    pub(super) fn as_slice(&self) -> &[LocalSpellIdx] {
        self.shared.unwrap_or(&self.single)
    }
}

pub(super) fn charge_pool_members(
    program: &crate::state::CombatProgram,
    spell_local: LocalSpellIdx,
) -> ChargePoolMembers<'_> {
    let shared = program
        .charge_category_members
        .get(spell_local.as_usize())
        .map(Box::as_ref)
        .filter(|members| !members.is_empty());

    ChargePoolMembers {
        single: [spell_local],
        shared,
    }
}

pub(super) fn charge_pool_owner(
    program: &crate::state::CombatProgram,
    spell_local: LocalSpellIdx,
) -> LocalSpellIdx {
    program
        .charge_category_owners
        .get(spell_local.as_usize())
        .copied()
        .unwrap_or(spell_local)
}

pub(super) fn sync_charge_pool(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
    owner: LocalSpellIdx,
    members: &[LocalSpellIdx],
) {
    let Some(source) = program.buffer_cooldown(state, owner).copied() else {
        return;
    };

    for member in members.iter().copied().filter(|member| *member != owner) {
        if let Some(target) = program.buffer_cooldown_mut(state, member) {
            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(
    pending_events: &mut Vec<Event>,
    cd: &mut wowlab_engine_domain::rotation::CooldownSlot,
    spell: wowlab_engine_ports::ScheduledSpellBinding,
    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));

        pending_events.push(Event::CooldownReady { t: ready_at, spell });
        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(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
    spell_local: LocalSpellIdx,
    amount: u8,
    _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);

    grant_charges_state(program, state, spell_local, amount);

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

pub(super) fn grant_charges_state(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
    spell_local: LocalSpellIdx,
    amount: u8,
) {
    let spell = spell_at(program, spell_local);

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

    let members = charge_pool_members(program, spell_local);
    let owner = charge_pool_owner(program, spell_local);
    let Some(cd) = program.buffer_cooldown_mut(state, owner) 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(program, state, owner, members.as_slice());
    project_members(program, state, members.as_slice());
}

pub(super) fn reduce_charged_cooldown(
    pending_events: &mut Vec<Event>,
    cd: &mut wowlab_engine_domain::rotation::CooldownSlot,
    spell: wowlab_engine_ports::ScheduledSpellBinding,
    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;
            pending_events.push(Event::CooldownReady {
                t: SimTime::from_secs_f64(cd.next_charge_at),
                spell,
            });

            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 {
        pending_events.push(Event::CooldownReady {
            t: SimTime::from_secs_f64(cd.next_charge_at),
            spell,
        });
    }
}

/// Applies live aura-411 category max-charge deltas to charged spells.
pub(crate) fn refresh_maximum_charges_for(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
    now: SimTime,
    locals: &[LocalSpellIdx],
) {
    for &local in locals {
        let spell = *program.spell(local);

        if !spell.is_charged() {
            continue;
        }

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

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

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

        for_each_planned_player_effect(
            program,
            state,
            crate::state::EffectFamily::MAXIMUM_CHARGES,
            |stacks, effect| {
                if let BuffEffect::MaxChargesCategory(value, effect_category) = effect
                    && *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(program, state, local, &spell);
        let mut schedule_recharge_at = None;

        if let Some(cd) = program.buffer_cooldown_mut(state, local) {
            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,
                spell: program.scheduled_spell(local),
            });
        }

        let members = charge_pool_members(program, local);

        sync_charge_pool(program, state, local, members.as_slice());
        project_members(program, state, members.as_slice());

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