wowlab_engine_content/hooks/retribution_paladin/

config.rs

use wowlab_engine_combat::DamageOps as _;
use wowlab_engine_combat::ProcOps as _;
use wowlab_engine_combat::AuraOps as _;
use wowlab_engine_combat::{
    BuffEffect, BuiltCombatSystem, CombatState, DamageFlags, HookCtx, ImpactActorFilter,
    ImpactEvent, ImpactProc, ProcDriver, ProcTriggerSide,
};
use wowlab_engine_domain::dbc::ResolvedGameDataEffectExt as _;
use wowlab_engine_domain::dbc::is_physical;
use wowlab_engine_ports::HandlerParams;
use wowlab_engine_gamedata::{ResolvedGameData};
use wowlab_engine_rng::proc_chance;
use wowlab_types::{
    constants::{HUNDRED, MS_PER_SECOND},
    sim::SpellIdx,
};

use super::{bugs::BUG_BURN_TO_ASH_CONSECRATION, templar};
use crate::generated::specs::retribution_paladin::{
    AURA, AURA_AVENGING_WRATH, AURA_CRUSADING_STRIKES, AURA_EXECUTION_SENTENCE_GATHER,
    AURA_EXECUTION_SENTENCE_TRACKER, AURA_RUSH_OF_LIGHT, AURA_TRUTHS_WAKE, AURA_ZEALOTS_FERVOR,
    EFFECT, HERO, REPORTED_SPELL, SET_BONUS, SPELL, SPELL_BLADE_OF_JUSTICE, TALENT,
};

/// Light's Judicator proc chance (spell 1261525, 50%).
const LIGHTS_JUDICATOR_PROC_CHANCE: f64 = 0.5;

fn execution_sentence_accumulate(ctx: &mut HookCtx<'_>, impact: ImpactEvent) {
    if ctx.is_owner_aura_active(AURA_EXECUTION_SENTENCE_TRACKER.raw())
        && (ctx.is_owner_aura_active(AURA_EXECUTION_SENTENCE_GATHER.raw())
            || impact.spell_id == REPORTED_SPELL::EXECUTION_SENTENCE_INIT)
        && execution_sentence_accepts(ctx.game_data(), impact.spell_id)
    {
        ctx.accumulate_owner_damage(AURA_EXECUTION_SENTENCE_TRACKER.raw(), impact.amount);
    }
}

fn execution_sentence_accepts(data: &ResolvedGameData, spell_id: u32) -> bool {
    is_physical(data, SpellIdx::from_raw(spell_id)) == Some(false)
}

fn execution_sentence_periodic_snapshot_mult(data: &ResolvedGameData) -> f64 {
    1.0 + data.effect_base_points(EFFECT::AVENGING_WRATH_PERIODIC_DAMAGE) / HUNDRED
}

const fn truths_wake_filter(spell_id: u32) -> bool {
    spell_id == AURA::TRUTHS_WAKE
}

fn burn_to_ash_extend(ctx: &mut HookCtx<'_>, _impact: ImpactEvent) {
    let extension_ms = retribution_config(ctx).burn_to_ash_extend_ms;

    if extension_ms > 0
        && ctx
            .aura_remaining_ms(AURA_TRUTHS_WAKE.raw())
            .is_some_and(|remaining_ms| remaining_ms > 0)
    {
        ctx.extend_aura(AURA_TRUTHS_WAKE.raw(), extension_ms);
    }
}

#[derive(Clone, Copy, Debug)]
struct RetributionWiring {
    templar_selected: bool,
    lights_deliverance: bool,
}

fn wire_retribution(
    built: &mut BuiltCombatSystem,
    params: &HandlerParams<'_>,
    wiring: RetributionWiring,
) {
    if wiring.templar_selected {
        register_templar_proc(built, params, wiring.lights_deliverance);
    }
}

