wowlab_engine_combat/systems/

channel.rs

//! Channeled-spell per-tick cost, damage, and early-end handling.

use wowlab_engine_ports::Event;
use wowlab_engine_telemetry::ResourceEventKind;
#[cfg(test)]
use wowlab_engine_telemetry::TelemetrySink;
use wowlab_types::sim::SimTime;
#[cfg(test)]
use wowlab_types::sim::{ActorId, EnemyIdx};

use super::{
    EffectExecution, ProfiledDamageDef, execute_effect_range,
    procs::{ResourceTelemetry, emit_resource},
    resources::spend_resource,
};
use crate::{
    DamageFlags,
    context::{CombatCtx, HookCtx},
    state::{ActiveChannelIdentity, CombatInstance},
};

// #t(fn: rust_cyclomatic_complexity) channel tick branches over cost/affordability/early-end/tick-hook paths
pub fn process_channel_tick_for(ctx: &mut CombatCtx<'_>, spell_id: u32, generation: u64) {
    let source = ctx.source;
    let target = ctx.target;
    let now = ctx.now;
    let program = ctx.program;
    let state = &mut *ctx.instance;
    let sink = &mut *ctx.sink;
    let rng = &mut *ctx.rng;

    // A channel may end and be recast while its old tick events remain in the queue. Reject the
    // stale generation before consulting target validity or shared channel flags, since either
    // branch could otherwise damage or terminate the newer cast.

    if state.runtime.casting.channel_generation != generation
        || state.runtime.casting.active_channel_target != Some(target)
    {
        return;
    }

    let Some(active_channel) = state.runtime.casting.active_channel else {
        return;
    };

    if active_channel.spell.as_u32() != spell_id {
        return;
    }

    let local = active_channel.local;
    let spell = *program.spell(local);

    if !spell.channel.behavior.is_channel {
        return;
    }

    let idx = active_channel.spell;

    if !state.is_valid_target(target) {
        end_channel_for_invalid_target(state, active_channel, now);

        return;
    }

    if state.buffer.spell_at(active_channel.handle).is_channeling == 0 {
        return;
    }

    if now.as_secs_f64() > state.buffer.spell_at(active_channel.handle).channel_end {
        super::end_channel(program, state, now);

        return;
    }

    if !spend_channel_tick_cost(
        &mut CombatCtx {
            program,
            instance: state,
            sink,
            now,
            rng,
            source,
            target,
        },
        &spell,
        active_channel.tick_cost_aura,
    ) {
        return;
    }

    // Hooks receive the channel's own remaining-tick signal instead of re-deriving it from
    // timestamps.

    let remaining = state
        .runtime
        .casting
        .active_channel_ticks_remaining
        .saturating_sub(1);

    state.runtime.casting.active_channel_ticks_remaining = remaining;
    state.runtime.casting.active_channel_on_last_tick = remaining == 0;

    let previous_damage_mult = apply_channel_tick_damage_factor(state, active_channel.handle, now);

    execute_channel_tick_payload(
        &mut CombatCtx {
            program,
            instance: state,
            sink,
            now,
            rng,
            source,
            target,
        },
        &spell,
        local,
        active_channel.tick_damage_aura,
    );

    state.runtime.casting.active_channel_last_tick = now;

    if let Some(hook_fn) = program.tick_hooks.get(local.as_usize()).copied().flatten() {
        let mut hook_ctx = HookCtx::new(
            crate::context::HookCtxServices {
                program,
                instance: state,
                sink,
                rng,
            },
            crate::context::HookCtxRequest::for_target(now, target).with_source(source),
        )
        .with_driver_spell(idx.0);

        hook_fn(&mut hook_ctx);
    }

    execute_channel_completion_effects(
        &mut CombatCtx {
            program,
            instance: state,
            sink,
            now,
            rng,
            source,
            target,
        },
        &spell,
        local,
    );

    state.runtime.casting.active_channel_damage_mult = previous_damage_mult;

    let channel_complete = {
        let s = state.buffer.spell_mut_at(active_channel.handle);

        if now.as_secs_f64() < s.channel_end {
            false
        } else {
            s.is_channeling = 0;

            true
        }
    };

    complete_channel_state(state, channel_complete, now);
}

fn complete_channel_state(state: &mut CombatInstance, channel_complete: bool, _now: SimTime) {
    if !channel_complete {
        return;
    }

    state.runtime.casting.active_channel_target = None;
    state.runtime.casting.active_channel = None;

    #[cfg(feature = "rotation-optimizations")]
    state.runtime.rotation_mutations.record_semantic(
        crate::state::runtime::RotationSemanticMutation::SpellState,
        crate::state::runtime::RotationMutationDirection::Fall,
        _now,
    );
}

