wowlab_engine_content/hooks/elemental_shaman/

hooks.rs

use wowlab_engine_combat::AuraOps as _;
use wowlab_engine_combat::CooldownOps as _;
use wowlab_engine_combat::DamageOps as _;
use wowlab_engine_combat::GuardianOps as _;
use wowlab_engine_combat::ProcOps as _;
use wowlab_engine_combat::ResourceOps as _;
use wowlab_engine_combat::SchedulingOps as _;
use wowlab_engine_combat::{
    BuffEffect, CombatSystemDraft, DamageFlags, HookCtx, ImpactEvent, ImpactProc, MasteryCtx,
    PassiveDriverEffect, RuntimeDamageDef, try_push_effect,
};
use wowlab_engine_domain::dbc::ResolvedGameDataEffectExt as _;
use wowlab_engine_ports::HandlerParams;
use wowlab_engine_rng::proc_chance;
use wowlab_types::{constants::HUNDRED, sim::SpellIdx};

use crate::generated::specs::elemental_shaman::{
    AURA_ANCESTRAL_SWIFTNESS, AURA_ASCENDANCE, AURA_ELEMENTAL_BLAST_CRIT,
    AURA_ELEMENTAL_BLAST_HASTE, AURA_ELEMENTAL_BLAST_MASTERY, AURA_FIRE_ELEMENTAL,
    AURA_FLAME_SHOCK, AURA_FLOWING_ELEMENTS, AURA_LAVA_SURGE, AURA_LIGHTNING_ROD,
    AURA_LIGHTNING_SHIELD, AURA_MASTER_OF_THE_ELEMENTS, AURA_OVERCHARGE_TIER,
    AURA_POWER_OF_THE_MAELSTROM, AURA_STORM_ELEMENTAL, AURA_STORMKEEPER, AURA_STORMS_EYE,
    AURA_TEMPEST, AURA_UNLIMITED_POWER, AURA_WIND_GUST, EFFECT, SET_BONUS, SPELL,
    SPELL_ELEMENTAL_BLAST, SPELL_LAVA_BURST, TALENT,
};

/// Server-side Maelstrom amounts absent from DBC.
const LAVA_BURST_MAELSTROM: f64 = 8.0;
const LIGHTNING_BOLT_OVERLOAD_MAELSTROM: f64 = 2.0;
const CHAIN_LIGHTNING_OVERLOAD_MAELSTROM: f64 = 1.0;
const LAVA_BURST_OVERLOAD_MAELSTROM: f64 = 3.0;

const CHAIN_OVERLOAD_DIVISOR: f64 = 3.0;

/// Stormkeeper's normal cast grants two charges (191634 e5).
const STORMKEEPER_CAST_CHARGES: u32 = 2;
/// Arc Discharge adds one Stormkeeper charge (455096 e1).
const ARC_DISCHARGE_CHARGES: u32 = 1;
const MID2_EMPOWERED_BUILDER_CHARGES: i32 = 2;
const MID2_OVERLAP_EMPOWERED_BUILDER_CHARGES: i32 = 4;

/// Lava Surge chance is `max(0, 0.6 - 1.16^(-2 * (attempts - 5)))`.
const LAVA_SURGE_CEILING: f64 = 0.6;
const LAVA_SURGE_DECAY_BASE: f64 = 1.16;
const LAVA_SURGE_MIDPOINT: f64 = 5.0;
const LAVA_SURGE_EXPONENT_SCALE: f64 = -2.0;

