wowlab_engine_combat/systems/cooldowns/

rates.rs

use wowlab_engine_domain::dbc::ModifierPropertyKind;
use wowlab_types::sim::ActorId;

#[cfg(feature = "rotation-optimizations")]
use super::CooldownReadinessSnapshot;
use super::{
    BuffEffect, CombatInstance, Event, HUNDRED, LocalSpellIdx, MS_PER_SECOND, SimTime, SpellData,
    charge_pool_members, charge_pool_owner, current_haste_mult, dbc_effect_points, project_members,
    project_ready_at, sync_charge_pool,
};
use crate::{context::ActorView, systems::buffs::for_each_active_spell_modifier_for_action};

#[derive(Clone, Copy)]
#[cfg(feature = "rotation-optimizations")]
struct CooldownProjection {
    rate_mult: f64,
    duration_mult: f64,
}

#[cfg(feature = "rotation-optimizations")]
const MISSING_COOLDOWN_RATE_PROJECTION: &str = "finalized spell has a cooldown-rate projection";

#[cfg(not(feature = "rotation-optimizations"))]
fn current_cooldown_rate_mult(
    program: &crate::state::CombatProgram,
    state: &CombatInstance,
    local: LocalSpellIdx,
    spell: &SpellData,
) -> f64 {
    let mut rate = if spell.cooldown.cooldown_hasted {
        current_haste_mult(&crate::CombatView::new(program, state))
    } else {
        1.0
    };
    let category_cooldown = spell.is_charged() || spell.cooldown.charge_category.is_some();
    let target = program.damage.spell_action(local);

    for_each_active_spell_modifier_for_action(
        ActorView::new(program, state, ActorId::Player),
        target,
        ModifierPropertyKind::Cooldown,
        |stacks, effect, _binding| match effect {
            BuffEffect::RechargeRatePercent(percent, _) => {
                rate *= 1.0 + percent * stacks / HUNDRED;
            }
            BuffEffect::CooldownRechargeRateFromEffect {
                percent,
                source_spell_id,
                effect_index,
            } if !category_cooldown => {
                rate *= 1.0 + percent * stacks / HUNDRED;
            }
            BuffEffect::ChargeRechargeRateCategory {
                percent, category, ..
            } if category_cooldown
                && spell
                    .cooldown
                    .charge_category
                    .is_some_and(|spell_category| spell_category.raw() == *category) =>
            {
                rate *= 1.0 + percent * stacks / HUNDRED;
            }
            _ => {}
        },
    );

    rate.max(f64::EPSILON)
}

#[cfg(feature = "rotation-optimizations")]
fn resolve_cooldown_projection(
    program: &crate::state::CombatProgram,
    state: &CombatInstance,
    local: LocalSpellIdx,
    spell: &SpellData,
) -> CooldownProjection {
    let mut projection = CooldownProjection {
        rate_mult: if spell.cooldown.cooldown_hasted {
            current_haste_mult(&crate::CombatView::new(program, state))
        } else {
            1.0
        },
        duration_mult: 1.0,
    };
    let category_cooldown = spell.is_charged() || spell.cooldown.charge_category.is_some();
    let target = program.damage.spell_action(local);

    for_each_active_spell_modifier_for_action(
        ActorView::new(program, state, ActorId::Player),
        target,
        ModifierPropertyKind::Cooldown,
        |stacks, effect, binding| match effect {
            BuffEffect::RechargeRatePercent(percent, _) => {
                projection.rate_mult *= 1.0 + percent * stacks / HUNDRED;
            }
            BuffEffect::CooldownRechargeRateFromEffect { percent, .. } if !category_cooldown => {
                projection.rate_mult *= 1.0 + percent * stacks / HUNDRED;
            }
            BuffEffect::ChargeRechargeRateCategory {
                percent, category, ..
            } if category_cooldown
                && spell
                    .cooldown
                    .charge_category
                    .is_some_and(|spell_category| spell_category.raw() == *category) =>
            {
                projection.rate_mult *= 1.0 + percent * stacks / HUNDRED;
            }
            BuffEffect::CooldownDurationPercent { percent, .. } => {
                let points = dbc_effect_points(
                    program,
                    state,
                    binding
                        .source_effect
                        .expect("matched source binding exists"),
                    stacks,
                );

                projection.duration_mult *= (1.0 + percent * points / HUNDRED).max(0.0);
            }
            _ => {}
        },
    );

    projection.rate_mult = projection.rate_mult.max(f64::EPSILON);

    projection
}

