wowlab_engine_content/

raid_buffs.rs

//! Raid-wide buffs and consumables (Bloodlust, potion, flask, food, augment rune) registered post-build at sim start.

use wowlab_engine_combat::{
    AuraData, BuffEffect, BuiltCombatSystem, MAX_AURA_APPLICATION_EXCLUSIONS,
    MAX_AURA_BUFF_EFFECTS, try_push_effect,
};
use wowlab_engine_domain::{
    dbc::{
        AuraSubtypeKind, RatingMultiplierMask, SCALING_CLASS_ARMOR_MULTIPLIED,
        SCALING_CLASS_PRIMARY_STAT, SpellEffectKind, StatModifierKind, aura_subtype_kind,
        spell_effect_is, spell_scaling_budget,
    },
    stats,
};
use wowlab_engine_gamedata::{FoodBuff, ItemBudget, ResolvedGameData};
use wowlab_engine_ports::{CombatStats, EngineError};
use wowlab_types::{
    constants::{BLOODLUST_SPELL_ID, HUNDRED},
    game::RatingType,
    sim::{AuraIdx, AuraKey, AuraOn, SpellIdx},
};

/// Bloodlust's ten-minute lockout aura.
pub(crate) const SATED_SPELL_ID: u32 = 57_724;
/// Heroism's equivalent ten-minute lockout aura.
pub(crate) const EXHAUSTION_SPELL_ID: u32 = 57_723;
const TEMPORAL_DISPLACEMENT_SPELL_ID: u32 = 80_354;
const FATIGUED_SPELL_ID: u32 = 264_689;
const EVOKER_EXHAUSTION_SPELL_ID: u32 = 390_435;
const BLOODLUST_FAMILY: [(u32, u32); MAX_AURA_APPLICATION_EXCLUSIONS] = [
    (BLOODLUST_SPELL_ID, SATED_SPELL_ID),
    (32_182, EXHAUSTION_SPELL_ID),
    (80_353, TEMPORAL_DISPLACEMENT_SPELL_ID),
    (264_667, FATIGUED_SPELL_ID),
    (390_386, EVOKER_EXHAUSTION_SPELL_ID),
];
const BLOODLUST_DURATION_MS: u32 = 40_000;
const BLOODLUST_LOCKOUT_DURATION_MS: u32 = 600_000;
const BLOODLUST_HASTE_EFFECT: u8 = 1;

const POTION_FALLBACK_DURATION_MS: u32 = 30_000;
const CONSUMABLE_FALLBACK_DURATION_MS: u32 = 3_600_000;

const CONSUMABLE_MAX_EFFECT: u8 = 10;

fn rating_type_from_mask(misc: i32) -> Option<RatingType> {
    let mask = RatingMultiplierMask::from_bits_retain(misc);

    if mask == RatingMultiplierMask::CRIT {
        Some(RatingType::Crit)
    } else if mask == RatingMultiplierMask::HASTE {
        Some(RatingType::Haste)
    } else if mask == RatingMultiplierMask::VERSATILITY {
        Some(RatingType::Versatility)
    } else if mask == RatingMultiplierMask::MASTERY {
        Some(RatingType::Mastery)
    } else {
        None
    }
}

fn primary_stat_budget(data: &ResolvedGameData) -> Result<f64, EngineError> {
    let level = data.level();

    spell_scaling_budget(data.game_tables(), SCALING_CLASS_PRIMARY_STAT, level).ok_or_else(|| {
        EngineError::spec_construction(format!(
            "spell scaling budget (class {SCALING_CLASS_PRIMARY_STAT}) missing for level {level}"
        ))
    })
}

fn rating_stat_budget(data: &ResolvedGameData) -> Result<f64, EngineError> {
    let level = data.level();

    spell_scaling_budget(data.game_tables(), SCALING_CLASS_ARMOR_MULTIPLIED, level).ok_or_else(
        || {
            EngineError::spec_construction(format!(
                "spell scaling budget (class {SCALING_CLASS_ARMOR_MULTIPLIED}) missing for level {level}"
            ))
        },
    )
}

pub(crate) fn rating_percent_points(
    data: &ResolvedGameData,
    rating_type: RatingType,
    amount: f64,
) -> Result<f64, EngineError> {
    stats::rating_percent_points(data, rating_type, amount).map_err(|error| {
        EngineError::spec_construction(format!("rating conversion failed: {error}"))
    })
}

