codegen/

gen_constants.rs

use anyhow::Context as _;
use proc_macro2::TokenStream;
use quote::{format_ident, quote};
use wowlab_manifest_schema::Manifest;

use crate::{
    gen_descriptor::hero_talent_statics,
    rust_source::{documented_u32_constant, inspect_link, lit_int, lit_str, rust_ident},
};

pub(crate) fn effect_constant(
    name: &str,
    spell_id: u32,
    effect: u8,
) -> anyhow::Result<TokenStream> {
    let name = rust_ident(name).context("effect name is not a Rust identifier")?;
    let spell_id = lit_int(spell_id);
    let effect = lit_int(effect);

    Ok(quote! {
        pub(crate) const #name: (u32, u8) = (#spell_id, #effect);
    })
}

pub(crate) fn constants(
    manifest: &Manifest,
    damage_namespace: &TokenStream,
) -> anyhow::Result<TokenStream> {
    let spells = const_module(
        "SPELL",
        manifest
            .spells
            .iter()
            .map(|(name, spell)| (name.as_str(), spell.id)),
        "spell",
    )?;
    let auras = const_module(
        "AURA",
        manifest
            .auras
            .iter()
            .map(|(name, aura)| (name.as_str(), aura.id)),
        "spell",
    )?;
    let talents = (!manifest.talents.is_empty())
        .then(|| {
            const_module(
                "TALENT",
                manifest
                    .talents
                    .iter()
                    .map(|(name, id)| (name.as_str(), *id)),
                "spell",
            )
        })
        .transpose()?;
    let set_bonuses = (!manifest.set_bonuses.is_empty())
        .then(|| {
            const_module(
                "SET_BONUS",
                manifest
                    .set_bonuses
                    .iter()
                    .map(|(name, id)| (name.as_str(), *id)),
                "spell",
            )
        })
        .transpose()?;
    let reported_spells = if manifest.reported_spells.is_empty() {
        TokenStream::new()
    } else {
        let entries = manifest
            .reported_spells
            .iter()
            .map(|(name, id)| documented_u32_constant(&name.to_uppercase(), *id, "spell"))
            .collect::<anyhow::Result<Vec<_>>>()?;

        quote! {
            pub(crate) mod REPORTED_SPELL {
                #(#entries)*
            }
        }
    };
    let hero = hero_constants(manifest)?;
    let damage = damage_constants(manifest, damage_namespace)?;

    Ok(quote! {
        #spells
        #auras
        #talents
        #set_bonuses
        #reported_spells
        #hero
        #damage
    })
}

