wowlab_engine_combat/systems/

channel.rs

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

use wowlab_engine_domain::rotation::DenseBuffer;
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, execute_effect_range,
    procs::{ResourceTelemetry, emit_resource},
    resources::spend_resource,
};
use crate::{
    DamageFlags,
    context::{CombatCtx, HookCtx},
    state::CombatState,
};

// #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 state = &mut *ctx.state;
    let buf = &mut *ctx.buf;
    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((local, spell_ref)) = state.spell_data(spell_id) else {
        return;
    };
    let spell = *spell_ref;

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

    let idx = wowlab_types::sim::SpellIdx(spell_id);

    if !state.is_valid_target(target) {
        if let Some(spell) = buf.spell_mut(idx) {
            spell.is_channeling = 0;
            spell.channel_end = now.as_secs_f64();
        }

        buf.player_mut().channel_end = now.as_secs_f64();
        state.runtime.casting.active_channel_target = None;
        state.schedule(Event::PlayerReady { t: now });

        return;
    }

    if buf.spell(idx).is_some_and(|s| s.is_channeling == 0) {
        return;
    }

    if buf
        .spell(idx)
        .is_some_and(|spell| now.as_secs_f64() > spell.channel_end)
    {
        super::end_channel(state, buf, now);

        return;
    }

    if !spend_channel_tick_cost(
        &mut CombatCtx {
            state,
            buf,
            sink,
            now,
            rng,
            source,
            target,
        },
        &spell,
        idx,
    ) {
        return;
    }

    // SimC splits `tick()` from `last_tick()` on the dot's own remaining-tick count, so the engine
    // publishes the same signal instead of leaving each hook to re-derive 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, buf, idx, now);

    execute_channel_tick_payload(
        &mut CombatCtx {
            state,
            buf,
            sink,
            now,
            rng,
            source,
            target,
        },
        &spell,
    );

    state.runtime.casting.active_channel_last_tick = now;

    if let Some(hook_fn) = state
        .defs
        .tick_hooks
        .get(local.as_usize())
        .copied()
        .flatten()
    {
        let mut hook_ctx = HookCtx::new(
            crate::context::HookCtxServices {
                state,
                buf,
                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 {
            state,
            buf,
            sink,
            now,
            rng,
            source,
            target,
        },
        &spell,
    );

    state.runtime.casting.active_channel_damage_mult = previous_damage_mult;

    if let Some(s) = buf.spell_mut(idx) {
        if now.as_secs_f64() >= s.channel_end {
            s.is_channeling = 0;
            state.runtime.casting.active_channel_target = None;
            state.runtime.casting.active_channel_spell_id = None;
        }
    }
}

fn spend_channel_tick_cost(
    ctx: &mut CombatCtx<'_>,
    spell: &crate::state::SpellData,
    spell_idx: wowlab_types::sim::SpellIdx,
) -> bool {
    let tick_cost = if spell.channel.tick_cost_aura != 0
        && super::auras::aura_stacks_by_id(
            ctx.state,
            ctx.buf,
            spell.channel.tick_cost_aura,
            ctx.source,
            Some(ctx.target),
        ) > 0
    {
        spell.channel.tick_cost_alt
    } else {
        spell.channel.tick_cost
    };

    if tick_cost <= 0.0 {
        return true;
    }

    if spend_resource(ctx.state, ctx.buf, tick_cost) {
        emit_resource(
            ctx.state,
            ctx.buf,
            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"
    );

    if let Some(slot) = ctx.buf.spell_mut(spell_idx) {
        slot.is_channeling = 0;
        slot.channel_end = ctx.now.as_secs_f64();
    }

    ctx.buf.player_mut().channel_end = ctx.now.as_secs_f64();
    ctx.state.runtime.casting.active_channel_target = None;
    ctx.state.schedule(Event::PlayerReady { t: ctx.now });

    false
}

fn apply_channel_tick_damage_factor(
    state: &mut CombatState,
    buf: &DenseBuffer,
    spell: wowlab_types::sim::SpellIdx,
    now: SimTime,
) -> f64 {
    let previous = state.runtime.casting.active_channel_damage_mult;

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

    previous
}

fn channel_tick_damage_factor(
    state: &CombatState,
    buf: &DenseBuffer,
    spell: wowlab_types::sim::SpellIdx,
    now: SimTime,
) -> f64 {
    let Some(slot) = buf.spell(spell) else {
        return 1.0;
    };

    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) {
    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.state, spell.channel.tick_effects);
    let resolved_flags = if hostile {
        super::resolve_spell_impact_flags(ctx, spell.spell_id, tick_flags)
    } else {
        Some(tick_flags)
    };
    let Some(resolved_flags) = resolved_flags else {
        return;
    };

    apply_channel_tick_damage(ctx, spell, resolved_flags);
    execute_effect_range(
        ctx,
        EffectExecution {
            range: spell.channel.tick_effects,
            profile_spell_id: spell.spell_id,
            flags: resolved_flags,
        },
    );
}

fn execute_channel_completion_effects(ctx: &mut CombatCtx<'_>, spell: &crate::state::SpellData) {
    if !ctx.state.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,
            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(spell_id) = ctx.state.runtime.casting.active_channel_spell_id else {
        return false;
    };
    let Some((_, spell)) = ctx.state.spell_data(spell_id) else {
        return false;
    };
    let spell = *spell;
    let interval_ms = ctx.state.runtime.casting.active_channel_tick_interval_ms;

    if interval_ms > 0 {
        let elapsed_ms = ctx
            .now
            .saturating_sub(ctx.state.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.state.runtime.casting.active_channel_damage_mult;

            ctx.state.runtime.casting.active_channel_damage_mult *= factor;
            execute_channel_tick_payload(ctx, &spell);
            ctx.state.runtime.casting.active_channel_damage_mult = previous;
        }
    }

    ctx.state.runtime.casting.channel_chain_spell_id = chain.then_some(spell_id);
    super::end_channel(ctx.state, ctx.buf, ctx.now);
    ctx.state.schedule(Event::PlayerReady {
        t: if chain {
            ctx.now
        } else {
            ctx.now.saturating_add(SimTime::from_millis(
                u32::from(spell.channel.completion.apply_lag)
                    * ctx.state.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(
    state: &mut CombatState,
    buf: &mut DenseBuffer,
    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_target = Some(target);
    let generation = state.runtime.casting.channel_generation;
    let mut ctx = CombatCtx {
        state,
        buf,
        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,
    flags: DamageFlags,
) {
    let use_alt = spell.channel.tick_damage_aura != 0
        && super::auras::aura_stacks_by_id(
            ctx.state,
            ctx.buf,
            spell.channel.tick_damage_aura,
            ctx.source,
            Some(ctx.target),
        ) > 0;
    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.state.runtime.casting.active_channel_damage_mult;

    crate::systems::deal_profiled_damage_def(
        ctx,
        crate::state::DamageEffectRef::new(damage_spell_id, 1),
        spell.spell_id,
        Some(spell.base_points),
        damage.scaled(channel_damage_mult),
        flags
            | if may_crit {
                DamageFlags::empty()
            } else {
                DamageFlags::NO_CRIT
            },
    );
}

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