fn rating_buff_effect(
    lookup: wowlab_engine_domain::dbc::EffectLookup<'_>,
    rating_type: RatingType,
    amount: f64,
) -> Result<BuffEffect, EngineError> {
    let data = lookup.data;
    let spell_id = lookup.effect.spell.as_u32();
    let effect_index = lookup.effect.effect_index;
    let percent = amount.signum() * rating_percent_points(data, rating_type, amount.abs())?;

    Ok(match rating_type {
        RatingType::Crit => BuffEffect::Crit(percent),
        RatingType::Haste => BuffEffect::Haste(percent),
        RatingType::Versatility => BuffEffect::Versatility(percent),
        RatingType::Mastery => BuffEffect::Mastery(percent),
        RatingType::Leech | RatingType::Avoidance | RatingType::Speed => {
            return Err(EngineError::spec_construction(format!(
                "unmodelled tertiary rating {rating_type:?} for spell {spell_id} effect {effect_index}"
            )));
        }
    })
}

fn clamp_rating_penalty(current_rating: f64, rating_delta: f64) -> f64 {
    rating_delta.max(-current_rating.max(0.0))
}

pub(crate) type BuildBuffEffectsFn =
    fn(&ResolvedGameData) -> Result<[Option<BuffEffect>; MAX_AURA_BUFF_EFFECTS], EngineError>;

#[derive(Clone, Copy, Debug)]
enum ConsumableSlot {
    Potion,
    Flask,
    Food,
    AugmentRune,
}

#[derive(Clone, Copy, Debug)]
enum BuffSource {
    Fixed {
        spell_id: u32,
        name: &'static str,
        fallback_duration_ms: u32,
        build_effects: BuildBuffEffectsFn,
    },
    Consumable(ConsumableSlot),
}

/// Table-row describing one precombat buff (racial, raid buff, or consumable slot).
#[derive(Clone, Copy, Debug)]
pub(crate) struct PrecombatBuffSpec {
    source: BuffSource,
}

impl PrecombatBuffSpec {
    /// A precombat buff for a fixed spell id with a bespoke effect builder.
    pub(crate) const fn fixed(
        spell_id: u32,
        name: &'static str,
        fallback_duration_ms: u32,
        build_effects: BuildBuffEffectsFn,
    ) -> Self {
        Self {
            source: BuffSource::Fixed {
                spell_id,
                name,
                fallback_duration_ms,
                build_effects,
            },
        }
    }

    const fn consumable(slot: ConsumableSlot) -> Self {
        Self {
            source: BuffSource::Consumable(slot),
        }
    }
}

fn consumable_effect_at(
    lookup: wowlab_engine_domain::dbc::EffectLookup<'_>,
    item_budget: Option<ItemBudget>,
) -> Result<Option<BuffEffect>, EngineError> {
    let data = lookup.data;
    let idx = lookup.effect.spell;
    let effect_index = lookup.effect.effect_index;

    if !spell_effect_is(lookup.effect_type(), SpellEffectKind::ApplyAura) {
        return Ok(None);
    }

    let coef = lookup.coefficient();
    let rating_effect = |rating: RatingType| -> Result<Option<BuffEffect>, EngineError> {
        let budget = match item_budget {
            Some(b) => b.rating,
            None => rating_stat_budget(data)?,
        };

        Ok(Some(rating_buff_effect(lookup, rating, coef * budget)?))
    };

    match aura_subtype_kind(data.effect_aura(idx, effect_index)) {
        Some(AuraSubtypeKind::ModRating) if coef > 0.0 => {
            let misc = data.effect_misc_value_0(idx, effect_index);

            rating_effect(rating_type_from_mask(misc).unwrap_or(RatingType::Crit))
        }
        Some(AuraSubtypeKind::PeriodicDummy) if coef > 0.0 => rating_effect(RatingType::Crit),
        Some(AuraSubtypeKind::ModStat)
            if coef > 0.0
                && data.effect_misc_value_0(idx, effect_index)
                    != StatModifierKind::Stamina as i32 =>
        {
            let budget = match item_budget {
                Some(b) => b.stat,
                None => primary_stat_budget(data)?,
            };

            Ok(Some(BuffEffect::PrimaryStat(coef * budget)))
        }
        Some(AuraSubtypeKind::ModTotalStatPercentage) => {
            let pct = data.base_points(idx, effect_index);

            Ok((pct > 0.0).then_some(BuffEffect::PrimaryStatPercent(pct)))
        }
        _ => Ok(None),
    }
}