/// 188592 e4/e5 affect mask (family flag 103), player half.
#[rustfmt::skip]
static EU_FIRE_PLAYER_SPELLS: [u32; 3] = [
    SPELL::ELEMENTAL_BLAST,
    EFFECT::ELEMENTAL_BLAST_OVERLOAD.0,
    SPELL::FLAME_SHOCK,
];
/// 188592 e4/e5 affect mask (family flag 103), Fire Elemental actions.
static EU_FIRE_PET_SPELLS: [u32; 3] = [SPELL::METEOR, SPELL::IMMOLATE, SPELL::FIRE_BLAST];
/// Family-flag-126 class mask shared by Storm Elemental unity (157299 e3/e4) and Lightning Capacitor (462862 e1/e2), player spells.
#[rustfmt::skip]
static FLAG_126_PLAYER_SPELLS: [u32; 11] = [
    SPELL::LIGHTNING_BOLT,
    SPELL::CHAIN_LIGHTNING,
    SPELL::ELEMENTAL_BLAST,
    SPELL::TEMPEST,
    SPELL::EARTH_SHOCK,
    SPELL::FLAME_SHOCK,
    SPELL::STORMS_EYE,
    EFFECT::LIGHTNING_BOLT_OVERLOAD.0,
    EFFECT::CHAIN_LIGHTNING_OVERLOAD.0,
    EFFECT::ELEMENTAL_BLAST_OVERLOAD.0,
    EFFECT::TEMPEST_OVERLOAD.0,
];
/// 157299 e3/e4 affect mask (family flag 126), Storm Elemental actions.
static EU_STORM_PET_SPELLS: [u32; 3] = [SPELL::WIND_GUST, SPELL::CALL_LIGHTNING, SPELL::STORMFURY];
/// Elemental Unity rows the summon auras declare in data but the game scripts on only with the talent.
static EU_FIRE_MASKED_EFFECTS: [(u32, u8); 2] = [
    EFFECT::FIRE_ELEMENTAL_UNITY,
    EFFECT::FIRE_ELEMENTAL_UNITY_PERIODIC,
];
static EU_STORM_MASKED_EFFECTS: [(u32, u8); 2] = [
    EFFECT::STORM_ELEMENTAL_UNITY,
    EFFECT::STORM_ELEMENTAL_UNITY_PET,
];
/// 382028 e1 affect masks (family flags 28/44/86/98): the fire half.
#[rustfmt::skip]
static IFW_SPELLS: [u32; 5] = [
    SPELL::FLAME_SHOCK,
    SPELL::LAVA_BURST,
    SPELL::ELEMENTAL_BLAST,
    EFFECT::LAVA_BURST_OVERLOAD.0,
    EFFECT::ELEMENTAL_BLAST_OVERLOAD.0,
];

pub(crate) fn earthquake_hook(ctx: &mut HookCtx<'_>) {
    if let Some(effect) = elemental_config(ctx).earthquake_ground {
        ctx.schedule_ground_effect(effect);
    }

    ctx.consume_aura(AURA_OVERCHARGE_TIER);
}

pub(crate) fn earth_shock_hook(ctx: &mut HookCtx<'_>) {
    ctx.consume_aura(AURA_OVERCHARGE_TIER);
}

const STORMS_EYE_CHARGES: i32 = 2;

const RANDOM_STAT_ROLL_THIRD: f64 = 1.0 / 3.0;
const RANDOM_STAT_ROLL_TWO_THIRDS: f64 = 2.0 / 3.0;

use super::{
    config::{ElementalRuntime, elemental_config, register_elemental_config},
    elementals::{STORM_ELEMENTAL_GUARDIAN_TAG, summon_fire_elemental, summon_storm_elemental},
};

fn trigger_elemental_blast_stat(ctx: &mut HookCtx<'_>) {
    let aura = match ctx.rng()() {
        roll if roll < RANDOM_STAT_ROLL_THIRD => AURA_ELEMENTAL_BLAST_CRIT,
        roll if roll < RANDOM_STAT_ROLL_TWO_THIRDS => AURA_ELEMENTAL_BLAST_HASTE,
        _ => AURA_ELEMENTAL_BLAST_MASTERY,
    };

    ctx.apply_aura(aura);
}

/// Overload proc chance: mastery points x 168534 e1 coefficient (1.875 %/point).
fn overload_chance(ctx: &HookCtx<'_>) -> f64 {
    ctx.effect_points(crate::generated::specs::elemental_shaman::DAMAGE_EFFECT::OVERLOAD_CHANCE)
        / HUNDRED
}

