wowlab_engine_combat/pipeline/

resources.rs

use super::{
    CombatCtx, HUNDRED, ResourceEventKind, ResourceGain, ResourceGainSource, ResourceTelemetry,
    SimTime, SpellData, bypass_aura_active, effective_optional_spell_cost, effective_spell_cost,
    emit_resource, gain_resource_with_procs, process_cast, secondary_spends_all_points,
    spend_all_secondary_resource, spend_health_cost, spend_resource, spend_secondary_resource,
};

pub(super) fn process_resource_threshold_triggers(ctx: &mut CombatCtx<'_>) {
    let trigger_count = ctx.state.defs.resource_threshold_triggers.len();

    for index in 0..trigger_count {
        // BOUNDS: `index` is bounded by the captured trigger vector length.
        let trigger = ctx.state.defs.resource_threshold_triggers[index];
        let spent =
            if Some(trigger.resource_type) == ctx.state.config.base_stats.secondary_resource_type {
                ctx.state.runtime.resources.last_secondary_spent
            } else {
                ctx.state.runtime.resources.last_primary_spent
            };

        if spent <= 0.0 {
            continue;
        }

        let Some(resource) = ctx.buf.resource(trigger.resource_type) else {
            continue;
        };

        if resource.current >= trigger.threshold {
            continue;
        }

        let spell = *ctx.state.spell(trigger.spell_local);
        let ready = ctx
            .buf
            .cooldown(spell.idx())
            .is_none_or(|cooldown| cooldown.is_ready(ctx.now.as_secs_f64()));

        if !ready {
            continue;
        }

        let primary_spent = ctx.state.runtime.resources.last_primary_spent;
        let secondary_spent = ctx.state.runtime.resources.last_secondary_spent;

        process_cast(ctx, spell.spell_id, 0);
        ctx.state.runtime.resources.last_primary_spent = primary_spent;
        ctx.state.runtime.resources.last_secondary_spent = secondary_spent;
    }
}

pub(super) fn process_single_resource(
    ctx: &mut CombatCtx<'_>,
    cost: f64,
    gain: ResourceGain,
    is_secondary: bool,
    now: SimTime,
    source_spell_id: u32,
) {
    if cost > 0.0 {
        let mut spent = cost;

        if is_secondary {
            // A combo-point cost is a usability floor; the cast consumes every available point.
            // The pool maximum is the only cap — the talents that raise it (Deeper/Devious/Secret/
            // Sanguine Stratagem) are the same ones SimC folds into `consume_cp_max`, so the spell's
            // own DBC power-entry maximum would pin every finisher to the untalented five.
            if secondary_spends_all_points(ctx.state) {
                spent = spend_all_secondary_resource(ctx.state, ctx.buf, cost);
            } else {
                spend_secondary_resource(ctx.state, ctx.buf, cost);
            }

            ctx.state.runtime.resources.last_secondary_spent = spent;
        } else {
            spend_resource(ctx.state, ctx.buf, cost);
            ctx.state.runtime.resources.last_primary_spent = cost;
        }

        emit_resource(
            ctx.state,
            ctx.buf,
            ctx.sink,
            ResourceTelemetry {
                kind: ResourceEventKind::Spend,
                amount: spent,
                secondary: is_secondary,
                now,
                source_spell_id,
            },
        );
    }

    if gain.amount > 0.0 {
        gain_resource_with_procs(ctx, gain, is_secondary);
    }
}

pub(super) fn process_resources(ctx: &mut CombatCtx<'_>, spell: &SpellData, now: SimTime) {
    ctx.state.runtime.resources.last_primary_spent = 0.0;
    ctx.state.runtime.resources.last_optional_primary_spent = 0.0;
    // docref:start cast-pipeline-process-resources
    let bypass = bypass_aura_active(
        ctx.state,
        ctx.buf,
        spell.requirements.cost_bypass_aura_id,
        ctx.source,
        Some(ctx.target),
    );
    let bypass_primary_cost =
        bypass || (spell.channel.behavior.is_channel && spell.channel.tick_cost > 0.0);
    // docref:end cast-pipeline-process-resources
    let unmodified_primary_cost =
        crate::systems::base_primary_spell_cost(ctx.state, ctx.buf, spell);
    let base_primary_cost = effective_spell_cost(
        &ctx.view(),
        spell.spell_id,
        unmodified_primary_cost,
        crate::state::ResourcePool::Primary,
    );
    let primary_cost = if bypass_primary_cost {
        0.0
    } else {
        let optional_primary_cost = effective_optional_spell_cost(
            &ctx.view(),
            spell.spell_id,
            crate::systems::base_optional_primary_spell_cost(ctx.state, ctx.buf, spell),
            crate::state::ResourcePool::Primary,
        );
        let maximum_cost = effective_spell_cost(
            &ctx.view(),
            spell.spell_id,
            unmodified_primary_cost + optional_primary_cost,
            crate::state::ResourcePool::Primary,
        );
        let current = ctx
            .state
            .config
            .base_stats
            .resource_type
            .and_then(|resource_type| ctx.buf.resource(resource_type))
            .map_or(0.0, |resource| resource.current);

        optional_cost_spend(base_primary_cost, maximum_cost, current)
    };

    ctx.state.runtime.resources.last_optional_primary_spent =
        (primary_cost - base_primary_cost).max(0.0);
    process_single_resource(
        ctx,
        primary_cost,
        ResourceGain::modified(
            spell.cost.resource_gain,
            ResourceGainSource::Spell(spell.spell_id),
        ),
        false,
        now,
        spell.spell_id,
    );
    let secondary_cost = if bypass {
        0.0
    } else {
        effective_spell_cost(
            &ctx.view(),
            spell.spell_id,
            spell.cost.secondary_resource_cost,
            crate::state::ResourcePool::Secondary,
        )
    };

    process_single_resource(
        ctx,
        secondary_cost,
        ResourceGain::modified(
            spell.cost.secondary_resource_gain,
            ResourceGainSource::Spell(spell.spell_id),
        ),
        true,
        now,
        spell.spell_id,
    );

    if !bypass
        && (spell.cost.health_cost > 0.0
            || spell.cost.health_cost_pct > 0.0
            || spell.cost.health_max_cost_pct > 0.0
            || spell.cost.health_optional_cost > 0.0
            || spell.cost.health_optional_cost_pct.percent > 0.0)
    {
        let base_cost = crate::systems::spell_health_cost(
            ctx.state,
            ctx.source,
            spell.cost.health_cost,
            spell.cost.health_cost_pct,
        );
        let maximum_health = ctx
            .state
            .friendly_actor_max_health(ctx.source)
            .unwrap_or(0.0);
        let optional_cost = spell.cost.health_optional_cost.max(0.0)
            + spell
                .cost
                .health_optional_cost_pct
                .resolve(0.0, maximum_health);
        let maximum_cost = base_cost
            + optional_cost
            + maximum_health * spell.cost.health_max_cost_pct.max(0.0) / HUNDRED;
        let current_health = ctx.state.friendly_actor_health(ctx.source).unwrap_or(0.0);
        let realized_cost = optional_cost_spend(base_cost, maximum_cost, current_health);

        spend_health_cost(ctx.state, ctx.source, realized_cost, 0.0);
    }
}

pub(super) fn optional_cost_spend(base_cost: f64, maximum_cost: f64, current_resource: f64) -> f64 {
    base_cost
        + (maximum_cost - base_cost)
            .max(0.0)
            .min((current_resource - base_cost).max(0.0))
}