codegen/

gen_aura_modifiers.rs

//! Emission of per-stack, rating, and spell-scoped aura modifiers.

use anyhow::bail;
use proc_macro2::TokenStream;
use quote::{format_ident, quote};
use wowlab_manifest_schema::{ManifestAuraDef, ScalarRef};

use crate::{
    gen_aura::AuraEmitOptions,
    gen_emit::scalar_ref_call,
    rust_source::{lit_int, rust_ident},
};

fn budget_scaled_expr(
    def: &ManifestAuraDef,
    scalar: &ScalarRef,
    budget_field: &str,
) -> anyhow::Result<TokenStream> {
    let scalar = scalar_ref_call(scalar)?;
    let budget_field = rust_ident(budget_field)?;
    let base = quote!(#scalar * budget.#budget_field);

    if !def.split_across_stacks {
        return Ok(base);
    }

    let stacks = def.max_stacks.as_ref().ok_or_else(|| {
        anyhow::anyhow!(
            "split_across_stacks on aura {} requires an explicit max_stacks",
            def.id
        )
    })?;
    let stacks = scalar_ref_call(stacks)?;

    Ok(quote!((#base) / (#stacks)))
}

pub(super) fn apply_per_stack_scalars(
    mut expression: TokenStream,
    def: &ManifestAuraDef,
) -> anyhow::Result<TokenStream> {
    let fields = [
        ("max_resource_per_stack", &def.max_resource_per_stack),
        ("regen_percent_per_stack", &def.regen_percent_per_stack),
        ("haste_per_stack", &def.haste_per_stack),
        ("attack_speed_per_stack", &def.attack_speed_per_stack),
        (
            "auto_attack_damage_per_stack",
            &def.auto_attack_damage_per_stack,
        ),
        (
            "resource_gain_mult_per_stack",
            &def.resource_gain_mult_per_stack,
        ),
        ("crit_per_stack", &def.crit_per_stack),
        ("mastery_per_stack", &def.mastery_per_stack),
    ];

    for (method, value) in fields {
        if let Some(value) = value {
            let method = format_ident!("{method}");
            let value = scalar_ref_call(value)?;

            expression = quote!(#expression.#method(#value)?);
        }
    }

    if let Some(value) = &def.damage_taken_from_caster_spells {
        let value = scalar_ref_call(value)?;

        expression = quote!(#expression.damage_taken_from_caster_spells(data, #value)?);
    }

    Ok(expression)
}

fn spell_ids(
    method: &str,
    names: &[String],
    aura_id: u32,
    options: &AuraEmitOptions<'_>,
) -> anyhow::Result<Vec<syn::LitInt>> {
    if names.is_empty() {
        bail!("{method} on aura {aura_id} requires a non-empty spells list");
    }

    names
        .iter()
        .map(|name| {
            options
                .spell_id_map
                .get(name.as_str())
                .copied()
                .map(lit_int)
                .ok_or_else(|| {
                    anyhow::anyhow!(
                        "{method} spell {name:?} on aura {aura_id} has no spell binding"
                    )
                })
        })
        .collect()
}

fn spell_scoped_call(
    expression: &TokenStream,
    method: &str,
    value: &ScalarRef,
    spells: &[String],
    aura_id: u32,
    options: &AuraEmitOptions<'_>,
) -> anyhow::Result<TokenStream> {
    let method_name = method;
    let method = rust_ident(method)?;
    let value = scalar_ref_call(value)?;
    let spell_ids = spell_ids(method_name, spells, aura_id, options)?;

    Ok(quote!(#expression.#method(#value, &[#(#spell_ids,)*])?))
}

pub(super) fn apply_spell_scoped_effects(
    mut expression: TokenStream,
    def: &ManifestAuraDef,
    options: &AuraEmitOptions<'_>,
) -> anyhow::Result<TokenStream> {
    let scoped = [
        ("crit_chance_spells", &def.crit_chance_spells),
        ("crit_damage_spells", &def.crit_damage_spells),
        ("damage_percent_spells", &def.damage_percent_spells),
        (
            "damage_percent_spells_linear",
            &def.damage_percent_spells_linear,
        ),
        ("cast_time_percent", &def.cast_time_percent),
        (
            "cast_time_percent_per_stack",
            &def.cast_time_percent_per_stack,
        ),
        ("gcd_percent", &def.gcd_percent),
    ];

    for (method, field) in scoped {
        if let Some(value) = field {
            expression = spell_scoped_call(
                &expression,
                method,
                &value.pct,
                &value.spells,
                def.id,
                options,
            )?;
        }
    }

    let singular = [
        ("spell_cost_flat", &def.spell_cost_flat),
        ("spell_cost_percent", &def.spell_cost_percent),
        (
            "secondary_spell_cost_percent",
            &def.secondary_spell_cost_percent,
        ),
        ("secondary_spell_cost_flat", &def.secondary_spell_cost_flat),
    ];

    for (method, field) in singular {
        if let Some(value) = field {
            expression = spell_scoped_call(
                &expression,
                method,
                &value.value,
                &value.spells,
                def.id,
                options,
            )?;
        }
    }

    for value in &def.recharge_rate_percent {
        expression = spell_scoped_call(
            &expression,
            "recharge_rate_percent",
            &value.value,
            &value.spells,
            def.id,
            options,
        )?;
    }

    Ok(expression)
}

pub(super) fn apply_rating_effects(
    mut expression: TokenStream,
    def: &ManifestAuraDef,
    options: &AuraEmitOptions<'_>,
) -> anyhow::Result<TokenStream> {
    let rating_fields = [
        (&def.crit_rating_per_stack, format_ident!("Crit")),
        (&def.haste_rating_per_stack, format_ident!("Haste")),
        (&def.mastery_rating_per_stack, format_ident!("Mastery")),
        (
            &def.versatility_rating_per_stack,
            format_ident!("Versatility"),
        ),
    ];
    let uses_budget = rating_fields.iter().any(|(field, _)| field.is_some())
        || def.primary_stat_per_stack.is_some();

    if uses_budget && !options.has_item_budget {
        bail!(
            "budget-scaled aura fields are items-manifest-only (aura {})",
            def.id
        );
    }

    for (field, rating) in rating_fields {
        if let Some(scalar) = field {
            let amount = budget_scaled_expr(def, scalar, "rating")?;

            expression = quote! {
                #expression.rating_per_stack(
                    data,
                    wowlab_types::game::RatingType::#rating,
                    #amount,
                )?
            };
        }
    }

    if let Some(scalar) = &def.primary_stat_per_stack {
        let amount = budget_scaled_expr(def, scalar, "stat")?;

        expression = quote!(#expression.primary_per_stack(#amount)?);
    }

    Ok(expression)
}