/// Overload damage penalty from spell 168534 e2.
fn overload_penalty(ctx: &HookCtx<'_>) -> f64 {
    ctx.effect_base_points(
        crate::generated::specs::elemental_shaman::DAMAGE_EFFECT::OVERLOAD_PENALTY,
    ) / HUNDRED
}

fn fire_overload(
    ctx: &mut HookCtx<'_>,
    effect: wowlab_engine_combat::DamageEffectId,
    maelstrom: f64,
) {
    fire_overload_scaled(ctx, effect, maelstrom, 1.0);
    let feedback_chance = elemental_config(ctx).feedback_loop_chance;

    if feedback_chance > 0.0 && proc_chance(ctx.rng(), feedback_chance) {
        fire_overload_scaled(ctx, effect, maelstrom, 1.0);
    }
}

fn fire_overload_scaled(
    ctx: &mut HookCtx<'_>,
    effect: wowlab_engine_combat::DamageEffectId,
    maelstrom: f64,
    damage_mult: f64,
) {
    let coef = ctx.effect_sp_coefficient(effect) * overload_penalty(ctx) * damage_mult;

    ctx.deal_damage_sp(effect.action(), coef, DamageFlags::empty());

    if maelstrom > 0.0 {
        ctx.gain_resource(maelstrom);
    }
}

// Elemental Blast never rolls Supercharge but retains mastery and Ascendance overloads.
fn fire_elemental_blast_overloads(ctx: &mut HookCtx<'_>, damage_mult: f64) {
    let cfg = elemental_config(ctx);
    let fire = |ctx: &mut HookCtx<'_>| {
        trigger_elemental_blast_stat(ctx);
        fire_overload_scaled(
            ctx,
            crate::generated::specs::elemental_shaman::DAMAGE_EFFECT::ELEMENTAL_BLAST_OVERLOAD,
            0.0,
            damage_mult,
        );

        if cfg.feedback_loop_chance > 0.0 && proc_chance(ctx.rng(), cfg.feedback_loop_chance) {
            trigger_elemental_blast_stat(ctx);
            fire_overload_scaled(
                ctx,
                crate::generated::specs::elemental_shaman::DAMAGE_EFFECT::ELEMENTAL_BLAST_OVERLOAD,
                0.0,
                damage_mult,
            );
        }
    };

    let chance = overload_chance(ctx);

    if proc_chance(ctx.rng(), chance) {
        fire(ctx);
    }

    if ctx.is_aura_active(AURA_ASCENDANCE) {
        fire(ctx);
    }
}

fn fire_elemental_blast(ctx: &mut HookCtx<'_>, damage_mult: f64) {
    trigger_elemental_blast_stat(ctx);
    let coefficient = ctx.effect_sp_coefficient(
        crate::generated::specs::elemental_shaman::DAMAGE_EFFECT::ELEMENTAL_BLAST_DAMAGE,
    ) * damage_mult;

    ctx.deal_damage_sp(
        crate::generated::specs::elemental_shaman::DAMAGE_SPELL::ELEMENTAL_BLAST,
        coefficient,
        DamageFlags::empty(),
    );
    let cfg = elemental_config(ctx);

    if cfg.eb_overload {
        fire_elemental_blast_overloads(ctx, cfg.eb_overload_mult * damage_mult);
    }
}

fn spend_stormkeeper_charge(ctx: &mut HookCtx<'_>) {
    if ctx.consume_proc_counter(
        wowlab_engine_combat::generated_identities::proc_counter::STORMKEEPER,
        1,
    ) == 0
    {
        ctx.expire_aura(AURA_STORMKEEPER);
    }
}

fn consume_flowing_elements(ctx: &mut HookCtx<'_>) {
    if ctx.consume_aura_stack(AURA_FLOWING_ELEMENTS) {
        ctx.apply_aura(AURA_OVERCHARGE_TIER);
    }
}