#[cfg(feature = "rotation-optimizations")]
fn projected_cooldown(state: &CombatInstance, local: LocalSpellIdx) -> CooldownProjection {
    let index = local.as_usize();

    CooldownProjection {
        rate_mult: state
            .runtime
            .recharge_rate_mults
            .get(index)
            .copied()
            .expect(MISSING_COOLDOWN_RATE_PROJECTION),
        duration_mult: state
            .runtime
            .cooldown_duration_mults
            .get(index)
            .copied()
            .expect("finalized spell has a cooldown-duration projection"),
    }
}

#[cfg(feature = "rotation-optimizations")]
fn write_cooldown_projection(
    state: &mut CombatInstance,
    local: LocalSpellIdx,
    projection: CooldownProjection,
) {
    let index = local.as_usize();
    let rate = state
        .runtime
        .recharge_rate_mults
        .get_mut(index)
        .expect(MISSING_COOLDOWN_RATE_PROJECTION);
    let duration = state
        .runtime
        .cooldown_duration_mults
        .get_mut(index)
        .expect("finalized spell has a cooldown-duration projection");

    *rate = projection.rate_mult;
    *duration = projection.duration_mult;
}

#[cfg(feature = "rotation-optimizations")]
pub(crate) fn initialize_cooldown_projections(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
) {
    for index in 0..program.spells.len() {
        let local = LocalSpellIdx::new(
            u8::try_from(index).expect("finalized spell count fits local index"),
        );
        let spell = program.spell(local);

        if !spell.cooldown.has_cooldown {
            continue;
        }

        let projection = resolve_cooldown_projection(program, state, local, spell);

        write_cooldown_projection(state, local, projection);
    }

    state
        .runtime
        .initial_recharge_rate_mults
        .copy_from_slice(&state.runtime.recharge_rate_mults);
    state
        .runtime
        .initial_cooldown_duration_mults
        .copy_from_slice(&state.runtime.cooldown_duration_mults);
}

#[cfg(feature = "rotation-optimizations")]
pub(crate) fn reset_cooldown_projections(state: &mut CombatInstance) {
    state
        .runtime
        .recharge_rate_mults
        .copy_from_slice(&state.runtime.initial_recharge_rate_mults);
    state
        .runtime
        .cooldown_duration_mults
        .copy_from_slice(&state.runtime.initial_cooldown_duration_mults);
}

#[cfg_attr(
    feature = "rotation-optimizations",
    expect(
        unused_variables,
        reason = "optimized cooldown projections replace the program lookup"
    )
)]
pub(super) fn effective_recharge_ms(
    program: &crate::state::CombatProgram,
    state: &CombatInstance,
    local: LocalSpellIdx,
    spell: &SpellData,
) -> (u32, f64) {
    #[cfg(not(feature = "rotation-optimizations"))]
    let rate = current_cooldown_rate_mult(program, state, local, spell);
    #[cfg(feature = "rotation-optimizations")]
    let rate = projected_cooldown(state, local).rate_mult;
    let duration = wowlab_types::numeric::f64_to_u32_saturating_trunc(
        f64::from(spell.cooldown.recharge_ms) / rate,
    );

    (
        duration.max(u32::from(spell.cooldown.recharge_ms > 0)),
        rate,
    )
}

