wowlab_engine_combat/systems/

resources.rs

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

use wowlab_engine_domain::rotation::DenseBuffer;
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;
use crate::state::{CombatState, ResourceGain, ResourceGainScaling};

#[must_use]
pub(crate) fn spell_health_cost(
    state: &CombatState,
    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 CombatState,
    actor: ActorId,
    flat: f64,
    percent_of_maximum: f64,
) -> f64 {
    let cost = spell_health_cost(state, actor, flat, percent_of_maximum);

    state
        .apply_friendly_actor_damage(actor, cost)
        .unwrap_or(0.0)
}

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

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

    if let Some(rt) = state.config.base_stats.resource_type {
        if let Some(res) = buf.resource_mut(rt) {
            res.regen_per_sec = effective_regen;
        }
    }
}

fn effective_primary_regen(
    state: &CombatState,
    buf: &DenseBuffer,
    base_regen: f64,
    haste_scaled: bool,
) -> (f64, f64) {
    let view = crate::CombatView::new(state, buf);
    let totals = view.buff_totals();
    let mut flat_regen_per_second = 0.0;
    let primary_type = state.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_active_aura_effect(state, buf, |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)
}

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(
    state: &mut CombatState,
    buf: &mut DenseBuffer,
    now: SimTime,
    last_sync: &mut SimTime,
    sink: &mut TelemetrySink,
) {
    if now <= *last_sync {
        return;
    }
    // docref:end resources-sync-resource

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

        return;
    }

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

    let dynamic_base_regen = state.runtime.resources.primary_base_regen_override;
    let base_regen = dynamic_base_regen.unwrap_or(state.config.base_stats.base_regen);
    let (effective_regen, max_resource_flat) = effective_primary_regen(
        state,
        buf,
        base_regen,
        state.config.haste_regen || dynamic_base_regen.is_some(),
    );
    let base_max = state.config.base_stats.resource_max;
    let mut gained = 0.0;
    let mut wasted = 0.0;

    if let Some(rt) = state.config.base_stats.resource_type {
        if let Some(res) = buf.resource_mut(rt) {
            res.max = base_max + max_resource_flat;

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

            gained = capped - res.current;
            wasted = uncapped - capped;
            res.current = capped;
            res.regen_per_sec = effective_regen;
        }
    }

    emit_passive_regen(state, buf, 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(
    state: &CombatState,
    buf: &DenseBuffer,
    now: SimTime,
    sink: &mut TelemetrySink,
    gained: f64,
    wasted: f64,
) {
    if gained <= 0.0 && wasted <= 0.0 {
        return;
    }

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

fn sync_runes(
    state: &mut CombatState,
    buf: &mut DenseBuffer,
    now: SimTime,
    last_sync: &mut SimTime,
    sink: &mut TelemetrySink,
) {
    let current = buf
        .resource(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(state, buf, 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(resource) = buf.resource_mut(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");

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

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

    *last_sync = now;
}

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

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

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

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

fn spend_resource_impl(
    state: &mut CombatState,
    buf: &mut DenseBuffer,
    amount: f64,
    secondary: bool,
) -> bool {
    if let Some(rt) = resource_type(state, secondary) {
        if let Some(res) = buf.resource_mut(rt) {
            if !res.spend(amount) {
                return false;
            }

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

            return true;
        }
    }

    false
}

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

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

    if let Some(rt) = resource_type(state, secondary) {
        if let Some(res) = buf.resource_mut(rt) {
            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);
            }

            return (actual, wasted);
        }
    }

    (0.0, amount)
}

pub(crate) fn spend_resource(state: &mut CombatState, buf: &mut DenseBuffer, amount: f64) -> bool {
    spend_resource_impl(state, buf, amount, false)
}

pub(crate) fn gain_resource_from(
    state: &mut CombatState,
    buf: &mut DenseBuffer,
    gain: ResourceGain,
) -> (f64, f64) {
    gain_resource_impl(state, buf, gain, false)
}

pub(crate) fn spend_secondary_resource(
    state: &mut CombatState,
    buf: &mut DenseBuffer,
    amount: f64,
) -> bool {
    spend_resource_impl(state, buf, amount, true)
}

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

pub(crate) fn spend_all_secondary_resource(
    state: &mut CombatState,
    buf: &mut DenseBuffer,
    cost: f64,
) -> f64 {
    if let Some(rt) = resource_type(state, true) {
        if let Some(res) = buf.resource_mut(rt) {
            let available = res.current;

            if available >= cost && res.spend(available) {
                return available;
            }
        }
    }

    0.0
}

pub(crate) fn gain_secondary_resource_from(
    state: &mut CombatState,
    buf: &mut DenseBuffer,
    gain: ResourceGain,
) -> (f64, f64) {
    gain_resource_impl(state, buf, gain, true)
}

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