#[derive(Clone, Copy)]
struct EmpoweredLightningOptions {
    chance_divisor: f64,
    stormkeeper_overload: bool,
    consume_stormkeeper: bool,
}

const LIGHTNING_BOLT_OPTIONS: EmpoweredLightningOptions = EmpoweredLightningOptions {
    chance_divisor: 1.0,
    stormkeeper_overload: true,
    consume_stormkeeper: true,
};
const TEMPEST_OPTIONS: EmpoweredLightningOptions = EmpoweredLightningOptions {
    chance_divisor: 1.0,
    stormkeeper_overload: false,
    consume_stormkeeper: false,
};
const CHAIN_LIGHTNING_OPTIONS: EmpoweredLightningOptions = EmpoweredLightningOptions {
    chance_divisor: CHAIN_OVERLOAD_DIVISOR,
    stormkeeper_overload: true,
    consume_stormkeeper: true,
};

fn empowered_lightning_cast(
    ctx: &mut HookCtx<'_>,
    overload: wowlab_engine_combat::DamageEffectId,
    overload_maelstrom: f64,
    options: EmpoweredLightningOptions,
) {
    let stormkeeper = ctx.is_aura_active(AURA_STORMKEEPER);
    let cfg = elemental_config(ctx);

    let chance = overload_chance(ctx) / options.chance_divisor;

    if (stormkeeper && options.stormkeeper_overload) || proc_chance(ctx.rng(), chance) {
        fire_overload(ctx, overload, overload_maelstrom);
    }

    if stormkeeper && options.consume_stormkeeper {
        spend_stormkeeper_charge(ctx);
    }

    if ctx.consume_aura(AURA_POWER_OF_THE_MAELSTROM) {
        fire_overload(ctx, overload, overload_maelstrom);

        if cfg.fusion_of_elements_mult > 0.0 {
            fire_elemental_blast(ctx, cfg.fusion_of_elements_mult);
        }
    }

    if cfg.supercharge_chance > 0.0 && proc_chance(ctx.rng(), cfg.supercharge_chance) {
        fire_overload(ctx, overload, overload_maelstrom);
    }
    // Ascendance adds one overload without duplicating Supercharge.

    if ctx.is_aura_active(AURA_ASCENDANCE) {
        fire_overload(ctx, overload, overload_maelstrom);
    }

    if ctx.active_guardian_count(STORM_ELEMENTAL_GUARDIAN_TAG) > 0 {
        ctx.apply_aura(AURA_WIND_GUST);
    }

    ctx.consume_aura(AURA_MASTER_OF_THE_ELEMENTS);
}

pub(crate) fn lightning_bolt_hook(ctx: &mut HookCtx<'_>) {
    empowered_lightning_cast(
        ctx,
        crate::generated::specs::elemental_shaman::DAMAGE_EFFECT::LIGHTNING_BOLT_OVERLOAD,
        LIGHTNING_BOLT_OVERLOAD_MAELSTROM,
        LIGHTNING_BOLT_OPTIONS,
    );
    ctx.consume_aura(AURA_ANCESTRAL_SWIFTNESS);
    consume_flowing_elements(ctx);
}

pub(crate) fn tempest_hook(ctx: &mut HookCtx<'_>) {
    let stormwell_maelstrom = elemental_config(ctx).stormwell_tempest_maelstrom;

    if stormwell_maelstrom > 0.0
        && elemental_config(ctx).stormwell_tempest_bug
        && !ctx.is_aura_active(AURA_STORMKEEPER)
    {
        ctx.gain_resource(stormwell_maelstrom);
    }

    // Every Tempest execute decrements the buff.

    ctx.consume_aura(AURA_TEMPEST);

    if elemental_config(ctx).tww3_stormbringer_4pc && ctx.consume_aura_stack(AURA_STORMS_EYE) {
        let storms_eye = ctx.effect_sp_coefficient(
            crate::generated::specs::elemental_shaman::DAMAGE_EFFECT::STORMS_EYE_DAMAGE,
        );

        ctx.deal_damage_sp(
            crate::generated::specs::elemental_shaman::DAMAGE_SPELL::STORMS_EYE,
            storms_eye,
            DamageFlags::empty(),
        );
    }

    empowered_lightning_cast(
        ctx,
        crate::generated::specs::elemental_shaman::DAMAGE_EFFECT::TEMPEST_OVERLOAD,
        0.0,
        TEMPEST_OPTIONS,
    );

    if elemental_config(ctx).arc_discharge {
        ctx.apply_aura(AURA_STORMKEEPER);
        ctx.add_proc_counter(
            wowlab_engine_combat::generated_identities::proc_counter::STORMKEEPER,
            ARC_DISCHARGE_CHARGES,
        );
    }
}

