wowlab_engine_combat/systems/

resources.rs

//! Primary/secondary resource spend, gain, and haste-scaled regeneration.

use wowlab_engine_telemetry::{RESOURCE_SOURCE_PASSIVE_REGEN, ResourceEventKind, TelemetrySink};
use wowlab_types::{
    combat::ResourceType,
    constants::{HUNDRED, MS_PER_SECOND},
    sim::{ActorId, SimTime},
};

use super::buffs::current_stat_haste_mult;
#[cfg(feature = "rotation-optimizations")]
use crate::state::runtime::RotationMutationDirection;
use crate::state::{CombatInstance, ResourceGain, ResourceGainScaling};

#[cfg(feature = "rotation-optimizations")]
fn record_resource_current_transition(
    state: &mut CombatInstance,
    resource: ResourceType,
    before: f64,
    after: f64,
    now: SimTime,
) {
    let direction = if after > before {
        RotationMutationDirection::Rise
    } else if after < before {
        RotationMutationDirection::Fall
    } else {
        return;
    };

    state
        .runtime
        .rotation_mutations
        .record_resource(resource, direction, now);
}

#[must_use]
pub(crate) fn spell_health_cost(
    state: &CombatInstance,
    actor: ActorId,
    flat: f64,
    percent_of_maximum: f64,
) -> f64 {
    let maximum = state.friendly_actor_max_health(actor).unwrap_or(0.0);

    flat.max(0.0) + maximum * percent_of_maximum.max(0.0) / HUNDRED
}

pub(crate) fn spend_health_cost(
    state: &mut CombatInstance,
    actor: ActorId,
    flat: f64,
    percent_of_maximum: f64,
    _now: SimTime,
) -> f64 {
    let cost = spell_health_cost(state, actor, flat, percent_of_maximum);
    let spent = state
        .apply_friendly_actor_damage(actor, cost)
        .unwrap_or(0.0);

    #[cfg(feature = "rotation-optimizations")]
    if actor == ActorId::Player && spent > 0.0 {
        state.runtime.rotation_mutations.record_semantic(
            crate::state::runtime::RotationSemanticMutation::PlayerHealth,
            RotationMutationDirection::Fall,
            _now,
        );
    }

    spent
}

/// Override the primary resource's base regeneration and project its effective live rate.
pub fn set_primary_resource_base_regen(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
    base_regen: f64,
    _now: SimTime,
) {
    let (effective_regen, _) = effective_primary_regen(program, state, base_regen, true);

    state.runtime.resources.primary_base_regen_override = Some(base_regen);

    if let Some(rt) = program.config.base_stats.resource_type
        && let Some(res) = program.buffer_resource_mut(state, rt)
    {
        #[cfg(feature = "rotation-optimizations")]
        let previous_regen = res.regen_per_sec;

        res.regen_per_sec = effective_regen;

        #[cfg(feature = "rotation-optimizations")]
        if previous_regen.to_bits() != effective_regen.to_bits() {
            state.runtime.rotation_mutations.record_resource(
                rt,
                RotationMutationDirection::Rise,
                _now,
            );
            state.runtime.rotation_mutations.record_resource(
                rt,
                RotationMutationDirection::Fall,
                _now,
            );
        }
    }
}

fn effective_primary_regen(
    program: &crate::state::CombatProgram,
    state: &CombatInstance,
    base_regen: f64,
    haste_scaled: bool,
) -> (f64, f64) {
    let view = crate::CombatView::new(program, state);
    let totals = view.buff_totals();
    let mut flat_regen_per_second = 0.0;
    let primary_type = program.config.base_stats.resource_type;
    let mut interrupted = false;
    let mut interrupted_percent = 0.0;
    let mut prevented_mask = 0_u64;

    super::buffs::for_each_planned_player_effect(
        program,
        state,
        crate::state::EffectFamily::RESOURCE_REGENERATION,
        |stacks, effect| match effect {
            crate::BuffEffect::ResourceRegenPerFiveSeconds(value, resource_type) => {
                if Some(*resource_type) == primary_type {
                    flat_regen_per_second +=
                        value * stacks / wowlab_engine_domain::dbc::POWER_REGEN_PERIOD_SECONDS;
                }
            }
            crate::BuffEffect::InterruptRegen => interrupted = true,
            crate::BuffEffect::InterruptedRegenPercent(value) => {
                interrupted_percent += value * stacks;
            }
            crate::BuffEffect::PreventResourceRegen(mask) => prevented_mask |= mask,
            _ => {}
        },
    );

    let haste_multiplier = if haste_scaled {
        current_stat_haste_mult(&view)
    } else {
        1.0
    };
    let scaled_base = base_regen * haste_multiplier * (1.0 + totals.regen_pct / HUNDRED);

    let effective = apply_regen_interruptions(
        scaled_base + flat_regen_per_second,
        primary_type,
        interrupted,
        interrupted_percent,
        prevented_mask,
    );

    (effective, totals.max_resource_flat)
}

