wowlab_engine_content/hooks/

mod.rs

pub(crate) fn gated<T>(enabled: bool, derive: impl FnOnce() -> T) -> T
where
    T: Default,
{
    if enabled { derive() } else { T::default() }
}

pub(crate) fn try_gated<T, E>(enabled: bool, derive: impl FnOnce() -> Result<T, E>) -> Result<T, E>
where
    T: Default,
{
    if enabled { derive() } else { Ok(T::default()) }
}

pub(crate) fn gated_or<T>(enabled: bool, fallback: T, derive: impl FnOnce() -> T) -> T {
    if enabled { derive() } else { fallback }
}

macro_rules! define_spec_handler {
    (
        impl $handler:ident($this:ident, $inner:ident) {
            $(
                $(#[$custom_meta:meta])*
                fn $custom_name:ident $custom_args:tt $(-> $custom_return:ty)? $custom_body:block
            )*
        }
    ) => {
        impl wowlab_engine_ports::SpecHandler for $handler {
            $(
                $(#[$custom_meta])*
                fn $custom_name $custom_args $(-> $custom_return)? $custom_body
            )*
            wowlab_engine_ports::delegate_spec_handler!(
                $inner;
                skip [$($custom_name),*]
            );
        }
    };
    (
        impl $handler:ident($this:ident, $inner:ident) {
            $(
                $(#[$custom_meta:meta])*
                fn $custom_name:ident $custom_args:tt $(-> $custom_return:ty)? $custom_body:block
            )*
        }
        delegate {
            $(
                fn $delegated_name:ident $delegated_args:tt $(-> $delegated_return:ty)?;
            )*
        }
    ) => {
        impl wowlab_engine_ports::SpecHandler for $handler {
            $(
                $(#[$custom_meta])*
                fn $custom_name $custom_args $(-> $custom_return)? $custom_body
            )*
            delegate::delegate! {
                to $this.$inner {
                    $(
                        fn $delegated_name $delegated_args $(-> $delegated_return)?;
                    )*
                }
            }
            wowlab_engine_ports::delegate_spec_handler!(
                $inner;
                skip [$($custom_name,)* $($delegated_name),*]
            );
        }
    };
}

pub(crate) use define_spec_handler;

macro_rules! define_spec_module {
    (modules [$($module:ident),+ $(,)?]; exports { $($export:item)* }) => {
        $(mod $module;)+
        $($export)*
    };
}

pub(crate) use define_spec_module;

macro_rules! define_spec_config {
    (
        $(#[$config_meta:meta])*
        $vis:vis struct $config:ident {
            $(
                $(#[$field_meta:meta])*
                $field:ident : $field_ty:ty {
                    provenance: $provenance:literal,
                    gate: $gate:expr,
                    source: $source:expr,
                    transform: $transform:expr
                    $(, fallback: $fallback:expr)?
                    $(,)?
                }
            ),* $(,)?
        }
        $(accessor $accessor_vis:vis fn $accessor:ident($ctx:ident);)?
        register $register_vis:vis fn $register:ident(
            $built:ident,
            $params:ident
        ) -> $return_ty:ty;
        prepare { $($prepare:tt)* }
        auras {
            $(
                {
                    provenance: $aura_provenance:literal,
                    gate: $aura_gate:expr,
                    aura: $aura:expr,
                    effect: $effect:expr $(,)?
                }
            ),* $(,)?
        }
        $(wiring {
            $(
                {
                    provenance: $wiring_provenance:literal,
                    gate: $wiring_gate:expr,
                    apply: $wiring_apply:block $(,)?
                }
            ),* $(,)?
        })?
        finish |$cfg:ident| $finish:block
    ) => {
        $(#[$config_meta])*
        #[derive(Copy, Clone, Debug)]
        $vis struct $config {
            $(
                #[doc = $provenance]
                $(#[$field_meta])*
                pub $field: $field_ty,
            )*
        }

        impl Default for $config {
            fn default() -> Self {
                Self {
                    $(
                        $field: $crate::hooks::define_spec_config!(
                            @fallback $field_ty $(, $fallback)?
                        ),
                    )*
                }
            }
        }

        $(
            $accessor_vis fn $accessor($ctx: &wowlab_engine_combat::HookCtx<'_>) -> $config {
                $ctx.state()
                    .spec_config::<$config>()
                    .copied()
                    .unwrap_or_default()
            }
        )?

        /// Registers the derived specialization configuration.
        ///
        /// # Errors
        ///
        /// Returns an engine construction error when required game data or registration is invalid.
        $register_vis fn $register(
            $built: &mut wowlab_engine_combat::BuiltCombatSystem,
            $params: &wowlab_engine_ports::HandlerParams<'_>,
        ) -> $return_ty {
            $($prepare)*
            let $cfg = $config {
                $(
                    $field: if $gate {
                        let value = $source;
                        ($transform)(value)
                    } else {
                        $crate::hooks::define_spec_config!(
                            @fallback $field_ty $(, $fallback)?
                        )
                    },
                )*
            };
            $(
                if $aura_gate {
                    $built.set_aura_effect($aura, $effect);
                }
            )*
            $(
                $(
                    if $wiring_gate {
                        $wiring_apply
                    }
                )*
            )?
            $finish
        }
    };
    (@fallback $field_ty:ty, $fallback:expr) => {
        $fallback
    };
    (@fallback $field_ty:ty) => {
        <$field_ty>::default()
    };
}

pub(crate) use define_spec_config;

#[cfg(test)]
mod config_macro_tests {
    #![expect(
        dead_code,
        reason = "the macro fixture deliberately exercises fields that individual tests do not read"
    )]

    use googletest::prelude::*;

    define_spec_config! {
        struct MacroConfig {
            fraction: f64 {
                provenance: "Synthetic effect e1 used to exercise source transforms.",
                gate: enabled,
                source: numerator,
                transform: |value| value / denominator,
            },
        }
        accessor fn macro_config(ctx);
        register fn register_macro_config(built, params) -> ();
        prepare {
            let enabled = true;
            let numerator = 25.0;
            let denominator = 100.0;
        }
        auras {}
        finish |cfg| {
            let _ = params;
            built.state.set_spec_config(cfg);
        }
    }

    #[gtest]
    fn config_table_emits_transformed_fields() -> Result<()> {
        let value = if true {
            let value = 25.0;
            let transform = |value| value / 100.0;

            transform(value)
        } else {
            f64::default()
        };
        let config = MacroConfig { fraction: value };

        verify_that!(config.fraction, eq(0.25))
    }
}

pub(crate) mod affliction_warlock;
pub(crate) mod arcane_mage;

pub(crate) mod arms_warrior;
pub(crate) mod assassination_rogue;
pub(crate) mod balance_druid;
pub(crate) mod beast_mastery_hunter;
pub(crate) mod demonology_warlock;
pub(crate) mod destruction_warlock;
pub(crate) mod devastation_evoker;
pub(crate) mod devourer_demon_hunter;
pub(crate) mod elemental_shaman;
pub(crate) mod enhancement_shaman;
pub(crate) mod feral_druid;
pub(crate) mod fire_mage;
pub(crate) mod frost_death_knight;
pub(crate) mod frost_mage;
pub(crate) mod fury_warrior;
pub(crate) mod havoc_demon_hunter;
pub(crate) mod items;
pub(crate) mod marksmanship_hunter;
pub(crate) mod outlaw_rogue;
pub(crate) mod retribution_paladin;
pub(crate) mod shadow_priest;
pub(crate) mod shared;
pub(crate) mod subtlety_rogue;
pub(crate) mod survival_hunter;
pub(crate) mod unholy_death_knight;
pub(crate) mod vengeance_demon_hunter;
pub(crate) mod windwalker_monk;