wowlab_engine_combat/systems/buffs/

costs.rs

use super::*;

/// Multiplicative primary-resource gain factor from active auras (aura 213).
pub(crate) fn current_resource_gain_mult(
    view: &CombatView<'_>,
    source: crate::state::ResourceGainSource,
) -> f64 {
    let totals = view.buff_totals();
    let mut multiplier = totals.resource_gain_mult;

    if view.state.config.base_stats.resource_type == Some(wowlab_types::combat::ResourceType::Rage)
        && matches!(source, crate::state::ResourceGainSource::AutoAttack)
    {
        multiplier *= totals.rage_gain_mult;
        multiplier *= view
            .state
            .config
            .game_data
            .power_auto_attack_gain_multiplier(i32::from(u8::from(
                wowlab_types::combat::ResourceType::Rage,
            )));
    }

    multiplier
}

pub(crate) fn effective_spell_cost(
    view: &CombatView<'_>,
    spell_id: u32,
    base_cost: f64,
    pool: ResourcePool,
) -> f64 {
    let CombatView { state, buf, .. } = view;
    let mut percent_mult = 1.0;
    let mut resource_cost_percent = 0.0;
    let mut flat = 0.0;
    let idx = wowlab_types::sim::SpellIdx::from_raw(spell_id);
    let pool_entry = state
        .config
        .game_data
        .cost_entry(idx, pool == ResourcePool::Secondary);
    let pool_type = match pool {
        ResourcePool::Primary => state.config.base_stats.resource_type,
        ResourcePool::Secondary => state.config.base_stats.secondary_resource_type,
    };
    let divisor = pool_type.map_or(1.0, |t| {
        state
            .config
            .game_data
            .power_display_divisor(i32::from(u8::from(t)))
    });

    if let Some(resource_type) = pool_type {
        resource_cost_percent += state
            .config
            .game_data
            .power_cost_percent(i32::from(u8::from(resource_type)));
    }

    for_each_active_aura_effect(state, buf, |stacks, effect| match effect {
        BuffEffect::ResourceCostPercent(value, resource_type)
            if Some(*resource_type) == pool_type =>
        {
            resource_cost_percent += value * stacks;
        }
        BuffEffect::SpellCostPercent(value, spells, effect_pool)
            if *effect_pool == pool && spells.contains(&spell_id) =>
        {
            percent_mult *= 1.0 + value * stacks / HUNDRED;
        }
        BuffEffect::SpellCostFlat(value, spells, effect_pool)
            if *effect_pool == pool && spells.contains(&spell_id) =>
        {
            flat += value * stacks;
        }
        BuffEffect::SpellCostFromEffect {
            value,
            source_spell_id,
            effect_index,
            cost_entry,
            operation,
        } if pool_entry != 0
            && *cost_entry == pool_entry
            && state.config.game_data.effect_affects_spell(
                wowlab_types::sim::SpellIdx::from_raw(*source_spell_id),
                *effect_index,
                idx,
            ) =>
        {
            let points = dbc_effect_points(state, *source_spell_id, *effect_index, stacks);

            match operation {
                ModifierOperation::Flat => flat += value * points / divisor,
                ModifierOperation::Percent => {
                    percent_mult *= 1.0 + value * points / HUNDRED;
                }
                _ => {}
            }
        }
        _ => {}
    });
    percent_mult *= 1.0 + resource_cost_percent / HUNDRED;

    ((base_cost + flat) * percent_mult).max(0.0)
}

pub(crate) fn base_primary_spell_cost(
    state: &CombatState,
    buf: &DenseBuffer,
    spell: &crate::state::SpellData,
) -> f64 {
    let base = state.config.base_stats.resource_max;
    let maximum = state
        .config
        .base_stats
        .resource_type
        .and_then(|resource_type| buf.resource(resource_type))
        .map_or(base, |resource| resource.max);

    spell.cost.resource_cost + spell.cost.resource_cost_pct.resolve(base, maximum)
}

pub(crate) fn base_optional_primary_spell_cost(
    state: &CombatState,
    buf: &DenseBuffer,
    spell: &crate::state::SpellData,
) -> f64 {
    let base = state.config.base_stats.resource_max;
    let maximum = state
        .config
        .base_stats
        .resource_type
        .and_then(|resource_type| buf.resource(resource_type))
        .map_or(base, |resource| resource.max);

    spell.cost.optional_resource_cost
        + spell.cost.optional_resource_cost_pct.resolve(base, maximum)
        + spell.cost.maximum_resource_cost_pct.resolve(base, maximum)
}

pub(crate) fn sync_player_health_from_stamina(state: &mut CombatState, buf: &DenseBuffer) {
    let view = CombatView::new(state, buf);
    let totals = *view.buff_totals();
    let stamina = crate::systems::damage_pipeline::dynamic_stamina(state, &totals);
    let Some(health_per_stamina) = state
        .config
        .game_data
        .health_per_stamina(state.config.game_data.level())
    else {
        return;
    };

    state
        .runtime
        .health
        .player_health
        .set_maximum_clamp_current(stamina.floor() * health_per_stamina);
}

pub(crate) fn effective_optional_spell_cost(
    view: &CombatView<'_>,
    spell_id: u32,
    base_optional_cost: f64,
    pool: ResourcePool,
) -> f64 {
    let CombatView { state, buf, .. } = view;
    let pool_type = match pool {
        ResourcePool::Primary => state.config.base_stats.resource_type,
        ResourcePool::Secondary => state.config.base_stats.secondary_resource_type,
    };
    let Some(pool_type) = pool_type else {
        return base_optional_cost.max(0.0);
    };
    let raw_pool_type = i32::from(u8::from(pool_type));
    let mut adjustment = 0.0;

    let divisor = state.config.game_data.power_display_divisor(raw_pool_type);

    for_each_active_aura_effect(state, buf, |stacks, effect| {
        let BuffEffect::AdditionalPowerCostFromEffect {
            value,
            source_spell_id,
            effect_index,
            resource_type,
        } = effect
        else {
            return;
        };

        if *resource_type == raw_pool_type
            && state.config.game_data.effect_affects_spell(
                wowlab_types::sim::SpellIdx::from_raw(*source_spell_id),
                *effect_index,
                wowlab_types::sim::SpellIdx::from_raw(spell_id),
            )
        {
            adjustment += value * stacks / divisor;
        }
    });

    (base_optional_cost + adjustment).max(0.0)
}

pub(crate) fn sync_spell_costs(state: &CombatState, buf: &mut DenseBuffer) {
    for spell in &state.defs.spells {
        let base_primary_cost = base_primary_spell_cost(state, buf, spell);
        let cost = effective_spell_cost(
            &CombatView::new(state, buf),
            spell.spell_id,
            base_primary_cost,
            ResourcePool::Primary,
        );
        let secondary_cost = effective_spell_cost(
            &CombatView::new(state, buf),
            spell.spell_id,
            spell.cost.secondary_resource_cost,
            ResourcePool::Secondary,
        );

        if let Some(slot) = buf.spell_mut(wowlab_types::sim::SpellIdx::from_raw(spell.spell_id)) {
            slot.cost = cost;
            slot.secondary_cost = secondary_cost;
        }
    }
}