fn consumable_stat_effects(
    data: &ResolvedGameData,
    spell_id: u32,
    item_budget: Option<ItemBudget>,
    stats: &CombatStats,
) -> Result<[Option<BuffEffect>; MAX_AURA_BUFF_EFFECTS], EngineError> {
    let idx = SpellIdx::from_raw(spell_id);
    let rating_effects = (1..=CONSUMABLE_MAX_EFFECT)
        .filter(|&effect_index| {
            spell_effect_is(
                data.effect_type(idx, effect_index),
                SpellEffectKind::ApplyAura,
            ) && aura_subtype_kind(data.effect_aura(idx, effect_index))
                == Some(AuraSubtypeKind::ModRating)
                && data.coefficient(idx, effect_index).abs() > f64::EPSILON
        })
        .filter_map(|effect_index| {
            let rating = rating_type_from_mask(data.effect_misc_value_0(idx, effect_index))?;

            Some((effect_index, rating, data.coefficient(idx, effect_index)))
        })
        .collect::<Vec<_>>();

    if rating_effects.iter().any(|(_, _, coef)| *coef < 0.0) {
        return selected_secondary_effects(data, spell_id, item_budget, stats, &rating_effects);
    }

    let mut effects = [None; MAX_AURA_BUFF_EFFECTS];

    for effect_index in 1..=CONSUMABLE_MAX_EFFECT {
        if let Some(effect) = consumable_effect_at(
            wowlab_engine_domain::dbc::EffectLookup::new(
                data,
                wowlab_types::sim::EffectRef::new(idx, effect_index),
            ),
            item_budget,
        )? {
            try_push_effect(&mut effects, effect).map_err(|e| {
                // #t(rust_alloc_in_loop) format! only fires on the error path (effect-array overflow)
                EngineError::spec_construction(format!(
                    "consumable spell {spell_id} has more stat effects than MAX_AURA_BUFF_EFFECTS: {e:?}"
                ))
            })?;
        }
    }

    if effects[0].is_none() && !data.is_empty() {
        return Err(EngineError::spec_construction(format!(
            "consumable spell {spell_id} has no modelled stat effects (aura kinds 189/226/29/137)"
        )));
    }

    Ok(effects)
}

