codegen/

gen_build.rs

use proc_macro2::TokenStream;
use quote::{format_ident, quote};
use wowlab_manifest_schema::Manifest;

use crate::{
    gen_proc::impact_proc_builder,
    helpers::{to_rotation_key, to_snake},
    rust_source::{lit_f64, lit_int, lit_str, rust_ident, rust_path},
};

fn validate_auto_attack_npc(
    auto_attack: &wowlab_manifest_schema::AutoAttackDef,
) -> anyhow::Result<()> {
    anyhow::ensure!(
        auto_attack.npc_id.is_none() || auto_attack.is_pet,
        "auto-attack npc_id requires is_pet = true"
    );

    Ok(())
}

fn auto_attack_expression(
    auto_attack: &wowlab_manifest_schema::AutoAttackDef,
) -> anyhow::Result<TokenStream> {
    validate_auto_attack_npc(auto_attack)?;

    let coefficient = match (auto_attack.ap_coef, auto_attack.pet_power_from_owner) {
        (Some(coefficient), None) => {
            let coefficient = lit_f64(coefficient);

            Some(quote!(#coefficient))
        }
        (None, Some(power_from_owner)) if auto_attack.is_pet => {
            let power_from_owner = lit_f64(power_from_owner);
            let weapon_speed = lit_int(
                auto_attack
                    .pet_weapon_speed_ms
                    .unwrap_or(auto_attack.swing_ms),
            );
            let weapon_multiplier = lit_f64(auto_attack.pet_weapon_multiplier.unwrap_or(1.0));

            Some(quote! {
                wowlab_engine_domain::damage::pet_swing_power_coefficient(
                    #power_from_owner,
                    #weapon_speed,
                    #weapon_multiplier,
                )
            })
        }
        (None, None) if !auto_attack.is_pet => None,
        (None, Some(_)) => anyhow::bail!("pet_power_from_owner requires is_pet = true"),
        _ => {
            anyhow::bail!("pet auto attack requires exactly one of ap_coef or pet_power_from_owner")
        }
    };
    let spell_id = lit_int(auto_attack.spell_id);
    let swing_ms = lit_int(auto_attack.swing_ms);
    let mut expression = quote! {
        a.spell_id(#spell_id)
            .swing_ms(#swing_ms)
            .apply_base_from_data(&params.game_data)
    };

    if let Some(coefficient) = coefficient {
        expression = quote!(#expression.ap_coef(#coefficient));
    }

    if auto_attack.is_pet {
        expression = quote!(#expression.is_pet());
    }

    if let Some(npc_id) = auto_attack.npc_id {
        let npc_id = lit_int(npc_id);

        expression = quote!(#expression.npc_id(#npc_id));
    }

    if auto_attack.uses_spell_power {
        expression = quote!(#expression.uses_spell_power());
    }

    if let Some(crit) = &auto_attack.on_crit_reduce_charge {
        let target = format_ident!("SPELL_{}", crit.target);
        let chance = lit_f64(crit.chance);

        expression = quote!(#expression.on_crit_reduce_charge(#target, #chance));
    }

    if let Some(hook) = &auto_attack.hook {
        let hook = rust_path(hook)?;

        expression = quote!(#expression.on_swing(#hook));
    }

    Ok(expression)
}

pub(crate) fn build_function(
    manifest: &Manifest,
    spec_variant: &str,
    module_name: &str,
) -> anyhow::Result<TokenStream> {
    let pre = pre_items_expression(manifest, spec_variant, module_name)?;

    Ok(quote! {
        pub(crate) fn build_combat_system_draft(
            params: &wowlab_engine_ports::HandlerParams<'_>,
        ) -> Result<CombatSystemDraft, wowlab_engine_ports::EngineError> {
            let builder = #pre;

            let builder = crate::generated::items::register_equipped(
                builder,
                &params.game_data,
                params.equipped_items,
            )?;

            builder.into_draft()
        }
    })
}

fn power_or_data(value: Option<f64>, method: &str, type_id: u8) -> TokenStream {
    value.map_or_else(
        || {
            let method = rust_ident(method).expect("fixed power accessor is a Rust identifier");
            let type_id = lit_int(type_id);
            let message = lit_str(&format!(
                "missing power-type {method} for type_id {type_id}"
            ));

            quote! {
                params.game_data.#method(#type_id).ok_or_else(|| {
                    wowlab_engine_ports::EngineError::spec_construction(#message)
                })?
            }
        },
        |value| {
            let value = lit_f64(value);

            quote!(#value)
        },
    )
}

fn pre_items_expression(
    manifest: &Manifest,
    spec_variant: &str,
    module_name: &str,
) -> anyhow::Result<TokenStream> {
    let type_id = lit_int(manifest.resource.type_id);
    let max = power_or_data(
        manifest.resource.max,
        "power_max",
        manifest.resource.type_id,
    );
    let regen = manifest.resource.regen.map_or_else(
        || {
            let message = lit_str(&format!(
                "missing power-type power_regen_for_max for type_id {}",
                manifest.resource.type_id
            ));

            quote! {
                params.game_data
                    .power_regen_for_max(#type_id, #max)
                    .ok_or_else(|| {
                        wowlab_engine_ports::EngineError::spec_construction(#message)
                    })?
            }
        },
        |regen| {
            let regen = lit_f64(regen);

            quote!(#regen)
        },
    );
    let starts_at = power_or_data(
        manifest.resource.starts_at,
        "power_default",
        manifest.resource.type_id,
    );
    let spec_variant = rust_ident(spec_variant)?;
    let spec_identity_module = rust_ident(module_name)?;
    let mastery_spell = lit_int(manifest.mastery.spell_id);
    let mastery_hook = rust_path(&manifest.mastery.hook)?;
    let resource_name = lit_str(&manifest.resource.name);
    let mut expression = quote! {
        CombatSystemBuilder::new(params.stats.clone())
            .spec_id(SpecId::#spec_variant)
            .spec_identity(wowlab_engine_combat::generated_identities::specs::#spec_identity_module::PROOF)
            .hero_talent_trees(DECLARED_METADATA.hero_talent_trees)
            .effect_identities(
                wowlab_engine_combat::generated_identities::specs::#spec_identity_module::damage::ALL,
            )
            .effect_identities(wowlab_engine_combat::generated_identities::shared::ALL)
            .mastery_spell(#mastery_spell)
            .mastery_hook(#mastery_hook)
            .resource(#resource_name, #max, #regen)
            .resource_type_id(#type_id)
            .resource_start(#starts_at)
    };

    if let Some(hook) = &manifest.mastery.crit_damage_hook {
        let hook = rust_path(hook)?;

        expression = quote!(#expression.mastery_crit_damage_hook(#hook));
    }

    if manifest.spec.has_pet {
        expression = quote!(#expression.has_pet(true));
    }

    if let Some(resource) = &manifest.secondary_resource {
        let max = power_or_data(resource.max, "power_max", resource.type_id);
        let name = lit_str(&resource.name);
        let type_id = lit_int(resource.type_id);

        expression = quote! {
            #expression
                .secondary_resource(#name, #max)
                .secondary_resource_type_id(#type_id)
        };
    }

    if let Some(auras) = &manifest.spec.precombat_auras {
        for name in auras {
            let aura = format_ident!("AURA_{name}");

            expression = quote!(#expression.precombat_aura(#aura));
        }
    }

    if let Some(aura) = &manifest.spec.stealth_aura {
        let aura = rust_ident(aura)?;

        expression = quote!(#expression.stealth_aura(AURA::#aura));
    }

    expression = register_definitions(expression, manifest)?;

    expression = quote!(#expression.game_data(params.game_data.clone()));

    if !manifest.talents.is_empty() {
        expression = quote!(#expression.talent_spell_ids(TALENTS));
    }

    expression = quote!(#expression.talent_selections(params.talent_selections));

    expression = register_talent_content(expression, manifest)?;

    Ok(quote! {
        #expression
            .set_bonus_auras(params.set_bonus_auras)
            .encounter(params.encounter.clone())
    })
}

fn register_definitions(
    mut expression: TokenStream,
    manifest: &Manifest,
) -> anyhow::Result<TokenStream> {
    for name in manifest.auras.keys() {
        let display = lit_str(&to_rotation_key(name));
        let aura = rust_ident(name)?;
        let function = format_ident!("aura_{}", to_snake(name));

        expression = quote! {
            #expression.aura(
                #display,
                AURA::#aura,
                |a| #function(a, &params.game_data),
            )
        };
    }

    for name in manifest.spells.keys() {
        let display = lit_str(&to_rotation_key(name));
        let spell = rust_ident(name)?;
        let function = format_ident!("spell_{}", to_snake(name));

        expression = quote! {
            #expression.spell(
                #display,
                SPELL::#spell,
                |s| #function(s, &params.game_data),
            )
        };
    }

    for auto_attack in manifest.auto_attacks.values() {
        let auto_attack = auto_attack_expression(auto_attack)?;

        expression = quote!(#expression.auto_attack(|a| #auto_attack));
    }

    Ok(expression)
}

fn register_talent_content(
    mut expression: TokenStream,
    manifest: &Manifest,
) -> anyhow::Result<TokenStream> {
    for gate in &manifest.talent_gated_aura_effects {
        let source_aura = manifest
            .auras
            .iter()
            .find_map(|(name, aura)| (aura.id == gate.source.spell_id).then_some(name))
            .ok_or_else(|| {
                anyhow::anyhow!(
                    "talent-gated effect source spell {} is not a declared aura",
                    gate.source.spell_id
                )
            })?;
        let target_aura = gate.target_aura.as_ref().unwrap_or(source_aura);
        let talent = rust_ident(&gate.talent)?;
        let target_aura = format_ident!("AURA_{target_aura}");
        let source_spell = lit_int(gate.source.spell_id);
        let source_effect = lit_int(gate.source.effect);

        expression = quote! {
            #expression.talent_gated_aura_effect(
                TALENT::#talent,
                #target_aura,
                #source_spell,
                #source_effect,
            )
        };
    }

    for (talent, auras) in &manifest.talent_companion_auras {
        let talent = rust_ident(talent)?;

        for aura in auras {
            let aura = format_ident!("AURA_{aura}");

            expression = quote!(#expression.talent_companion_aura(TALENT::#talent, #aura));
        }
    }

    for proc in &manifest.impact_procs {
        let builder = impact_proc_builder(proc)?;

        expression = if let Some(talent) = &proc.talent {
            let talent = rust_ident(talent)?;

            quote! {
                #expression.register_impact_effect_proc_if_talent(TALENT::#talent, #builder)
            }
        } else {
            quote!(#expression.register_impact_effect_proc(#builder))
        };
    }

    Ok(expression)
}

pub(crate) fn handler_factory(manifest: &Manifest) -> anyhow::Result<TokenStream> {
    let finish = if let Some(custom) = &manifest.spec.custom_handler {
        let custom = rust_path(custom)?;

        quote!(#custom)
    } else {
        quote!(|parts, _| parts.into_handler())
    };

    Ok(quote! {
        fn new_handler(
            params: wowlab_engine_ports::HandlerParams<'_>,
        ) -> Result<Box<dyn SpecHandler>, wowlab_engine_ports::EngineError> {
            let handler = crate::composition::compose_handler(
                build_combat_system_draft,
                &params,
                #finish,
            )?;

            Ok(Box::new(handler))
        }
    })
}

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