crate::hooks::define_spec_config! {
pub(super) struct RetributionConfig {
    crusade: bool { provenance: "Crusade selection.", gate: crusade, source: true, transform: |value| value },
    art_of_war_chance: f64 { provenance: "Art of War e1 proc chance.", gate: art_of_war, source: params.effect_base_points(EFFECT::ART_OF_WAR_CHANCE), transform: |value| value / HUNDRED },
    art_of_war_crit_bonus: f64 { provenance: "Art of War critical bonus.", gate: art_of_war, source: params.effect_base_points(EFFECT::ART_OF_WAR_CRIT_BONUS), transform: |value| value / HUNDRED },
    light_within: bool { provenance: "Light Within selection.", gate: light_within, source: true, transform: |value| value },
    light_within_wave_mult: f64 { provenance: "Light Within Wave damage multiplier.", gate: params.talent_picked(TALENT::LIGHT_WITHIN_WAVE), source: params.effect_base_points(EFFECT::LIGHT_WITHIN_WAVE_BONUS), transform: |value| 1.0 + value / HUNDRED },
    righteous_cause_chance: f64 { provenance: "Righteous Cause proc chance.", gate: righteous_cause, source: params.effect_base_points(EFFECT::RIGHTEOUS_CAUSE_CHANCE), transform: |value| value / HUNDRED },
    mid1_expurgation_final_verdict: f64 { provenance: "MID1 4pc Final Verdict Expurgation effectiveness.", gate: mid1_4pc, source: params.effect_base_points(EFFECT::MID1_4PC_FINAL_VERDICT), transform: |value| value / HUNDRED },
    mid1_expurgation_divine_storm: f64 { provenance: "MID1 4pc Divine Storm Expurgation effectiveness.", gate: mid1_4pc, source: params.effect_base_points(EFFECT::MID1_4PC_DIVINE_STORM), transform: |value| value / HUNDRED },
    crusading_strikes: bool { provenance: "Crusading Strikes selection.", gate: crusading_strikes, source: true, transform: |value| value },
    empyrean_power_chance: f64 { provenance: "Empyrean Power proc chance.", gate: params.talent_picked(TALENT::EMPYREAN_POWER), source: params.effect_base_points(EFFECT::EMPYREAN_POWER_CHANCE), transform: |value| value / HUNDRED },
    divine_purpose_chance: f64 { provenance: "Divine Purpose proc chance.", gate: params.talent_picked(TALENT::DIVINE_PURPOSE), source: params.effect_base_points(EFFECT::DIVINE_PURPOSE_CHANCE), transform: |value| value / HUNDRED },
    empyrean_legacy: bool { provenance: "Empyrean Legacy selection.", gate: params.talent_picked(TALENT::EMPYREAN_LEGACY), source: true, transform: |value| value },
    empyrean_legacy_effectiveness: f64 { provenance: "Empyrean Legacy e2 Divine Storm effectiveness.", gate: params.talent_picked(TALENT::EMPYREAN_LEGACY), source: params.effect_base_points(EFFECT::EMPYREAN_LEGACY_EFFECTIVENESS), transform: |value| 1.0 + value / HUNDRED },
    templar: bool { provenance: "Light's Guidance Templar selection.", gate: templar_selected, source: true, transform: |value| value },
    lights_guidance_count: u32 { provenance: "Light's Guidance 427445 e2 hammer count.", gate: templar_selected, source: params.effect_base_points(EFFECT::LIGHTS_GUIDANCE_COUNT), transform: wowlab_types::numeric::f64_to_u32_saturating_trunc },
    lights_guidance_delay_ms: u32 { provenance: "Light's Guidance 427445 e4 initial delay.", gate: templar_selected, source: params.effect_base_points(EFFECT::LIGHTS_GUIDANCE_DELAY), transform: wowlab_types::numeric::f64_to_u32_saturating_trunc },
    empyrean_hammer_stagger_ms: u32 { provenance: "Light's Guidance 427445 e3 stagger.", gate: templar_selected, source: params.effect_base_points(EFFECT::LIGHTS_GUIDANCE_STAGGER), transform: wowlab_types::numeric::f64_to_u32_saturating_trunc },
    zealous_vindication_count: u32 { provenance: "Zealous Vindication 431463 e1 hammer count.", gate: templar_selected && params.talent_picked(HERO::TEMPLAR::SPELL::ZEALOUS_VINDICATION), source: params.effect_base_points(EFFECT::ZEALOUS_VINDICATION_COUNT), transform: wowlab_types::numeric::f64_to_u32_saturating_trunc },
    shake_the_heavens: bool { provenance: "Shake the Heavens selection.", gate: templar_selected && params.talent_picked(HERO::TEMPLAR::SPELL::SHAKE_THE_HEAVENS_TALENT), source: true, transform: |value| value },
    sanctification: bool { provenance: "Sanctification selection.", gate: templar_selected && params.talent_picked(HERO::TEMPLAR::SPELL::SANCTIFICATION_TALENT), source: true, transform: |value| value },
    higher_calling_ms: u32 { provenance: "Higher Calling e1 seconds converted to milliseconds.", gate: templar_selected && params.talent_picked(HERO::TEMPLAR::SPELL::HIGHER_CALLING), source: params.effect_base_points(EFFECT::HIGHER_CALLING_EXTEND), transform: |value| wowlab_types::numeric::f64_to_u32_saturating_trunc(value * MS_PER_SECOND) },
    hammerfall: bool { provenance: "Hammerfall selection.", gate: templar_selected && params.talent_picked(HERO::TEMPLAR::SPELL::HAMMERFALL), source: true, transform: |value| value },
    lights_deliverance: bool { provenance: "Light's Deliverance selection.", gate: lights_deliverance, source: true, transform: |value| value },
    lights_deliverance_max_stacks: i32 { provenance: "Light's Deliverance passively-modified maximum stacks.", gate: lights_deliverance, source: params.game_data.aura_max_stacks(SpellIdx::from_raw(AURA::LIGHTS_DELIVERANCE)).unwrap_or_default(), transform: i32::from },
    undisputed_ruling: bool { provenance: "Undisputed Ruling selection.", gate: templar_selected && params.talent_picked(HERO::TEMPLAR::SPELL::UNDISPUTED_RULING_TALENT), source: true, transform: |value| value },
    divine_hammer: bool { provenance: "Divine Hammer selection.", gate: templar_selected && params.talent_picked(HERO::TEMPLAR::SPELL::DIVINE_HAMMER_TALENT), source: true, transform: |value| value },
    greater_judgment: bool { provenance: "Greater Judgment selection.", gate: params.talent_picked(TALENT::GREATER_JUDGMENT), source: true, transform: |value| value },
    sanctify: bool { provenance: "Sanctify selection.", gate: params.talent_picked(TALENT::SANCTIFY), source: true, transform: |value| value },
    hammer_of_wrath: bool { provenance: "Hammer of Wrath talent selection.", gate: params.talent_picked(TALENT::HAMMER_OF_WRATH_TALENT), source: true, transform: |value| value },
    vengeful_wrath_max_bonus: f64 { provenance: "Vengeful Wrath e1 maximum Hammer of Wrath damage bonus.", gate: params.talent_picked(TALENT::VENGEFUL_WRATH), source: params.effect_base_points(EFFECT::VENGEFUL_WRATH_MAX_BONUS), transform: |value| value / HUNDRED },
    divine_toll_echo_mult: f64 { provenance: "Divine Toll echo effectiveness modifier.", gate: true, source: params.effect_base_points(EFFECT::DIVINE_TOLL_ECHO_MULT), transform: |value| 1.0 + value / HUNDRED },
    divine_exaction_count: u32 { provenance: "Divine Exaction 1260429 e1 echo count.", gate: divine_exaction, source: params.effect_base_points(EFFECT::DIVINE_EXACTION_COUNT), transform: wowlab_types::numeric::f64_to_u32_saturating_trunc },
    divine_exaction_mult: f64 { provenance: "Divine Exaction 1260429 e2 effectiveness plus base damage.", gate: divine_exaction, source: params.effect_base_points(EFFECT::DIVINE_EXACTION_MULT), transform: |value| 1.0 + value / HUNDRED },
    burn_to_ash_extend_ms: u32 { provenance: "Burn to Ash 446663 e1 Truth's Wake extension in seconds.", gate: burn_to_ash, source: params.effect_base_points(EFFECT::BURN_TO_ASH_EXTEND), transform: |value| wowlab_types::numeric::f64_to_u32_saturating_trunc(value * MS_PER_SECOND) },
    consecrated_blade: bool { provenance: "Consecrated Blade baseline specialization selection.", gate: params.talent_selected(TALENT::CONSECRATED_BLADE), source: true, transform: |value| value },
}
accessor pub(crate) fn retribution_config(ctx);
register pub(crate) fn register_retribution(built, params) -> RetributionConfig;
prepare {
    let crusade = params.talent_picked(TALENT::CRUSADE);
    let light_within = params.talent_picked(TALENT::LIGHT_WITHIN);
    let crusading_strikes = params.talent_picked(TALENT::CRUSADING_STRIKES);
    let art_of_war = params.talent_picked(TALENT::ART_OF_WAR);
    let righteous_cause = params.talent_picked(TALENT::RIGHTEOUS_CAUSE);
    let mid1_4pc = params.set_bonus_auras.contains(&SET_BONUS::MID1_RETRIBUTION_4PC);
    let templar_selected = params.talent_picked(HERO::TEMPLAR::SPELL::LIGHTS_GUIDANCE);
    let lights_deliverance = templar_selected && params.talent_picked(HERO::TEMPLAR::SPELL::LIGHTS_DELIVERANCE_TALENT);
    let divine_exaction = templar_selected && params.talent_picked(HERO::TEMPLAR::SPELL::DIVINE_EXACTION);
    let burn_to_ash = params.talent_picked(TALENT::BURN_TO_ASH);
}
auras {
    { provenance: "Light Within Verdict damage is constant while the stackable Avenging Wrath aura is active.", gate: params.talent_picked(TALENT::LIGHT_WITHIN_VERDICT), aura: AURA_AVENGING_WRATH, effect: BuffEffect::DamageMultSpellsActive(1.0 + params.effect_base_points(EFFECT::LIGHT_WITHIN_VERDICT_BONUS) / HUNDRED, &LIGHT_WITHIN_VERDICT_SPELLS) },
    { provenance: "Execution Sentence's initial payload snapshots Avenging Wrath e2's periodic multiplier in addition to its ordinary direct multiplier.", gate: params.talent_picked(TALENT::EXECUTION_SENTENCE), aura: AURA_AVENGING_WRATH, effect: BuffEffect::DamageMultSpellsActive(execution_sentence_periodic_snapshot_mult(&params.game_data), &EXECUTION_SENTENCE_INIT_SPELLS) },
}
wiring {
    { provenance: "Crusade's passive e1/e2 derive Avenging Wrath's stack cap; the manifest gate retains e11 as the data-owned per-stack Haste payload.", gate: crusade, apply: {
        built.mask_aura_dbc_effect(
            AURA_AVENGING_WRATH,
            EFFECT::AVENGING_WRATH_CRIT.0,
            EFFECT::AVENGING_WRATH_CRIT.1,
        );
        let haste_per_stack = params.effect_base_points(EFFECT::CRUSADE_HASTE_PER_STACK);
        let haste_cap = params.effect_base_points(EFFECT::CRUSADE_HASTE_CAP);
        let max_stacks = wowlab_types::numeric::f64_to_u8_saturating_trunc(
            haste_cap / haste_per_stack.max(f64::EPSILON),
        ).max(1);

        built.patch_aura(AURA_AVENGING_WRATH, |aura| {
            aura.max_stacks = max_stacks;
        });
        built.set_aura_effect(
            AURA_AVENGING_WRATH,
            BuffEffect::CritActive(params.effect_base_points(EFFECT::AVENGING_WRATH_CRIT)),
        );
    } },
    { provenance: "The live Burn to Ash bug applies Truth's Wake e4 twice; duplicate the resolved DBC row without reconstructing its magnitude or affected-spell list.", gate: burn_to_ash && built.state.bug_enabled(&BUG_BURN_TO_ASH_CONSECRATION), apply: {
        let duplicated = built.duplicate_aura_dbc_effect(
            AURA_TRUTHS_WAKE,
            EFFECT::TRUTHS_WAKE_BURN_EFFECT_4.0,
            EFFECT::TRUTHS_WAKE_BURN_EFFECT_4.1,
        );
        debug_assert_eq!(duplicated, 1);
    } },
    { provenance: "Crusading Strikes precombat aura; generic OverridesSpellID handling disables Crusader Strike.", gate: crusading_strikes, apply: {
        built.push_precombat_aura(AURA_CRUSADING_STRIKES);
    } },
    { provenance: "Zealot's Fervor precombat aura.", gate: params.talent_picked(TALENT::ZEALOTS_FERVOR), apply: {
        built.push_precombat_aura(AURA_ZEALOTS_FERVOR);
    } },
    { provenance: "Execution Sentence damage accumulator proc.", gate: params.talent_picked(TALENT::EXECUTION_SENTENCE), apply: {
        built.register_impact_proc(
            ImpactProc::new(execution_sentence_accumulate)
                .with_actor_filter(ImpactActorFilter::Any),
        );
    } },
    { provenance: "Burn to Ash extends Truth's Wake after each non-final critical periodic tick.", gate: burn_to_ash, apply: {
        built.register_impact_proc(
            ImpactProc::new(burn_to_ash_extend)
                .with_spell_filter(truths_wake_filter)
                .periodic_only()
                .crit_only(),
        );
    } },
    { provenance: "Rush of Light procs from critical non-periodic impacts of lowered spells that generate Holy Power.", gate: params.talent_picked(TALENT::RUSH_OF_LIGHT), apply: {
        built.register_impact_proc(rush_of_light_proc(&params.game_data));
    } },
    { provenance: "Holy Blade flat Blade of Justice energize modifier.", gate: params.talent_picked(TALENT::HOLY_BLADE), apply: {
        let extra = params.effect_base_points(EFFECT::HOLY_BLADE_ENERGIZE);
        built.patch_spell(SPELL_BLADE_OF_JUSTICE, |spell| {
            spell.cost.resource_gain += extra;
        });
    } },
}
finish |cfg| {
    wire_retribution(
        built,
        params,
        RetributionWiring {
            templar_selected,
            lights_deliverance,
        },
    );
    built.state.set_spec_config(cfg);
    cfg
}
}