fn selected_secondary_effects(
    data: &ResolvedGameData,
    spell_id: u32,
    item_budget: Option<ItemBudget>,
    stats: &CombatStats,
    rating_effects: &[(u8, RatingType, f64)],
) -> Result<[Option<BuffEffect>; MAX_AURA_BUFF_EFFECTS], EngineError> {
    // SimC's `util::highest_stat`/`lowest_stat` rank by RATING, not by percent
    // points (per-stat divisors and the mastery coefficient would reorder a
    // percent comparison). Estimate each stat's rating by dividing its
    // above-base percent by the stat's per-rating conversion.
    let base_stat = |rating| match rating {
        RatingType::Crit => wowlab_engine_domain::constants::BASE_CRIT_CHANCE * HUNDRED,
        RatingType::Mastery => stats::BASE_MASTERY_POINTS,
        _ => 0.0,
    };
    let estimated_rating = |rating: RatingType| -> Result<f64, EngineError> {
        let per_hundred = rating_percent_points(data, rating, HUNDRED)?;

        if per_hundred.abs() < f64::EPSILON {
            return Ok(0.0);
        }

        let value = match rating {
            RatingType::Crit => stats.crit_chance,
            RatingType::Haste => stats.haste,
            RatingType::Mastery => stats.mastery,
            RatingType::Versatility => stats.versatility,
            RatingType::Leech | RatingType::Avoidance | RatingType::Speed => 0.0,
        };

        Ok((value - base_stat(rating)).max(0.0) * HUNDRED / per_hundred)
    };
    let mut ranked = Vec::with_capacity(rating_effects.len());

    for entry in rating_effects {
        ranked.push((entry, estimated_rating(entry.1)?));
    }

    let positive = ranked
        .iter()
        .filter(|((_, _, coef), _)| *coef > 0.0)
        .max_by(|(_, left), (_, right)| left.total_cmp(right));
    let negative = ranked
        .iter()
        .filter(|((_, _, coef), _)| *coef < 0.0)
        .min_by(|(_, left), (_, right)| left.total_cmp(right));
    let selected = [
        positive.map(|(entry, rating)| (**entry, *rating)),
        negative.map(|(entry, rating)| (**entry, *rating)),
    ];
    let budget =
        item_budget.map_or_else(|| rating_stat_budget(data), |budget| Ok(budget.rating))?;
    let mut effects = [None; MAX_AURA_BUFF_EFFECTS];

    for ((effect_index, rating, coefficient), current_rating) in selected.into_iter().flatten() {
        // SimC converts the total rating through curve 21024. Values below the
        // curve's first point clamp to zero, so a selected-stat penalty cannot
        // turn a zero (or smaller-than-penalty) rating into a negative percent.
        let amount = clamp_rating_penalty(current_rating, coefficient * budget);
        let effect = rating_buff_effect(
            wowlab_engine_domain::dbc::EffectLookup::new(
                data,
                wowlab_types::sim::EffectRef::new(SpellIdx::from_raw(spell_id), effect_index),
            ),
            rating,
            amount,
        )?;

        try_push_effect(&mut effects, effect)
        .map_err(|error| {
            // #t(rust_alloc_in_loop) allocation occurs only while returning a bounded construction error.
            EngineError::spec_construction(format!(
                "consumable spell {spell_id} selected more stat effects than MAX_AURA_BUFF_EFFECTS: {error:?}"
            ))
        })?;
    }

    Ok(effects)
}

fn food_effects(
    data: &ResolvedGameData,
    food: &FoodBuff,
) -> Result<[Option<BuffEffect>; MAX_AURA_BUFF_EFFECTS], EngineError> {
    let coef = data.coefficient(SpellIdx::from_raw(food.coeff_spell_id), food.coeff_effect);

    if coef <= 0.0 && !data.is_empty() {
        return Err(EngineError::spec_construction(format!(
            "food coefficient missing: spell {} effect {} for '{}'",
            food.coeff_spell_id, food.coeff_effect, food.name
        )));
    }

    let mut effects = [None; MAX_AURA_BUFF_EFFECTS];

    effects[0] = Some(BuffEffect::PrimaryStat(
        coef * primary_stat_budget(data)? * food.amount_multiplier,
    ));

    Ok(effects)
}

fn register_buff_aura(
    built: &mut BuiltCombatSystem,
    data: &ResolvedGameData,
    spell_id: u32,
    name: &str,
    fallback_duration_ms: u32,
    build_effects: impl FnOnce() -> Result<[Option<BuffEffect>; MAX_AURA_BUFF_EFFECTS], EngineError>,
) -> Result<(), EngineError> {
    let key = AuraKey::new(
        AuraIdx(spell_id),
        wowlab_types::sim::ActorId::Player,
        wowlab_types::sim::ActorId::Player,
        AuraOn::Player,
    );
    let effects = build_effects()?;

    if let Some(existing_local) = built.state.aura_local(spell_id) {
        if !built.patch_aura(existing_local, |aura| aura.effects = effects) {
            return Err(EngineError::spec_construction(format!(
                "registered aura {spell_id} has no definition"
            )));
        }

        built.set_precombat_aura(existing_local, true);

        built.buffer.ensure_aura_slot(key);

        return Ok(());
    }

    let duration_ms = match data
        .aura_duration_ms(SpellIdx::from_raw(spell_id))
        .unwrap_or(0)
    {
        0 => {
            tracing::warn!(
                spell_id,
                fallback_duration_ms,
                "aura duration missing; using fallback"
            );

            fallback_duration_ms
        }
        d => d,
    };

    let aura = AuraData::simple_player_buff(spell_id, 0, duration_ms, effects);
    let local = built.register_aura(name, aura)?;

    built.push_precombat_aura(local);

    Ok(())
}