#[cfg_attr(
    feature = "rotation-optimizations",
    expect(
        unused_variables,
        reason = "optimized cooldown projections replace the program and spell lookups"
    )
)]
pub(super) fn effective_cooldown_duration_ms(
    program: &crate::state::CombatProgram,
    state: &CombatInstance,
    local: LocalSpellIdx,
    spell: &SpellData,
    base_duration_ms: u32,
) -> (u32, f64) {
    #[cfg(not(feature = "rotation-optimizations"))]
    let rate = current_cooldown_rate_mult(program, state, local, spell);
    #[cfg(feature = "rotation-optimizations")]
    let projection = projected_cooldown(state, local);
    #[cfg(feature = "rotation-optimizations")]
    let rate = projection.rate_mult;
    #[cfg(feature = "rotation-optimizations")]
    let duration_mult = projection.duration_mult;
    #[cfg(not(feature = "rotation-optimizations"))]
    let mut duration_mult = 1.0;
    #[cfg(not(feature = "rotation-optimizations"))]
    let target = program.damage.spell_action(local);

    #[cfg(not(feature = "rotation-optimizations"))]
    for_each_active_spell_modifier_for_action(
        ActorView::new(program, state, ActorId::Player),
        target,
        ModifierPropertyKind::Cooldown,
        |stacks, effect, binding| {
            if let BuffEffect::CooldownDurationPercent { percent, .. } = effect {
                let points = dbc_effect_points(
                    program,
                    state,
                    binding
                        .source_effect
                        .expect("matched source binding exists"),
                    stacks,
                );

                duration_mult *= (1.0 + percent * points / HUNDRED).max(0.0);
            }
        },
    );
    let duration = wowlab_types::numeric::f64_to_u32_saturating_trunc(
        f64::from(base_duration_ms) * duration_mult / rate,
    );

    (duration, rate)
}

pub(super) fn effective_cooldown_ms(
    program: &crate::state::CombatProgram,
    state: &CombatInstance,
    local: LocalSpellIdx,
    spell: &SpellData,
) -> (u32, f64) {
    effective_cooldown_duration_ms(
        program,
        state,
        local,
        spell,
        spell.cooldown.cooldown_duration_ms,
    )
}

pub(super) fn effective_category_cooldown_ms(
    program: &crate::state::CombatProgram,
    state: &CombatInstance,
    local: LocalSpellIdx,
    spell: &SpellData,
) -> u32 {
    effective_cooldown_duration_ms(
        program,
        state,
        local,
        spell,
        spell.cooldown.category_cooldown_duration_ms,
    )
    .0
}

fn reproject_deadline(deadline_s: f64, now_s: f64, old_rate: f64, new_rate: f64) -> Option<f64> {
    (deadline_s > now_s).then(|| now_s + (deadline_s - now_s) * old_rate / new_rate)
}

#[derive(Clone, Copy)]
struct ActiveCooldownDeadlines {
    private: SimTime,
    charge: Option<(wowlab_types::data::CooldownCategoryId, SimTime)>,
}

#[derive(Clone, Copy)]
struct RechargeRateChange {
    now_s: f64,
    old: f64,
    new: f64,
}

fn update_recharge_slot(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
    local: LocalSpellIdx,
    spell: &SpellData,
    rate: RechargeRateChange,
    deadlines: ActiveCooldownDeadlines,
) -> (Option<f64>, Option<f64>) {
    let Some(cd) = program.buffer_cooldown_mut(state, local) else {
        return (None, None);
    };

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

        cd.duration = base_recharge_s / rate.new;
        cd.recharge_time = cd.duration;
        let next_at = (cd.current_charges < cd.max_charges)
            .then(|| reproject_deadline(cd.next_charge_at, rate.now_s, rate.old, rate.new))
            .flatten();

        if let Some(next_at) = next_at {
            cd.next_charge_at = next_at;
        }

        return (None, next_at);
    }

    let base_duration_s = f64::from(spell.cooldown.cooldown_duration_ms) / MS_PER_SECOND;

    cd.duration = base_duration_s / rate.new;
    let private = reproject_deadline(
        deadlines.private.as_secs_f64(),
        rate.now_s,
        rate.old,
        rate.new,
    );
    let charge = deadlines.charge.and_then(|(_, ready_at)| {
        reproject_deadline(ready_at.as_secs_f64(), rate.now_s, rate.old, rate.new)
    });

    (private, charge)
}