pub(crate) fn chain_lightning_hook(ctx: &mut HookCtx<'_>) {
    empowered_lightning_cast(
        ctx,
        crate::generated::specs::elemental_shaman::DAMAGE_EFFECT::CHAIN_LIGHTNING_OVERLOAD,
        CHAIN_LIGHTNING_OVERLOAD_MAELSTROM,
        CHAIN_LIGHTNING_OPTIONS,
    );
    ctx.consume_aura(AURA_ANCESTRAL_SWIFTNESS);
    consume_flowing_elements(ctx);
}

pub(crate) fn lava_burst_hook(ctx: &mut HookCtx<'_>) {
    let cfg = elemental_config(ctx);

    if cfg.master_of_the_elements {
        ctx.apply_aura(AURA_MASTER_OF_THE_ELEMENTS);
    }

    if cfg.potm_chance > 0.0 && proc_chance(ctx.rng(), cfg.potm_chance) {
        ctx.apply_aura(AURA_POWER_OF_THE_MAELSTROM);
    }

    ctx.gain_resource(LAVA_BURST_MAELSTROM);
    ctx.consume_aura(AURA_LAVA_SURGE);

    let chance = overload_chance(ctx);

    if proc_chance(ctx.rng(), chance) {
        fire_overload(
            ctx,
            crate::generated::specs::elemental_shaman::DAMAGE_EFFECT::LAVA_BURST_OVERLOAD,
            LAVA_BURST_OVERLOAD_MAELSTROM,
        );
    }

    if ctx.is_aura_active(AURA_ASCENDANCE) {
        fire_overload(
            ctx,
            crate::generated::specs::elemental_shaman::DAMAGE_EFFECT::LAVA_BURST_OVERLOAD,
            LAVA_BURST_OVERLOAD_MAELSTROM,
        );
    }

    ctx.consume_aura(AURA_ANCESTRAL_SWIFTNESS);
    consume_flowing_elements(ctx);
}

pub(crate) fn elemental_blast_hook(ctx: &mut HookCtx<'_>) {
    let maelstrom_spent = ctx.last_primary_spent();

    fire_elemental_blast(ctx, 1.0);

    if elemental_config(ctx).unlimited_power {
        ctx.apply_aura(AURA_UNLIMITED_POWER);
    }

    ctx.apply_aura(AURA_LIGHTNING_ROD);
    ctx.consume_aura(AURA_MASTER_OF_THE_ELEMENTS);
    let cfg = elemental_config(ctx);

    if cfg.aftershock_chance > 0.0 && proc_chance(ctx.rng(), cfg.aftershock_chance) {
        ctx.gain_resource(maelstrom_spent);
    }

    if maelstrom_spent > 0.0
        && cfg.tempest_chance_on_blast > 0.0
        && proc_chance(ctx.rng(), cfg.tempest_chance_on_blast)
    {
        ctx.apply_aura(AURA_TEMPEST);
    }

    ctx.consume_aura(AURA_OVERCHARGE_TIER);
    ctx.consume_aura(AURA_ANCESTRAL_SWIFTNESS);
}