fn register_consumable(
    built: &mut BuiltCombatSystem,
    data: &ResolvedGameData,
    slot: ConsumableSlot,
) -> Result<(), EngineError> {
    let consumables = data.consumable_spells();

    match slot {
        ConsumableSlot::Potion => match &consumables.potion {
            None => Ok(()),
            Some(buff) => {
                let effects = consumable_stat_effects(
                    data,
                    buff.spell_id,
                    buff.item_budget,
                    built.base_combat_stats(),
                )?;

                register_buff_aura(
                    built,
                    data,
                    buff.spell_id,
                    &buff.name,
                    POTION_FALLBACK_DURATION_MS,
                    || Ok(effects),
                )
            }
        },
        ConsumableSlot::Flask => match &consumables.flask {
            None => Ok(()),
            Some(buff) => {
                let effects = consumable_stat_effects(
                    data,
                    buff.spell_id,
                    buff.item_budget,
                    built.base_combat_stats(),
                )?;

                register_buff_aura(
                    built,
                    data,
                    buff.spell_id,
                    &buff.name,
                    CONSUMABLE_FALLBACK_DURATION_MS,
                    || Ok(effects),
                )
            }
        },
        ConsumableSlot::AugmentRune => match &consumables.augment_rune {
            None => Ok(()),
            Some(buff) => {
                let effects = consumable_stat_effects(
                    data,
                    buff.spell_id,
                    buff.item_budget,
                    built.base_combat_stats(),
                )?;

                register_buff_aura(
                    built,
                    data,
                    buff.spell_id,
                    &buff.name,
                    CONSUMABLE_FALLBACK_DURATION_MS,
                    || Ok(effects),
                )
            }
        },
        ConsumableSlot::Food => match &consumables.food {
            None => Ok(()),
            Some(food) => register_buff_aura(
                built,
                data,
                food.spell_id,
                &food.name,
                CONSUMABLE_FALLBACK_DURATION_MS,
                || food_effects(data, food),
            ),
        },
    }
}

pub(crate) fn register_precombat_buff(
    built: &mut BuiltCombatSystem,
    data: &ResolvedGameData,
    spec: &PrecombatBuffSpec,
) -> Result<(), EngineError> {
    match spec.source {
        BuffSource::Fixed {
            spell_id,
            name,
            fallback_duration_ms,
            build_effects,
        } => {
            let family_lockout = BLOODLUST_FAMILY
                .iter()
                .find_map(|(family_spell_id, lockout)| {
                    (*family_spell_id == spell_id).then_some(*lockout)
                });

            if family_lockout.is_some() {
                for (_, lockout_aura_id) in BLOODLUST_FAMILY {
                    register_buff_aura(
                        built,
                        data,
                        lockout_aura_id,
                        "Bloodlust Lockout",
                        BLOODLUST_LOCKOUT_DURATION_MS,
                        || Ok([None; MAX_AURA_BUFF_EFFECTS]),
                    )?;

                    if let Some(local) = built.state.aura_local(lockout_aura_id) {
                        built.set_precombat_aura(local, false);
                    }
                }
            }

            register_buff_aura(built, data, spell_id, name, fallback_duration_ms, || {
                build_effects(data)
            })?;

            if let Some(lockout_aura_id) = family_lockout {
                let local = built.state.aura_local(spell_id).ok_or_else(|| {
                    EngineError::spec_construction("Bloodlust-family aura registration was lost")
                })?;

                if !built.patch_aura(local, |aura| {
                    aura.application_excluded_auras =
                        BLOODLUST_FAMILY.map(|(_, family_lockout)| family_lockout);
                    aura.application_followup_aura_id = lockout_aura_id;
                }) {
                    return Err(EngineError::spec_construction(
                        "Bloodlust-family aura registration has no definition",
                    ));
                }
            }

            Ok(())
        }
        BuffSource::Consumable(slot) => register_consumable(built, data, slot),
    }
}

/// Register every spec in `specs` onto `built`, then the data-selected food buff; idempotent per spell id.
///
/// # Errors
///
/// Returns an engine construction error when a selected buff cannot be resolved or registered.
pub(crate) fn register_precombat_buffs(
    built: &mut BuiltCombatSystem,
    data: &ResolvedGameData,
    specs: &[PrecombatBuffSpec],
) -> Result<(), EngineError> {
    for spec in specs {
        register_precombat_buff(built, data, spec)?;
    }

    register_consumable(built, data, ConsumableSlot::Food)
}