pub(crate) fn damage_action_expr(namespace: &TokenStream, spell_id: u32) -> TokenStream {
    let action = format_ident!("SPELL_{spell_id}");

    quote!(#namespace::ACTION::#action)
}

pub(crate) fn damage_effect_expr(
    namespace: &TokenStream,
    spell_id: u32,
    effect_index: u8,
) -> TokenStream {
    let effect = format_ident!("SPELL_{spell_id}_EFFECT_{effect_index}");

    quote!(#namespace::EFFECT::#effect)
}

fn damage_constants(
    manifest: &Manifest,
    damage_namespace: &TokenStream,
) -> anyhow::Result<TokenStream> {
    let action = |name: &str, spell_id: u32| {
        let name = rust_ident(name)?;
        let action = damage_action_expr(damage_namespace, spell_id);

        Ok::<_, anyhow::Error>(quote! {
            pub(crate) const #name: wowlab_engine_combat::DamageActionId =
                #action;
        })
    };
    let mut spell_coordinates = manifest
        .spells
        .iter()
        .map(|(name, spell)| (name.as_str(), spell.id))
        .collect::<Vec<_>>();

    for tree in manifest.hero_talents.values() {
        for (name, spell_id) in &tree.spells {
            if !spell_coordinates
                .iter()
                .any(|(candidate, _)| *candidate == name)
            {
                spell_coordinates.push((name.as_str(), *spell_id));
            }
        }
    }

    let spell_entries = spell_coordinates
        .into_iter()
        .map(|(name, spell_id)| action(name, spell_id))
        .collect::<anyhow::Result<Vec<_>>>()?;
    let aura_entries = manifest
        .auras
        .iter()
        .map(|(name, aura)| action(name, aura.id))
        .collect::<anyhow::Result<Vec<_>>>()?;
    let talent_entries = manifest
        .talents
        .iter()
        .map(|(name, spell_id)| action(name, *spell_id))
        .collect::<anyhow::Result<Vec<_>>>()?;
    let reported_entries = manifest
        .reported_spells
        .iter()
        .map(|(name, spell_id)| action(&name.to_uppercase(), *spell_id))
        .collect::<anyhow::Result<Vec<_>>>()?;
    let effect_entries = manifest
        .effects
        .iter()
        .map(|(name, effect)| {
            let name = rust_ident(name)?;
            let effect = damage_effect_expr(damage_namespace, effect.spell_id, effect.effect);

            Ok::<_, anyhow::Error>(quote! {
                pub(crate) const #name: wowlab_engine_combat::DamageEffectId =
                    #effect;
            })
        })
        .collect::<anyhow::Result<Vec<_>>>()?;

    Ok(quote! {
        pub(crate) mod DAMAGE_SPELL {
            #(#spell_entries)*
        }
        pub(crate) mod DAMAGE_AURA {
            #(#aura_entries)*
        }
        pub(crate) mod DAMAGE_TALENT {
            #(#talent_entries)*
        }
        pub(crate) mod DAMAGE_REPORTED {
            #(#reported_entries)*
        }
        pub(crate) mod DAMAGE_EFFECT {
            #(#effect_entries)*
        }
    })
}

fn const_module<'a>(
    module: &str,
    entries: impl Iterator<Item = (&'a str, u32)>,
    url_path: &str,
) -> anyhow::Result<TokenStream> {
    let module = rust_ident(module)?;
    let entries = entries
        .map(|(name, id)| documented_u32_constant(name, id, url_path))
        .collect::<anyhow::Result<Vec<_>>>()?;

    Ok(quote! {
        pub(crate) mod #module {
            #(#entries)*
        }
    })
}

fn hero_constants(manifest: &Manifest) -> anyhow::Result<TokenStream> {
    if manifest.hero_talents.is_empty() {
        return Ok(TokenStream::new());
    }

    let trees = manifest
        .hero_talents
        .iter()
        .map(|(tree_name, tree)| {
            let name = rust_ident(&tree_name.to_uppercase())?;
            let spells = (!tree.spells.is_empty())
                .then(|| {
                    const_module(
                        "SPELL",
                        tree.spells.iter().map(|(name, id)| (name.as_str(), *id)),
                        "spell",
                    )
                })
                .transpose()?;
            let auras = (!tree.auras.is_empty())
                .then(|| {
                    const_module(
                        "AURA",
                        tree.auras.iter().map(|(name, id)| (name.as_str(), *id)),
                        "spell",
                    )
                })
                .transpose()?;

            Ok::<_, anyhow::Error>(quote! {
                pub(crate) mod #name {
                    #spells
                    #auras
                }
            })
        })
        .collect::<anyhow::Result<Vec<_>>>()?;
    let statics = hero_talent_statics(manifest);

    Ok(quote! {
        pub(crate) mod HERO {
            #(#trees)*
        }

        #statics
    })
}