pub(crate) fn stormkeeper_hook(ctx: &mut HookCtx<'_>) {
    let cfg = elemental_config(ctx);

    ctx.reset_proc_counter(wowlab_engine_combat::generated_identities::proc_counter::STORMKEEPER);
    ctx.add_proc_counter(
        wowlab_engine_combat::generated_identities::proc_counter::STORMKEEPER,
        STORMKEEPER_CAST_CHARGES,
    );

    if cfg.summon_storm_elemental {
        summon_storm_elemental(ctx);
    }
}

pub(crate) fn stormkeeper_expire_hook(ctx: &mut HookCtx<'_>) {
    if !elemental_config(ctx).mid2_4pc {
        return;
    }

    if ctx.is_aura_active(AURA_ASCENDANCE) {
        if let Some(runtime) = ctx.spec_runtime_mut::<ElementalRuntime>() {
            runtime.stormkeeper_faded_during_ascendance = true;
        }
    } else {
        ctx.apply_aura_n(AURA_FLOWING_ELEMENTS, MID2_EMPOWERED_BUILDER_CHARGES);
    }
}

pub(crate) fn ascendance_expire_hook(ctx: &mut HookCtx<'_>) {
    if !elemental_config(ctx).mid2_4pc {
        return;
    }

    let stormkeeper_buffered = ctx
        .spec_runtime_mut::<ElementalRuntime>()
        .is_some_and(|runtime| std::mem::take(&mut runtime.stormkeeper_faded_during_ascendance));
    let stacks = if stormkeeper_buffered {
        MID2_OVERLAP_EMPOWERED_BUILDER_CHARGES
    } else {
        MID2_EMPOWERED_BUILDER_CHARGES
    };

    ctx.apply_aura_n(AURA_FLOWING_ELEMENTS, stacks);
}

pub(crate) fn ascendance_hook(ctx: &mut HookCtx<'_>) {
    let cfg = elemental_config(ctx);

    if cfg.tww3_stormbringer_2pc {
        ctx.apply_aura(AURA_TEMPEST);
    }

    if cfg.tww3_stormbringer_4pc {
        ctx.apply_aura_n(AURA_STORMS_EYE, STORMS_EYE_CHARGES);
    }

    ctx.reset_cooldown(SPELL_LAVA_BURST);
    ctx.apply_aura(AURA_FLAME_SHOCK);
    let lava_burst = ctx.effect_sp_coefficient(
        crate::generated::specs::elemental_shaman::DAMAGE_EFFECT::LAVA_BURST_DAMAGE,
    );

    ctx.deal_damage_sp(
        crate::generated::specs::elemental_shaman::DAMAGE_SPELL::LAVA_BURST,
        lava_burst,
        DamageFlags::empty(),
    );
    fire_overload(
        ctx,
        crate::generated::specs::elemental_shaman::DAMAGE_EFFECT::LAVA_BURST_OVERLOAD,
        LAVA_BURST_OVERLOAD_MAELSTROM,
    );

    let chance = overload_chance(ctx);

    if proc_chance(ctx.rng(), chance) {
        fire_overload(
            ctx,
            crate::generated::specs::elemental_shaman::DAMAGE_EFFECT::LAVA_BURST_OVERLOAD,
            LAVA_BURST_OVERLOAD_MAELSTROM,
        );
    }

    if cfg.summon_fire_elemental {
        summon_fire_elemental(ctx);
    }
}

/// Returns Elemental Overload mastery damage from spell 168534 e3/e4.
#[must_use]
pub(crate) fn mastery(ctx: &MasteryCtx<'_>) -> f64 {
    if ctx.is_pet {
        return ctx.bonus(EFFECT::MASTERY_PET_DAMAGE.1);
    }

    let effect = if ctx.is_periodic {
        EFFECT::MASTERY_PERIODIC_DAMAGE.1
    } else {
        EFFECT::MASTERY_DIRECT_DAMAGE.1
    };
    let mut mult = if ctx.affects_spell(effect) {
        ctx.bonus(effect)
    } else {
        1.0
    };

    if matches!(ctx.spell_id, SPELL::LAVA_BURST | SPELL::LAVA_BURST_OVERLOAD)
        && ctx.is_aura_active(AURA_FLAME_SHOCK)
    {
        mult *= 1.0 + ctx.instance.player_crit() / HUNDRED;
    }

    mult
}