#[expect(
    clippy::unnecessary_wraps,
    reason = "precombat effect factories share a fallible callback signature"
)]
fn bloodlust_effects(
    data: &ResolvedGameData,
) -> Result<[Option<BuffEffect>; MAX_AURA_BUFF_EFFECTS], EngineError> {
    let haste = data.base_points(
        SpellIdx::from_raw(BLOODLUST_SPELL_ID),
        BLOODLUST_HASTE_EFFECT,
    );
    let mut effects = [None; MAX_AURA_BUFF_EFFECTS];

    effects[0] = Some(BuffEffect::HasteMult(haste));

    Ok(effects)
}

fn external_buff_effects(
    data: &ResolvedGameData,
    spell_id: u32,
) -> Result<[Option<BuffEffect>; MAX_AURA_BUFF_EFFECTS], EngineError> {
    let spell = SpellIdx::from_raw(spell_id);
    let mut effects = [None; MAX_AURA_BUFF_EFFECTS];

    for effect_index in 1..=data.max_effect_index(spell) {
        let subtype = aura_subtype_kind(data.effect_aura(spell, effect_index));
        let effect = match subtype {
            Some(AuraSubtypeKind::HasteAll | AuraSubtypeKind::ModSpellHastePercent) => {
                Some(BuffEffect::HasteMult(data.base_points(spell, effect_index)))
            }
            Some(AuraSubtypeKind::ModAllCritChance | AuraSubtypeKind::ModSpellCritChance) => {
                Some(BuffEffect::Crit(data.base_points(spell, effect_index)))
            }
            Some(AuraSubtypeKind::ModMasteryPercent) => {
                Some(BuffEffect::Mastery(data.base_points(spell, effect_index)))
            }
            _ => None,
        };

        if let Some(effect) = effect {
            try_push_effect(&mut effects, effect).map_err(|error| {
                // #t(rust_alloc_in_loop) allocation occurs only while returning a bounded construction error.
                EngineError::spec_construction(format!(
                    "external buff {spell_id} exceeds MAX_AURA_BUFF_EFFECTS: {error:?}"
                ))
            })?;
        }
    }

    Ok(effects)
}

/// Register run-configured external buffs without making them precombat auras.
///
/// # Errors
///
/// Returns a construction error when DBC effects or registry capacity are invalid.
pub(crate) fn register_external_buffs(
    built: &mut BuiltCombatSystem,
    data: &ResolvedGameData,
    configs: &[wowlab_engine_ports::ExternalBuffConfig],
) -> Result<(), EngineError> {
    for config in configs {
        register_buff_aura(
            built,
            data,
            config.spell_id,
            "External Buff",
            wowlab_types::numeric::f64_to_u32_saturating_round(
                config.schedule.duration * wowlab_types::constants::MS_PER_SECOND,
            ),
            || external_buff_effects(data, config.spell_id),
        )?;

        if let Some(local) = built.state.aura_local(config.spell_id) {
            built.set_precombat_aura(local, false);
        }
    }

    Ok(())
}

/// Bloodlust (2825) precombat-buff spec.
pub(crate) const fn bloodlust_spec() -> PrecombatBuffSpec {
    PrecombatBuffSpec::fixed(
        BLOODLUST_SPELL_ID,
        "Bloodlust",
        BLOODLUST_DURATION_MS,
        bloodlust_effects,
    )
}

/// The sim's selected potion prepot.
#[must_use]
pub(crate) const fn tempered_potion_spec() -> PrecombatBuffSpec {
    PrecombatBuffSpec::consumable(ConsumableSlot::Potion)
}

/// The sim's selected flask.
#[must_use]
pub(crate) const fn flask_spec() -> PrecombatBuffSpec {
    PrecombatBuffSpec::consumable(ConsumableSlot::Flask)
}

/// The sim's selected augment rune.
#[must_use]
pub(crate) const fn augment_rune_spec() -> PrecombatBuffSpec {
    PrecombatBuffSpec::consumable(ConsumableSlot::AugmentRune)
}

#[cfg(test)]
#[expect(
    clippy::float_cmp,
    reason = "buff registration tests assert exact authored fixture values"
)]
mod tests;