fn end_channel_for_invalid_target(
    state: &mut CombatInstance,
    active_channel: ActiveChannelIdentity,
    now: SimTime,
) {
    let spell = state.buffer.spell_mut_at(active_channel.handle);

    spell.is_channeling = 0;
    spell.channel_end = now.as_secs_f64();

    state.buffer.player_mut().channel_end = now.as_secs_f64();
    state.runtime.casting.active_channel_target = None;

    #[cfg(feature = "rotation-optimizations")]
    state.runtime.rotation_mutations.record_semantic(
        crate::state::runtime::RotationSemanticMutation::SpellState,
        crate::state::runtime::RotationMutationDirection::Fall,
        now,
    );
    state.schedule(Event::PlayerReady { t: now });
}

fn spend_channel_tick_cost(
    ctx: &mut CombatCtx<'_>,
    spell: &crate::state::SpellData,
    tick_cost_aura: Option<crate::state::CastAuraRequirement>,
) -> bool {
    let tick_cost = if tick_cost_aura.is_some_and(|requirement| {
        ctx.program
            .rotation
            .aura_active(ctx.instance, requirement, ctx.target)
    }) {
        spell.channel.tick_cost_alt
    } else {
        spell.channel.tick_cost
    };

    if tick_cost <= 0.0 {
        return true;
    }

    if spend_resource(ctx.program, ctx.instance, tick_cost, ctx.now) {
        emit_resource(
            ctx.program,
            ctx.instance,
            ctx.sink,
            ResourceTelemetry {
                kind: ResourceEventKind::Spend,
                amount: tick_cost,
                secondary: false,
                now: ctx.now,
                source_spell_id: spell.spell_id,
            },
        );

        return true;
    }

    tracing::trace!(
        spell_id = spell.spell_id,
        amount = tick_cost,
        "channel ended early: insufficient primary resource for tick cost"
    );

    super::end_channel(ctx.program, ctx.instance, ctx.now);
    ctx.instance.schedule(Event::PlayerReady { t: ctx.now });

    false
}

fn apply_channel_tick_damage_factor(
    state: &mut CombatInstance,
    handle: wowlab_engine_domain::rotation::SpellSlotHandle,
    now: SimTime,
) -> f64 {
    let previous = state.runtime.casting.active_channel_damage_mult;

    state.runtime.casting.active_channel_damage_mult *=
        channel_tick_damage_factor(state, handle, now);

    previous
}

fn channel_tick_damage_factor(
    state: &CombatInstance,
    handle: wowlab_engine_domain::rotation::SpellSlotHandle,
    now: SimTime,
) -> f64 {
    let slot = state.buffer.spell_at(handle);

    if now.as_secs_f64() < slot.channel_end {
        return 1.0;
    }

    let elapsed_ms = now
        .saturating_sub(state.runtime.casting.active_channel_last_tick)
        .as_millis();
    let interval_ms = state.runtime.casting.active_channel_tick_interval_ms;

    if interval_ms == 0 {
        1.0
    } else {
        (f64::from(elapsed_ms) / f64::from(interval_ms)).clamp(0.0, 1.0)
    }
}

fn execute_channel_tick_payload(
    ctx: &mut CombatCtx<'_>,
    spell: &crate::state::SpellData,
    local: crate::state::LocalSpellIdx,
    tick_damage_aura: Option<crate::state::CastAuraRequirement>,
) {
    let tick_flags = channel_tick_flags(spell);
    let hostile =
        !matches!(
            spell.channel.tick_damage,
            crate::state::RuntimeDamageDef::None
        ) || !matches!(
            spell.channel.tick_damage_alt,
            crate::state::RuntimeDamageDef::None
        ) || super::effect_range_is_hostile(ctx.program, ctx.instance, spell.channel.tick_effects);
    let resolved_flags = if hostile {
        super::resolve_spell_impact_flags(ctx, ctx.program.damage.spell_action(local), tick_flags)
    } else {
        Some(tick_flags)
    };
    let Some(resolved_flags) = resolved_flags else {
        return;
    };

    apply_channel_tick_damage(ctx, spell, tick_damage_aura, resolved_flags);
    execute_effect_range(
        ctx,
        EffectExecution {
            range: spell.channel.tick_effects,
            profile_spell_id: spell.spell_id,
            profile_action: ctx.program.damage.spell_action(local),
            flags: resolved_flags,
        },
    );
}

fn execute_channel_completion_effects(
    ctx: &mut CombatCtx<'_>,
    spell: &crate::state::SpellData,
    local: crate::state::LocalSpellIdx,
) {
    if !ctx.instance.runtime.casting.active_channel_on_last_tick
        || spell.channel.complete_effects.len == 0
    {
        return;
    }

    execute_effect_range(
        ctx,
        EffectExecution {
            range: spell.channel.complete_effects,
            profile_spell_id: spell.spell_id,
            profile_action: ctx.program.damage.spell_action(local),
            flags: DamageFlags::empty(),
        },
    );
}