const fn flame_shock_filter(spell_id: u32) -> bool {
    spell_id == SPELL::FLAME_SHOCK
}

const fn lightning_rod_filter(spell_id: u32) -> bool {
    matches!(
        spell_id,
        SPELL::LIGHTNING_BOLT
            | SPELL::CHAIN_LIGHTNING
            | SPELL::TEMPEST
            | SPELL::LIGHTNING_BOLT_OVERLOAD
            | SPELL::CHAIN_LIGHTNING_OVERLOAD
            | SPELL::TEMPEST_OVERLOAD
    )
}

fn lightning_rod_fire(ctx: &mut HookCtx<'_>, impact: ImpactEvent) {
    let cfg = elemental_config(ctx);

    if cfg.lightning_rod_mult > 0.0 && ctx.is_aura_active(AURA_LIGHTNING_ROD) {
        ctx.deal_resolved_damage(
            crate::generated::specs::elemental_shaman::DAMAGE_SPELL::LIGHTNING_ROD_DAMAGE,
            impact.amount * cfg.lightning_rod_mult,
        );
    }
}

fn lava_surge_fire(ctx: &mut HookCtx<'_>, _impact: ImpactEvent) {
    if ctx.roll_attempt_proc(
        wowlab_engine_combat::generated_identities::proc_counter::LAVA_SURGE_ATTEMPT,
        |attempt| {
            let exponent = LAVA_SURGE_EXPONENT_SCALE * (f64::from(attempt) - LAVA_SURGE_MIDPOINT);

            (LAVA_SURGE_CEILING - LAVA_SURGE_DECAY_BASE.powf(exponent)).max(0.0)
        },
    ) {
        ctx.reset_cooldown(SPELL_LAVA_BURST);
        ctx.apply_aura(AURA_LAVA_SURGE);
    }
}

/// Only Lightning Bolt Overload is hand-flagged.
static STORMKEEPER_OVERLOAD_SPELLS: [u32; 1] = [EFFECT::LIGHTNING_BOLT_OVERLOAD.0];

static MID2_SPENDER_DAMAGE_SPELLS: [u32; 3] = [
    SPELL::EARTH_SHOCK,
    SPELL::ELEMENTAL_BLAST,
    EFFECT::EARTHQUAKE_DAMAGE.0,
];