fn rush_of_light_accepts(state: &CombatState, spell_id: u32) -> bool {
    state
        .spell_data(spell_id)
        .is_some_and(|(_, spell)| spell.cost.resource_gain > 0.0)
}

fn rush_of_light_fire(ctx: &mut HookCtx<'_>, impact: ImpactEvent) {
    if !rush_of_light_accepts(ctx.state(), impact.spell_id)
        || !ctx.proc_category_ready(TALENT::RUSH_OF_LIGHT)
    {
        return;
    }

    ctx.apply_aura(AURA_RUSH_OF_LIGHT.raw());
    ctx.start_proc_category_cooldown(TALENT::RUSH_OF_LIGHT);
}

fn rush_of_light_proc(data: &ResolvedGameData) -> ImpactProc {
    ImpactProc::new(rush_of_light_fire)
        .with_driver(ProcDriver::from_spell(
            data,
            TALENT::RUSH_OF_LIGHT,
            ProcTriggerSide::Caster,
        ))
        .skip_periodic()
        .crit_only()
}

fn register_templar_proc(
    built: &mut BuiltCombatSystem,
    params: &HandlerParams<'_>,
    lights_deliverance: bool,
) {
    let enabled =
        lights_deliverance && params.talent_picked(HERO::TEMPLAR::SPELL::LIGHTS_JUDICATOR);

    if enabled {
        built.register_impact_proc(
            ImpactProc::new(lights_judicator_fire)
                .with_chance(LIGHTS_JUDICATOR_PROC_CHANCE)
                .with_spell_filter(is_empyrean_hammer)
                .skip_periodic()
                .crit_only(),
        );
    }
}