/// Immediately project aura-dependent primary maximum and regeneration fields.
pub(crate) fn refresh_primary_resource_projection(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
    _now: SimTime,
) {
    if program.config.base_stats.resource_type == Some(ResourceType::Runes) {
        return;
    }

    let dynamic_base_regen = state.runtime.resources.primary_base_regen_override;
    let base_regen = dynamic_base_regen.unwrap_or(program.config.base_stats.base_regen);
    let (effective_regen, max_resource_flat) = effective_primary_regen(
        program,
        state,
        base_regen,
        program.config.haste_regen || dynamic_base_regen.is_some(),
    );

    #[cfg(feature = "rotation-optimizations")]
    let mut resource_transition = None;

    if let Some(resource_type) = program.config.base_stats.resource_type
        && let Some(resource) = program.buffer_resource_mut(state, resource_type)
    {
        #[cfg(feature = "rotation-optimizations")]
        let current_before = resource.current;

        resource.max = program.config.base_stats.resource_max + max_resource_flat;
        resource.current = resource.current.min(resource.max);
        resource.regen_per_sec = effective_regen;

        #[cfg(feature = "rotation-optimizations")]
        {
            resource_transition = Some((resource_type, current_before, resource.current));
        }
    }

    #[cfg(feature = "rotation-optimizations")]
    if let Some((resource, before, after)) = resource_transition {
        record_resource_current_transition(state, resource, before, after, _now);
    }
}

fn apply_regen_interruptions(
    rate: f64,
    primary_type: Option<ResourceType>,
    interrupted: bool,
    interrupted_percent: f64,
    prevented_mask: u64,
) -> f64 {
    let resource_prevented = primary_type.is_some_and(|resource_type| {
        let bit = u32::from(u8::from(resource_type));

        1_u64
            .checked_shl(bit)
            .is_some_and(|mask| prevented_mask & mask != 0)
    });

    if resource_prevented {
        0.0
    } else if interrupted {
        let continuation = if primary_type == Some(ResourceType::Mana) {
            interrupted_percent.max(0.0) / HUNDRED
        } else {
            0.0
        };

        rate * continuation
    } else {
        rate
    }
}

// docref:start resources-sync-resource
pub(crate) fn sync_resource(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
    now: SimTime,
    last_sync: &mut SimTime,
    sink: &mut TelemetrySink,
) {
    if now <= *last_sync {
        return;
    }
    // docref:end resources-sync-resource

    if program.config.base_stats.resource_type == Some(ResourceType::Runes) {
        sync_runes(program, state, now, last_sync, sink);

        return;
    }

    let elapsed_s = f64::from(now.as_millis() - last_sync.as_millis()) / MS_PER_SECOND;

    let mut gained = 0.0;
    let mut wasted = 0.0;
    #[cfg(feature = "rotation-optimizations")]
    let mut resource_transition = None;

    if let Some(rt) = program.config.base_stats.resource_type
        && let Some(res) = program.buffer_resource_mut(state, rt)
    {
        #[cfg(feature = "rotation-optimizations")]
        let current_before = res.current;

        let uncapped = res.current + res.regen_per_sec * elapsed_s;
        let capped = uncapped.min(res.max);

        gained = capped - res.current;
        wasted = uncapped - capped;
        res.current = capped;

        #[cfg(feature = "rotation-optimizations")]
        {
            resource_transition = Some((rt, current_before, res.current));
        }
    }

    #[cfg(feature = "rotation-optimizations")]
    if let Some((resource, before, after)) = resource_transition {
        record_resource_current_transition(state, resource, before, after, now);
    }

    emit_passive_regen(program, state, now, sink, gained, wasted);

    *last_sync = now;
}