/// Legally clips the active player channel, granting its elapsed partial tick.
///
/// `chain` permits an immediate recast of the same channel without starting another GCD.
#[must_use]
pub fn clip_active_channel(ctx: &mut CombatCtx<'_>, chain: bool) -> bool {
    let Some(active_channel) = ctx.instance.runtime.casting.active_channel else {
        return false;
    };
    let spell = *ctx.program.spell(active_channel.local);
    let interval_ms = ctx.instance.runtime.casting.active_channel_tick_interval_ms;

    if interval_ms > 0 {
        let elapsed_ms = ctx
            .now
            .saturating_sub(ctx.instance.runtime.casting.active_channel_last_tick)
            .as_millis();
        let factor = (f64::from(elapsed_ms) / f64::from(interval_ms)).clamp(0.0, 1.0);

        if factor > f64::EPSILON {
            let previous = ctx.instance.runtime.casting.active_channel_damage_mult;

            ctx.instance.runtime.casting.active_channel_damage_mult *= factor;
            execute_channel_tick_payload(
                ctx,
                &spell,
                active_channel.local,
                active_channel.tick_damage_aura,
            );
            ctx.instance.runtime.casting.active_channel_damage_mult = previous;
        }
    }

    ctx.instance.runtime.casting.channel_chain_spell = chain.then_some(active_channel.local);
    super::end_channel(ctx.program, ctx.instance, ctx.now);
    ctx.instance.schedule(Event::PlayerReady {
        t: if chain {
            ctx.now
        } else {
            ctx.now.saturating_add(SimTime::from_millis(
                u32::from(spell.channel.completion.apply_lag)
                    * ctx.program.config.cast_latency.channel_ms,
            ))
        },
    });

    true
}

const fn channel_tick_flags(spell: &crate::state::SpellData) -> DamageFlags {
    let mut bits = spell.damage_attribute_flags.bits();

    if spell.channel.timing.tick_is_periodic {
        bits |= DamageFlags::PERIODIC.bits();
    }

    if spell.behavior.is_pet {
        bits |= DamageFlags::PET.bits();
    }

    DamageFlags::from_bits_retain(bits)
}

#[cfg(test)]
fn process_channel_tick_fixture(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
    spell_id: u32,
    now: SimTime,
    rng: &mut dyn FnMut() -> f64,
    sink: &mut TelemetrySink,
) {
    let Some(target) = state.current_target() else {
        return;
    };

    state.runtime.casting.active_channel =
        program.active_channel_identity(wowlab_types::sim::SpellIdx::from_raw(spell_id));
    state.runtime.casting.active_channel_target = Some(target);
    let generation = state.runtime.casting.channel_generation;
    let mut ctx = CombatCtx {
        program,
        instance: state,
        sink,
        now,
        rng,
        source: ActorId::Player,
        target,
    };

    process_channel_tick_for(&mut ctx, spell_id, generation);
}

fn apply_channel_tick_damage(
    ctx: &mut CombatCtx<'_>,
    spell: &crate::state::SpellData,
    tick_damage_aura: Option<crate::state::CastAuraRequirement>,
    flags: DamageFlags,
) {
    let use_alt = tick_damage_aura.is_some_and(|requirement| {
        ctx.program
            .rotation
            .aura_active(ctx.instance, requirement, ctx.target)
    });
    let (damage, damage_spell_id, may_crit) = if use_alt {
        (
            spell.channel.tick_damage_alt,
            spell.channel.tick_damage_alt_spell_id,
            spell.channel.completion.tick_damage_alt_may_crit,
        )
    } else {
        (
            spell.channel.tick_damage,
            spell.channel.tick_spell_id,
            spell.channel.behavior.tick_may_crit,
        )
    };
    let channel_damage_mult = ctx.instance.runtime.casting.active_channel_damage_mult;
    let Some(active) = ctx.instance.runtime.casting.active_channel else {
        return;
    };
    let Some(binding) = ctx.program.damage.channel_request(active.local, use_alt) else {
        return;
    };

    crate::systems::deal_bound_profiled_damage_def(
        ctx,
        ProfiledDamageDef {
            binding,
            effect: crate::state::DamageEffectRef::new(damage_spell_id, 1),
            geometry_effect: crate::state::DamageEffectRef::new(damage_spell_id, 1),
            profile_spell_id: spell.spell_id,
            base_points: Some(spell.base_points),
            def: damage.scaled(channel_damage_mult),
            flags: flags
                | if may_crit {
                    DamageFlags::empty()
                } else {
                    DamageFlags::NO_CRIT
                },
            source_position: None,
            destination: None,
        },
    );
}

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