const LIGHT_WITHIN_VERDICT_SPELLS: [u32; 2] = [SPELL::FINAL_VERDICT, SPELL::DIVINE_STORM];
const EXECUTION_SENTENCE_INIT_SPELLS: [u32; 1] = [REPORTED_SPELL::EXECUTION_SENTENCE_INIT];
const fn is_empyrean_hammer(spell_id: u32) -> bool {
    spell_id == SPELL::EMPYREAN_HAMMER
}

fn lights_judicator_fire(ctx: &mut HookCtx<'_>, _impact: ImpactEvent) {
    templar::gain_lights_deliverance(ctx);
}

const fn highlords_judgment_filter(spell_id: u32) -> bool {
    matches!(
        spell_id,
        SPELL::JUDGMENT
            | SPELL::HAMMER_OF_WRATH
            | SPELL::JUDGMENT_DIVINE_TOLL
            | SPELL::HAMMER_OF_WRATH_DIVINE_TOLL
    )
}

fn highlords_judgment_chance(ctx: &HookCtx<'_>) -> f64 {
    ctx.effect_points(EFFECT::HIGHLORDS_MASTERY_FACTOR) / HUNDRED
}

fn fire_highlords_judgment(ctx: &mut HookCtx<'_>, chance: f64) {
    if !proc_chance(ctx.rng(), chance) {
        return;
    }

    let coef = ctx
        .game_data()
        .effect_ap_coefficient(EFFECT::HIGHLORDS_JUDGMENT);

    ctx.deal_damage_ap(SPELL::HIGHLORDS_JUDGMENT, coef, DamageFlags::empty());
}