/// Report one sync step's haste-scaled passive regeneration so resource-income views account for it.
fn emit_passive_regen(
    program: &crate::state::CombatProgram,
    state: &CombatInstance,
    now: SimTime,
    sink: &mut TelemetrySink,
    gained: f64,
    wasted: f64,
) {
    if gained <= 0.0 && wasted <= 0.0 {
        return;
    }

    super::procs::emit_resource(
        program,
        state,
        sink,
        super::procs::ResourceTelemetry {
            kind: ResourceEventKind::Gain { wasted },
            amount: gained,
            secondary: false,
            now,
            source_spell_id: RESOURCE_SOURCE_PASSIVE_REGEN,
        },
    );
}

fn sync_runes(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
    now: SimTime,
    last_sync: &mut SimTime,
    sink: &mut TelemetrySink,
) {
    let current = program
        .buffer_resource(state, ResourceType::Runes)
        .map_or(0.0, |resource| resource.current);
    let rune_count = u32::try_from(crate::state::RUNE_COUNT).expect("rune count fits u32");
    let represented = u32::try_from(state.runtime.resources.runes.full_count())
        .expect("full rune count fits u32");

    if (current - f64::from(represented)).abs() > f64::EPSILON {
        let requested = wowlab_types::numeric::f64_to_u32_saturating_round(current).min(rune_count);

        state.runtime.resources.runes.reset_to(
            usize::try_from(requested).expect("requested rune count fits usize"),
            *last_sync,
        );
    }

    let elapsed_s = f64::from(now.as_millis() - last_sync.as_millis()) / MS_PER_SECOND;
    let (rate_multiplier, _) = effective_primary_regen(program, state, 1.0, true);

    let banked_before = u32::try_from(state.runtime.resources.runes.full_count())
        .expect("full rune count fits u32");

    state
        .runtime
        .resources
        .runes
        .advance(elapsed_s * rate_multiplier);
    state.runtime.resources.runes.updated_at = now;

    let mut banked = 0.0;

    if let Some(handle) = program.resource_binding(ResourceType::Runes) {
        let full_count = u32::try_from(state.runtime.resources.runes.full_count())
            .expect("full rune count fits u32");
        let regenerating_count = u32::try_from(state.runtime.resources.runes.regenerating_count())
            .expect("regenerating rune count fits u32");
        let resource = state.buffer.resource_mut_at(handle);

        resource.max = f64::from(rune_count);
        resource.current = f64::from(full_count);
        resource.regen_per_sec =
            f64::from(regenerating_count) * rate_multiplier / crate::state::RUNE_RECHARGE_SECONDS;
        banked = f64::from(full_count.saturating_sub(banked_before));
    }

    #[cfg(feature = "rotation-optimizations")]
    {
        let current_after = program
            .buffer_resource(state, ResourceType::Runes)
            .map_or(0.0, |resource| resource.current);

        record_resource_current_transition(state, ResourceType::Runes, current, current_after, now);
    }

    emit_passive_regen(program, state, now, sink, banked, 0.0);

    *last_sync = now;
}

pub(crate) fn rune_time_to_regen(
    program: &crate::state::CombatProgram,
    state: &CombatInstance,
    needed: usize,
) -> Option<f64> {
    let (rate_multiplier, _) = effective_primary_regen(program, state, 1.0, true);

    state
        .runtime
        .resources
        .runes
        .time_to_regen(needed, rate_multiplier)
}

#[inline]
const fn resource_type(
    program: &crate::state::CombatProgram,
    _state: &CombatInstance,
    secondary: bool,
) -> Option<ResourceType> {
    if secondary {
        program.config.base_stats.secondary_resource_type
    } else {
        program.config.base_stats.resource_type
    }
}