fn sync_spell_recharge_rate(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
    local: LocalSpellIdx,
    spell: &SpellData,
    now: SimTime,
) {
    #[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 now_s = now.as_secs_f64();
    let i = local.as_usize();
    #[cfg(not(feature = "rotation-optimizations"))]
    let new_rate = current_cooldown_rate_mult(program, state, local, spell);
    #[cfg(feature = "rotation-optimizations")]
    let projection = resolve_cooldown_projection(program, state, local, spell);
    #[cfg(feature = "rotation-optimizations")]
    let new_rate = projection.rate_mult;
    #[cfg(feature = "rotation-optimizations")]
    let old_rate = state
        .runtime
        .recharge_rate_mults
        .get(i)
        .copied()
        .expect(MISSING_COOLDOWN_RATE_PROJECTION)
        .max(f64::EPSILON);
    #[cfg(not(feature = "rotation-optimizations"))]
    let old_rate = state
        .runtime
        .recharge_rate_mults
        .get(i)
        .copied()
        .unwrap_or(1.0)
        .max(f64::EPSILON);

    #[cfg(feature = "rotation-optimizations")]
    write_cooldown_projection(state, local, projection);

    #[cfg(not(feature = "rotation-optimizations"))]
    if let Some(rate) = state.runtime.recharge_rate_mults.get_mut(i) {
        *rate = new_rate;
    }

    #[cfg(feature = "rotation-optimizations")]
    if old_rate.to_bits() == new_rate.to_bits() {
        return;
    }

    let private_ready_at = state.runtime.pools.cooldown_ready_at.ready_at(local);
    let charge_ready_at = spell.cooldown.charge_category.map(|category| {
        (
            category,
            state.runtime.pools.charge_category_ready_at.ready_at(local),
        )
    });
    let deadlines = ActiveCooldownDeadlines {
        private: private_ready_at,
        charge: charge_ready_at,
    };
    let rate = RechargeRateChange {
        now_s,
        old: old_rate,
        new: new_rate,
    };
    let (private_rescheduled, charge_rescheduled) =
        update_recharge_slot(program, state, local, spell, rate, deadlines);

    if !spell.is_charged() {
        if let Some(ready_at) = private_rescheduled {
            state
                .runtime
                .pools
                .cooldown_ready_at
                .start(local, SimTime::from_secs_f64(ready_at));
            state.schedule(Event::CooldownReady {
                t: SimTime::from_secs_f64(ready_at),
                spell: program.scheduled_spell(local),
            });
        }

        if let (Some((_, _)), Some(ready_at)) = (charge_ready_at, charge_rescheduled) {
            let members = charge_pool_members(program, local);

            for member in members.as_slice().iter().copied() {
                state
                    .runtime
                    .pools
                    .charge_category_ready_at
                    .start(member, SimTime::from_secs_f64(ready_at));
                state.schedule(Event::CooldownReady {
                    t: SimTime::from_secs_f64(ready_at),
                    spell: program.scheduled_spell(member),
                });
            }

            project_members(program, state, members.as_slice());
        } else {
            project_ready_at(program, state, local);
        }
    }

    if spell.is_charged() {
        let members = charge_pool_members(program, local);

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

    if spell.is_charged()
        && let Some(next_at) = charge_rescheduled
    {
        state.schedule(Event::CooldownReady {
            t: SimTime::from_secs_f64(next_at),
            spell: program.scheduled_spell(local),
        });
    }

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

pub(crate) fn refresh_recharge_rates_for(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
    now: SimTime,
    locals: &[LocalSpellIdx],
) {
    for &local in locals {
        let spell = *program.spell(local);

        if !spell.cooldown.has_cooldown {
            continue;
        }

        if (spell.is_charged() || spell.cooldown.charge_category.is_some())
            && charge_pool_owner(program, local) != local
        {
            continue;
        }

        sync_spell_recharge_rate(program, state, local, &spell, now);
    }
}