fn highlords_judgment_fire(ctx: &mut HookCtx<'_>, _impact: ImpactEvent) {
    let chance = highlords_judgment_chance(ctx);

    fire_highlords_judgment(ctx, chance);
}

fn highlords_judgment_fire_wrath(ctx: &mut HookCtx<'_>, _impact: ImpactEvent) {
    let data = ctx.game_data();
    let divisor = data.effect_base_points(EFFECT::HIGHLORDS_WRATH_DIVISOR);
    let percent = data.effect_base_points(EFFECT::HIGHLORDS_WRATH) / HUNDRED;
    let mult = if divisor > 0.0 {
        1.0 + percent / divisor
    } else {
        1.0
    };
    let chance = highlords_judgment_chance(ctx) * mult;

    fire_highlords_judgment(ctx, chance);
}

/// Register the Highlord's Judgment mastery proc.
pub(crate) fn register_highlords_judgment(
    built: &mut BuiltCombatSystem,
    params: &HandlerParams<'_>,
) {
    if params
        .game_data
        .effect_sp_coefficient(EFFECT::HIGHLORDS_MASTERY_FACTOR)
        <= 0.0
    {
        return;
    }

    let wrath_talented = params.talent_picked(TALENT::HIGHLORDS_WRATH);
    let fire = if wrath_talented {
        highlords_judgment_fire_wrath
    } else {
        highlords_judgment_fire
    };

    // The mastery-scaled roll happens inside `fire`.

    built.register_impact_proc(
        ImpactProc::new(fire)
            .with_spell_filter(highlords_judgment_filter)
            .skip_periodic(),
    );
}