pub(crate) fn resource_pool_for_type(
    program: &crate::state::CombatProgram,
    _state: &CombatInstance,
    resource_type: ResourceType,
) -> Option<bool> {
    if program.config.base_stats.resource_type == Some(resource_type) {
        Some(false)
    } else if program.config.base_stats.secondary_resource_type == Some(resource_type) {
        Some(true)
    } else {
        None
    }
}

fn spend_resource_impl(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
    amount: f64,
    secondary: bool,
    _now: SimTime,
) -> bool {
    if let Some(rt) = resource_type(program, state, secondary)
        && let Some(handle) = program.resource_binding(rt)
    {
        let res = state.buffer.resource_mut_at(handle);

        #[cfg(feature = "rotation-optimizations")]
        let current_before = res.current;

        if !res.spend(amount) {
            return false;
        }

        #[cfg(feature = "rotation-optimizations")]
        let current_after = res.current;

        let spent = if rt == ResourceType::Runes {
            state.runtime.resources.runes.consume(
                wowlab_types::numeric::f64_to_u32_saturating_round(amount.max(0.0)) as usize,
            )
        } else {
            true
        };

        #[cfg(feature = "rotation-optimizations")]
        record_resource_current_transition(state, rt, current_before, current_after, _now);

        return spent;
    }

    false
}

fn gain_resource_impl(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
    gain: ResourceGain,
    secondary: bool,
    _now: SimTime,
) -> (f64, f64) {
    let amount = if secondary || gain.scaling == ResourceGainScaling::Unmodified {
        gain.amount
    } else {
        gain.amount
            * super::buffs::current_resource_gain_mult(
                &crate::CombatView::new(program, state),
                gain.source,
            )
    };

    tracing::trace!(?gain.source, base_amount = gain.amount, amount, secondary, "RESOURCE_GAIN");

    if let Some(rt) = resource_type(program, state, secondary)
        && let Some(handle) = program.resource_binding(rt)
    {
        let res = state.buffer.resource_mut_at(handle);

        #[cfg(feature = "rotation-optimizations")]
        let current_before = res.current;

        let wasted = res.gain(amount);
        let actual = amount - wasted;

        if rt == ResourceType::Runes {
            let gained = wowlab_types::numeric::f64_to_u32_saturating_round(actual.max(0.0));

            state
                .runtime
                .resources
                .runes
                .fill(usize::try_from(gained).expect("gained rune count fits usize"));
            let full_count = u32::try_from(state.runtime.resources.runes.full_count())
                .expect("full rune count fits u32");

            res.current = f64::from(full_count);
        }

        #[cfg(feature = "rotation-optimizations")]
        let current_after = res.current;

        #[cfg(feature = "rotation-optimizations")]
        record_resource_current_transition(state, rt, current_before, current_after, _now);

        return (actual, wasted);
    }

    (0.0, amount)
}

pub(crate) fn spend_resource(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
    amount: f64,
    now: SimTime,
) -> bool {
    spend_resource_impl(program, state, amount, false, now)
}

pub(crate) fn gain_resource_from(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
    gain: ResourceGain,
    now: SimTime,
) -> (f64, f64) {
    gain_resource_impl(program, state, gain, false, now)
}

pub(crate) fn spend_secondary_resource(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
    amount: f64,
    now: SimTime,
) -> bool {
    spend_resource_impl(program, state, amount, true, now)
}

pub(crate) fn secondary_spends_all_points(
    program: &crate::state::CombatProgram,
    state: &CombatInstance,
) -> bool {
    matches!(
        resource_type(program, state, true),
        Some(ResourceType::ComboPoints)
    )
}

pub(crate) fn spend_all_secondary_resource(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
    cost: f64,
    _now: SimTime,
) -> f64 {
    if let Some(rt) = resource_type(program, state, true)
        && let Some(res) = program.buffer_resource_mut(state, rt)
    {
        let available = res.current;

        if available >= cost && res.spend(available) {
            #[cfg(feature = "rotation-optimizations")]
            record_resource_current_transition(state, rt, available, 0.0, _now);

            return available;
        }
    }

    0.0
}

pub(crate) fn gain_secondary_resource_from(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
    gain: ResourceGain,
    now: SimTime,
) -> (f64, f64) {
    gain_resource_impl(program, state, gain, true, now)
}

#[cfg(test)]
#[path = "resources/tests.rs"]
mod tests;