wowlab_engine_combat/pipeline/

empower.rs

use super::{
    CombatCtx, EmpowerReleaseAdjustment, HookCtx, LocalSpellIdx, RuntimeDamageDef,
    SpellCastPayload, SpellData, aura_stacks, secondary_spends_all_points,
};

pub(super) fn empower_release_adjustment(
    ctx: &mut CombatCtx<'_>,
    spell_local: LocalSpellIdx,
    rank: u8,
) -> EmpowerReleaseAdjustment {
    if rank == 0 {
        return EmpowerReleaseAdjustment::default();
    }

    let hook = ctx
        .program
        .empower_release_hooks
        .get(spell_local.as_usize())
        .copied()
        .flatten();
    let Some(hook) = hook else {
        return EmpowerReleaseAdjustment::default();
    };
    let hook_ctx = HookCtx::new(
        crate::context::HookCtxServices {
            program: ctx.program,
            instance: ctx.instance,
            sink: ctx.sink,
            rng: ctx.rng,
        },
        crate::context::HookCtxRequest::for_target(ctx.now, ctx.target).with_source(ctx.source),
    )
    .with_empower_rank(rank);

    hook(&hook_ctx, rank)
}

pub(super) fn adjust_empower_payload(
    program: &crate::state::CombatProgram,
    state: &crate::state::CombatInstance,
    spell: &SpellData,
    damage: RuntimeDamageDef,
    adjustment: EmpowerReleaseAdjustment,
) -> SpellCastPayload {
    let unchanged = SpellCastPayload {
        damage,
        base_points: spell.base_points,
        aura_duration_ms: None,
    };
    let Some(transfer) = adjustment.periodic_tick_transfer else {
        return unchanged;
    };

    let Some((periodic, aura_duration_ms)) = empower_periodic_transfer_data(
        program,
        state,
        spell,
        transfer.total_ticks,
        transfer.transferred_ticks,
    ) else {
        return unchanged;
    };
    let ticks = f64::from(transfer.transferred_ticks);

    match (damage, periodic) {
        (
            RuntimeDamageDef::SpCoefficient { coef, is_physical },
            crate::state::PeriodicKind::DamageSp {
                coef: periodic_coef,
                is_physical: periodic_physical,
            }
            | crate::state::PeriodicKind::RollingDamageSp {
                coef: periodic_coef,
                is_physical: periodic_physical,
            },
        ) if is_physical == periodic_physical => SpellCastPayload {
            damage: RuntimeDamageDef::SpCoefficient {
                coef: coef + periodic_coef * ticks,
                is_physical,
            },
            base_points: spell.base_points,
            aura_duration_ms: Some(aura_duration_ms),
        },
        (
            RuntimeDamageDef::None,
            crate::state::PeriodicKind::DamageSp { coef, is_physical }
            | crate::state::PeriodicKind::RollingDamageSp { coef, is_physical },
        ) => SpellCastPayload {
            damage: RuntimeDamageDef::SpCoefficient {
                coef: coef * ticks,
                is_physical,
            },
            base_points: spell.base_points,
            aura_duration_ms: Some(aura_duration_ms),
        },
        (
            RuntimeDamageDef::ApCoefficient {
                coef,
                is_physical,
                ap_type,
            },
            crate::state::PeriodicKind::DamageAp {
                coef: periodic_coef,
                is_physical: periodic_physical,
            }
            | crate::state::PeriodicKind::RollingDamageAp {
                coef: periodic_coef,
                is_physical: periodic_physical,
            },
        ) if is_physical == periodic_physical => SpellCastPayload {
            damage: RuntimeDamageDef::ApCoefficient {
                coef: coef + periodic_coef * ticks,
                is_physical,
                ap_type,
            },
            base_points: spell.base_points,
            aura_duration_ms: Some(aura_duration_ms),
        },
        (
            RuntimeDamageDef::None,
            crate::state::PeriodicKind::DamageAp { coef, is_physical }
            | crate::state::PeriodicKind::RollingDamageAp { coef, is_physical },
        ) => SpellCastPayload {
            damage: RuntimeDamageDef::ApCoefficient {
                coef: coef * ticks,
                is_physical,
                ap_type: crate::state::WeaponApType::None,
            },
            base_points: spell.base_points,
            aura_duration_ms: Some(aura_duration_ms),
        },
        (
            RuntimeDamageDef::Flat(amount),
            crate::state::PeriodicKind::FlatDamage {
                amount: periodic_amount,
                ..
            }
            | crate::state::PeriodicKind::RollingFlatDamage {
                amount: periodic_amount,
                ..
            },
        ) => SpellCastPayload {
            damage: RuntimeDamageDef::Flat(amount + periodic_amount * ticks),
            base_points: spell.base_points,
            aura_duration_ms: Some(aura_duration_ms),
        },
        (
            RuntimeDamageDef::None,
            crate::state::PeriodicKind::FlatDamage { amount, .. }
            | crate::state::PeriodicKind::RollingFlatDamage { amount, .. },
        ) => SpellCastPayload {
            damage: RuntimeDamageDef::Flat(amount * ticks),
            base_points: spell.base_points,
            aura_duration_ms: Some(aura_duration_ms),
        },
        (
            direct @ (RuntimeDamageDef::SpCoefficient { .. }
            | RuntimeDamageDef::ApCoefficient { .. }),
            crate::state::PeriodicKind::FlatDamage { amount, .. }
            | crate::state::PeriodicKind::RollingFlatDamage { amount, .. },
        ) => SpellCastPayload {
            damage: direct,
            base_points: spell.base_points + amount * ticks,
            aura_duration_ms: Some(aura_duration_ms),
        },
        _ => {
            tracing::warn!(
                spell_id = spell.spell_id,
                "empower periodic transfer has incompatible direct and periodic damage kinds"
            );

            unchanged
        }
    }
}