#[cfg(test)]
mod tests {
    use googletest::prelude::*;
    use rstest::rstest;
    use wowlab_engine_domain::dbc::{SpellAttributeKind, SpellSchoolMask};
    use wowlab_engine_ports::{CombatStats};
use wowlab_engine_gamedata::{ResolvedGameData, SpellProps};

    use super::*;

    #[gtest]
    fn execution_sentence_banks_only_resolved_nonphysical_damage() -> Result<()> {
        let physical = SpellIdx::from_raw(6603);
        let holy = SpellIdx::from_raw(SPELL::FINAL_VERDICT);
        let unknown = SpellIdx::from_raw(853);
        let mut builder = ResolvedGameData::builder();

        builder.insert_school_mask(physical, i32::from(SpellSchoolMask::PHYSICAL.bits()));
        builder.insert_school_mask(holy, i32::from(SpellSchoolMask::HOLY.bits()));

        let data = builder.build();

        verify_false!(execution_sentence_accepts(&data, physical.0))?;
        verify_true!(execution_sentence_accepts(&data, holy.0))?;

        verify_false!(execution_sentence_accepts(&data, unknown.0))
    }

    #[gtest]
    fn execution_sentence_initial_snapshot_uses_avenging_wrath_periodic_effect() -> Result<()> {
        let mut builder = ResolvedGameData::builder();

        builder.insert_base_points(
            SpellIdx::from_raw(EFFECT::AVENGING_WRATH_PERIODIC_DAMAGE.0),
            EFFECT::AVENGING_WRATH_PERIODIC_DAMAGE.1,
            20.0,
        );
        let data = builder.build();

        verify_that!(
            execution_sentence_periodic_snapshot_mult(&data),
            near(1.2, f64::EPSILON),
        )
    }