fn register_conditional_multipliers(built: &mut CombatSystemDraft, params: &HandlerParams<'_>) {
    let data = &params.game_data;
    let mult_from = |effect: (u32, u8)| {
        1.0 + data.base_points(SpellIdx::from_raw(effect.0), effect.1) / HUNDRED
    };

    // The elemental summon auras carry their Elemental Unity modifiers as ordinary DBC effects, but
    // the game only scripts them on when Elemental Unity is picked, and swaps them for the talent's
    // own effects under Primal Elementalist. Mask the data-derived rows so
    // the talent state below is the only thing that applies them.

    for effect in EU_FIRE_MASKED_EFFECTS {
        built.mask_aura_dbc_effect(AURA_FIRE_ELEMENTAL, effect.0, effect.1);
    }

    for effect in EU_STORM_MASKED_EFFECTS {
        built.mask_aura_dbc_effect(AURA_STORM_ELEMENTAL, effect.0, effect.1);
    }

    if params.talent_picked(TALENT::ELEMENTAL_UNITY) {
        let pe = params.talent_picked(TALENT::PRIMAL_ELEMENTALIST);
        let fire = if pe {
            EFFECT::ELEMENTAL_UNITY_FIRE
        } else {
            EFFECT::FIRE_ELEMENTAL_UNITY
        };
        let storm = if pe {
            EFFECT::ELEMENTAL_UNITY_STORM
        } else {
            EFFECT::STORM_ELEMENTAL_UNITY_PET
        };

        let fire_mult = mult_from(fire);
        let storm_mult = mult_from(storm);

        for spells in [
            EU_FIRE_PLAYER_SPELLS.as_slice(),
            EU_FIRE_PET_SPELLS.as_slice(),
        ] {
            built.set_aura_effect(
                AURA_FIRE_ELEMENTAL,
                BuffEffect::DamageMultSpells(fire_mult, spells),
            );
        }

        for spells in [
            FLAG_126_PLAYER_SPELLS.as_slice(),
            EU_STORM_PET_SPELLS.as_slice(),
        ] {
            built.set_aura_effect(
                AURA_STORM_ELEMENTAL,
                BuffEffect::DamageMultSpells(storm_mult, spells),
            );
        }
    }

    if params.talent_picked(TALENT::LIGHTNING_CAPACITOR) {
        built.set_aura_effect(
            AURA_LIGHTNING_SHIELD,
            BuffEffect::DamageMultSpells(
                mult_from(EFFECT::LIGHTNING_CAPACITOR_DAMAGE),
                &FLAG_126_PLAYER_SPELLS,
            ),
        );
    }

    if params.talent_picked(TALENT::FLAMETONGUE_WEAPON) {
        let effect = EFFECT::IMPROVED_FLAMETONGUE_DAMAGE;
        let pct = data.base_points(SpellIdx::from_raw(effect.0), effect.1);

        built.register_passive_driver_effect(PassiveDriverEffect::new(
            TALENT::FLAMETONGUE_WEAPON,
            BuffEffect::DamageMultSpells(1.0 + pct / HUNDRED, &IFW_SPELLS),
        ));
    }
}

fn register_stormkeeper_damage(built: &mut CombatSystemDraft, params: &HandlerParams<'_>) {
    let stormkeeper_mult = 1.0
        + params
            .game_data
            .effect_base_points(EFFECT::STORMKEEPER_DAMAGE)
            / HUNDRED;

    built.patch_aura(AURA_STORMKEEPER, |aura| {
        try_push_effect(
            &mut aura.effects,
            BuffEffect::DamageMultSpells(stormkeeper_mult, &STORMKEEPER_OVERLOAD_SPELLS),
        )
        .expect("Stormkeeper aura has room for its overload damage modifier");
    });
}

pub(super) fn wire_elemental(
    built: &mut CombatSystemDraft,
    params: &HandlerParams<'_>,
) -> Result<(), wowlab_engine_ports::EngineError> {
    if params.talent_picked(TALENT::ELEMENTAL_BLAST) {
        built.disable_spell(SPELL::EARTH_SHOCK);

        built.patch_spell(SPELL_ELEMENTAL_BLAST, |spell| {
            spell.damage = RuntimeDamageDef::None;
        });
    }

    register_stormkeeper_damage(built, params);
    register_conditional_multipliers(built, params);

    if params
        .set_bonus_auras
        .contains(&SET_BONUS::MID2_ELEMENTAL_2PC)
    {
        let bonus = params
            .game_data
            .effect_base_points(EFFECT::MID2_SPENDER_DAMAGE);

        built.register_passive_driver_effect(PassiveDriverEffect::new(
            SET_BONUS::MID2_ELEMENTAL_2PC,
            BuffEffect::DamageMultSpells(1.0 + bonus / HUNDRED, &MID2_SPENDER_DAMAGE_SPELLS),
        ));
    }

    if params.talent_picked(TALENT::FLAMETONGUE_WEAPON) {
        built.register_weapon_imbue(SPELL::FLAMETONGUE_WEAPON, "flametongue_weapon", true);
    }

    built.register_impact_proc(
        ImpactProc::new(lava_surge_fire)
            .with_spell_filter(flame_shock_filter)
            .periodic_only(),
    );

    built.register_impact_proc(
        ImpactProc::new(lightning_rod_fire)
            .with_spell_filter(lightning_rod_filter)
            .skip_periodic(),
    );

    register_elemental_config(built, params)?;

    Ok(())
}