wowlab_engine_combat/pipeline/

resources.rs

use super::{
    CombatCtx, HUNDRED, ResourceEventKind, ResourceGain, ResourceGainSource, ResourceTelemetry,
    SimTime, SpellData, effective_optional_spell_cost, effective_spell_cost, emit_resource,
    gain_resource_with_procs, process_selected_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.program.resource_threshold_triggers.len();

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

        if spent <= 0.0 {
            continue;
        }

        let Some(resource) = ctx
            .program
            .buffer_resource(ctx.instance, trigger.resource_type)
        else {
            continue;
        };

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

        let ready = ctx
            .program
            .buffer_cooldown(ctx.instance, trigger.spell_local)
            .is_none_or(|cooldown| cooldown.is_ready(ctx.now.as_secs_f64()));

        if !ready {
            continue;
        }

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

        let binding = ctx.program.rotation.local_binding(trigger.spell_local);
        let candidate = crate::handler::can_cast::CastCandidate::resolve_planned(
            ctx.instance,
            binding,
            ctx.target,
        );

        process_selected_cast(ctx, candidate, 0);
        ctx.instance.runtime.resources.last_primary_spent = primary_spent;
        ctx.instance.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 spell's own DBC power-entry maximum would pin
            // every finisher to the untalented five despite talents that raise the pool maximum.
            if secondary_spends_all_points(ctx.program, ctx.instance) {
                spent = spend_all_secondary_resource(ctx.program, ctx.instance, cost, now);
            } else {
                spend_secondary_resource(ctx.program, ctx.instance, cost, now);
            }

            ctx.instance.runtime.resources.last_secondary_spent = spent;
        } else {
            spend_resource(ctx.program, ctx.instance, cost, now);
            ctx.instance.runtime.resources.last_primary_spent = cost;
        }

        emit_resource(
            ctx.program,
            ctx.instance,
            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,
    profile: &crate::state::CastProfile,
    now: SimTime,
) {
    ctx.instance.runtime.resources.last_primary_spent = 0.0;
    ctx.instance.runtime.resources.last_optional_primary_spent = 0.0;
    // docref:start cast-pipeline-process-resources
    let bypass = profile.cost_bypass_aura.is_some_and(|requirement| {
        ctx.program
            .rotation
            .aura_active(ctx.instance, requirement, 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.program, ctx.instance, spell);
    let base_primary_cost = effective_spell_cost(
        &ctx.view(),
        profile.local,
        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(),
            profile.local,
            crate::systems::base_optional_primary_spell_cost(ctx.program, ctx.instance, spell),
            crate::state::ResourcePool::Primary,
        );
        let maximum_cost = effective_spell_cost(
            &ctx.view(),
            profile.local,
            unmodified_primary_cost + optional_primary_cost,
            crate::state::ResourcePool::Primary,
        );
        let current = profile.primary_resource.map_or(0.0, |handle| {
            ctx.instance.buffer.resource_at(handle).current
        });

        optional_cost_spend(base_primary_cost, maximum_cost, current)
    };

    ctx.instance.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(),
            profile.local,
            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.instance,
            ctx.source,
            spell.cost.health_cost,
            spell.cost.health_cost_pct,
        );
        let maximum_health = ctx
            .instance
            .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
            .instance
            .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.instance, ctx.source, realized_cost, 0.0, now);
    }
}

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