pub(super) fn empower_periodic_transfer_data(
    program: &crate::state::CombatProgram,
    _state: &crate::state::CombatInstance,
    spell: &SpellData,
    total_ticks: u16,
    transferred_ticks: u16,
) -> Option<(crate::state::PeriodicKind, u32)> {
    if transferred_ticks > total_ticks {
        tracing::warn!(
            spell_id = spell.spell_id,
            total_ticks,
            transferred_ticks,
            "empower release driver transferred more periodic ticks than exist"
        );

        return None;
    }

    let Some(aura_local) = spell.applies_aura else {
        tracing::warn!(
            spell_id = spell.spell_id,
            "empower periodic transfer requires an applied aura"
        );

        return None;
    };
    let Some(aura) = program.auras.get(aura_local.as_usize()).copied() else {
        tracing::warn!(
            spell_id = spell.spell_id,
            "empower periodic transfer references an unknown aura"
        );

        return None;
    };
    let Some(periodic) = aura.periodic else {
        tracing::warn!(
            spell_id = spell.spell_id,
            aura_id = aura.aura_id,
            "empower periodic transfer requires a periodic aura"
        );

        return None;
    };
    let remaining_ticks = total_ticks - transferred_ticks;
    let Some(aura_duration_ms) = u32::from(remaining_ticks).checked_mul(periodic.tick_interval_ms)
    else {
        tracing::warn!(
            spell_id = spell.spell_id,
            aura_id = aura.aura_id,
            remaining_ticks,
            tick_interval_ms = periodic.tick_interval_ms,
            "empower periodic duration overflow"
        );

        return None;
    };

    Some((periodic.effect, aura_duration_ms))
}

pub(super) fn finisher_scaled_damage(ctx: &CombatCtx<'_>, spell: &SpellData) -> RuntimeDamageDef {
    if spell.cost.secondary_resource_cost > 0.0
        && secondary_spends_all_points(ctx.program, ctx.instance)
    {
        spell
            .damage
            .scaled(ctx.instance.runtime.resources.last_secondary_spent)
    } else {
        spell.damage
    }
}

pub(super) fn empower_rank_for_cast(
    ctx: &CombatCtx<'_>,
    spell_local: LocalSpellIdx,
    requested_rank: u8,
) -> u8 {
    let Some(spell) = ctx.program.spells.get(spell_local.as_usize()).copied() else {
        return 0;
    };

    if spell.empower_rank_count > 0
        && ctx
            .program
            .rotation
            .cast_profile(spell_local)
            .max_empower_aura
            .is_some_and(|requirement| {
                aura_stacks(
                    ctx.program,
                    ctx.instance,
                    requirement.local,
                    ctx.source,
                    Some(ctx.target),
                ) > 0
            })
    {
        spell.empower_rank_count
    } else if spell.empower_rank_count > 0 {
        requested_rank.max(1).min(spell.empower_rank_count)
    } else {
        0
    }
}