    #[gtest]
    #[rstest]
    #[case::judgment(SPELL::JUDGMENT, true)]
    #[case::hammer_of_wrath(SPELL::HAMMER_OF_WRATH, true)]
    #[case::divine_toll_judgment(SPELL::JUDGMENT_DIVINE_TOLL, true)]
    #[case::divine_toll_hammer_of_wrath(SPELL::HAMMER_OF_WRATH_DIVINE_TOLL, true)]
    #[case::highlords_judgment(SPELL::HIGHLORDS_JUDGMENT, false)]
    #[case::arbitrary(853, false)]
    fn highlords_judgment_filter_allows_only_judgment_family_impacts(
        #[case] spell_id: u32,
        #[case] expected: bool,
    ) -> Result<()> {
        verify_that!(highlords_judgment_filter(spell_id), eq(expected))
    }

    #[gtest]
    #[rstest]
    #[case::empyrean_hammer(SPELL::EMPYREAN_HAMMER, true)]
    #[case::judgment(SPELL::JUDGMENT, false)]
    #[case::arbitrary(853, false)]
    fn lights_judicator_filter_allows_only_empyrean_hammer_impacts(
        #[case] spell_id: u32,
        #[case] expected: bool,
    ) -> Result<()> {
        verify_that!(is_empyrean_hammer(spell_id), eq(expected))
    }

    #[gtest]
    fn rush_of_light_accepts_only_lowered_spells_with_primary_resource_gain() -> Result<()> {
        const GENERATOR: u32 = 100;
        const NON_GENERATOR: u32 = 200;

        let built = crate::test_combat_builder(CombatStats::default())
            .spell("generator", GENERATOR, |spell| Ok(spell.gain(1.0)))
            .spell("non_generator", NON_GENERATOR, Ok)
            .build(
                crate::test_support::wait_rotation(),
            )
            .or_fail()?;

        verify_true!(rush_of_light_accepts(&built.state, GENERATOR))?;
        verify_false!(rush_of_light_accepts(&built.state, NON_GENERATOR))?;

        verify_false!(rush_of_light_accepts(&built.state, 300))
    }

    #[gtest]
    fn rush_of_light_registration_uses_caster_driver_and_critical_direct_player_impacts()
    -> Result<()> {
        let attribute = SpellAttributeKind::CanProcFromProcs;
        let mut attributes = vec![0; 14];

        attributes[attribute.block()] |= attribute.mask();

        let mut builder = ResolvedGameData::builder();

        builder.insert_spell_props(
            SpellIdx::from_raw(TALENT::RUSH_OF_LIGHT),
            SpellProps {
                attributes,
                proc_category_recovery_ms: 500,
                ..SpellProps::default()
            },
        );

        let data = builder.build();
        let proc = rush_of_light_proc(&data);

        verify_that!(proc.actor_filter, eq(ImpactActorFilter::Player))?;
        verify_that!(proc.chance, near(1.0, f64::EPSILON))?;
        verify_that!(proc.driver.trigger_side, eq(ProcTriggerSide::Caster))?;
        verify_true!(proc.driver.policy.can_proc_from_procs)?;
        verify_true!(proc.spell_filter.is_none())?;
        verify_false!(proc.periodic_only)?;
        verify_true!(proc.skip_periodic)?;
        verify_true!(proc.crit_only)?;

        verify_that!(
            data.proc_category_recovery_ms(SpellIdx::from_raw(TALENT::RUSH_OF_LIGHT)),
            some(eq(500))
        )
    }
}