pub(crate) fn talent_table(manifest: &Manifest) -> anyhow::Result<TokenStream> {
    let entries = manifest
        .talents
        .keys()
        .map(|name| {
            let text = lit_str(name);
            let name = rust_ident(name)?;

            Ok::<_, syn::Error>(quote!((#text, TALENT::#name)))
        })
        .collect::<Result<Vec<_>, _>>()?;

    Ok(quote! {
        static TALENTS: &[(&str, u32)] = &[#(#entries,)*];
    })
}

pub(crate) fn local_indices(manifest: &Manifest, module_name: &str) -> anyhow::Result<TokenStream> {
    let module_name = rust_ident(module_name)?;
    let auras = manifest
        .auras
        .keys()
        .map(|name| local_index("AURA", name, "LocalAuraIdx", &module_name))
        .collect::<anyhow::Result<Vec<_>>>()?;
    let aura_guard = count_guard("AURA", manifest.auras.len());
    let spells = manifest
        .spells
        .keys()
        .map(|name| local_index("SPELL", name, "LocalSpellIdx", &module_name))
        .collect::<anyhow::Result<Vec<_>>>()?;
    let spell_guard = count_guard("SPELL", manifest.spells.len());

    Ok(quote! {
        #(#auras)*
        #aura_guard
        #(#spells)*
        #spell_guard
    })
}

fn local_index(
    prefix: &str,
    name: &str,
    index_type: &str,
    module_name: &syn::Ident,
) -> anyhow::Result<TokenStream> {
    let name = format_ident!("{prefix}_{name}");
    let index_type = rust_ident(index_type)?;

    Ok(quote! {
        pub(crate) const #name: #index_type =
            wowlab_engine_combat::generated_identities::specs::#module_name::#name.bind(
                wowlab_engine_combat::generated_identities::specs::#module_name::PROOF
            );
    })
}

fn count_guard(prefix: &str, count: usize) -> TokenStream {
    let name = format_ident!("{prefix}_COUNT");
    let count = lit_int(count);
    let message = lit_str(&format!(
        "{prefix} index ABI: count changed -- update positional hook consumers"
    ));

    quote! {
        pub(crate) const #name: usize = #count;
        const _: () = assert!(#name == #count, #message);
    }
}

pub(crate) fn metric_keys(manifest: &Manifest) -> anyhow::Result<TokenStream> {
    let Some(metric_keys) = manifest
        .metric_keys
        .as_ref()
        .filter(|metric_keys| !metric_keys.keys.is_empty())
    else {
        return Ok(TokenStream::new());
    };
    let module = rust_ident(&metric_keys.module_name)?;
    let entries = metric_keys
        .keys
        .iter()
        .enumerate()
        .map(|(index, key)| {
            let key = rust_ident(key)?;
            let index = lit_int(index);

            Ok::<_, syn::Error>(quote!(pub(crate) const #key: u32 = #index;))
        })
        .collect::<Result<Vec<_>, _>>()?;

    Ok(quote! {
        pub(crate) mod #module {
            #(#entries)*
        }
    })
}

pub(crate) fn effects(manifest: &Manifest) -> anyhow::Result<TokenStream> {
    let effect_module = if manifest.effects.is_empty() {
        TokenStream::new()
    } else {
        let entries = manifest
            .effects
            .iter()
            .map(|(name, effect)| {
                let documentation = lit_str(&inspect_link("spell", effect.spell_id));
                let constant = effect_constant(name, effect.spell_id, effect.effect)?;

                Ok::<_, anyhow::Error>(quote! {
                    #[doc = #documentation]
                    #constant
                })
            })
            .collect::<anyhow::Result<Vec<_>>>()?;

        quote! {
            pub(crate) mod EFFECT {
                #(#entries)*
            }
        }
    };
    let reported_spells = manifest.reported_spells.iter().map(|(name, id)| {
        let name = lit_str(&name.to_lowercase());
        let id = lit_int(id);

        quote!((#name, #id))
    });
    let spell_ids = canonical_damage_spell_ids(manifest);

    let mut aura_ids = manifest
        .auras
        .values()
        .map(|aura| aura.id)
        .collect::<Vec<_>>();

    for tree in manifest.hero_talents.values() {
        aura_ids.extend(tree.auras.values().copied());
    }

    let spell_ids = u32_slice("DECLARED_SPELL_IDS", &spell_ids)?;
    let aura_ids = u32_slice("DECLARED_AURA_IDS", &aura_ids)?;

    Ok(quote! {
        #effect_module

        static REPORTED_SPELLS: &[(&str, u32)] = &[#(#reported_spells,)*];
        #spell_ids
        #aura_ids
    })
}

pub(crate) fn canonical_damage_spell_ids(manifest: &Manifest) -> Vec<u32> {
    let effect_ids = declared_effect_spell_ids(manifest);
    let mut ids = manifest
        .spells
        .values()
        .map(|spell| spell.id)
        .chain(manifest.auras.values().map(|aura| aura.id))
        .chain(manifest.talents.values().copied())
        .chain(manifest.auto_attacks.values().map(|attack| attack.spell_id))
        .chain(effect_ids)
        .chain(manifest.reported_spells.values().copied())
        .collect::<Vec<_>>();

    for tree in manifest.hero_talents.values() {
        ids.extend(tree.spells.values().copied());
        ids.extend(tree.auras.values().copied());
    }

    let mut unique = Vec::with_capacity(ids.len());

    for id in ids {
        if id != 0 && !unique.contains(&id) {
            unique.push(id);
        }
    }

    unique
}

pub(crate) fn declared_effect_spell_ids(manifest: &Manifest) -> Vec<u32> {
    let mut ids = manifest
        .effects
        .values()
        .map(|effect| effect.spell_id)
        .collect::<Vec<_>>();

    ids.extend(
        manifest
            .talent_gated_aura_effects
            .iter()
            .map(|gate| gate.source.spell_id),
    );
    ids.push(manifest.mastery.spell_id);

    let damage_ref_id = |damage: &wowlab_manifest_schema::ManifestDamageDef| match damage {
        wowlab_manifest_schema::ManifestDamageDef::EffectRef { spell_id, .. } => Some(*spell_id),
        _ => None,
    };
    let scalar_ref_id = wowlab_manifest_schema::ScalarRef::effect_spell_id;
    let event_effect_id = |effect: &wowlab_manifest_schema::EventEffectDef| match effect {
        wowlab_manifest_schema::EventEffectDef::Energize { amount, .. } => scalar_ref_id(amount),
        _ => None,
    };

    ids.extend(
        manifest
            .spells
            .values()
            .filter_map(|spell| spell.damage.as_ref())
            .filter_map(damage_ref_id),
    );
    ids.extend(
        manifest
            .spells
            .values()
            .flat_map(wowlab_manifest_schema::ManifestSpellDef::scalar_refs)
            .filter_map(wowlab_manifest_schema::ScalarRef::effect_spell_id),
    );
    ids.extend(manifest.reported_spells.values().copied());
    ids.extend(
        manifest
            .auras
            .values()
            .flat_map(wowlab_manifest_schema::ManifestAuraDef::scalar_refs)
            .filter_map(wowlab_manifest_schema::ScalarRef::effect_spell_id),
    );

    for proc in &manifest.impact_procs {
        ids.extend(scalar_ref_id(&proc.chance_pct));
        ids.extend(proc.effects.iter().filter_map(event_effect_id));
    }

    for spell in manifest.spells.values() {
        let Some(channel) = &spell.channel else {
            continue;
        };

        ids.extend(channel.tick_damage.as_ref().and_then(damage_ref_id));
        ids.extend(channel.tick_cost.as_ref().map(|cost| cost.spell_id));
    }

    ids.sort_unstable();
    ids.dedup();

    ids
}

fn u32_slice(name: &str, ids: &[u32]) -> anyhow::Result<TokenStream> {
    let name = rust_ident(name)?;
    let ids = ids.iter().map(lit_int);

    Ok(quote! {
        static #name: &[u32] = &[#(#ids,)*];
    })
}

#[cfg(test)]
#[path = "gen_constants/tests.rs"]
mod tests;