wowlab_engine_combat/pipeline/

impact.rs

use super::{
    ActorId, CombatCtx, DamageFlags, EffectExecution, Event, PendingSpellImpact, ProfiledDamageDef,
    RuntimeDamageDef, SimTime, SpellCastPayload, SpellCastTargetFlags, SpellData, apply_cast_aura,
    deal_profiled_damage_def_at, execute_effect_range, fire_expire_hooks, resolve_payload_flags,
};

pub(super) fn schedule_spell_impact(
    ctx: &mut CombatCtx<'_>,
    spell_local: crate::state::LocalSpellIdx,
    spell: &SpellData,
    payload: SpellCastPayload,
    now: SimTime,
) {
    let pending = &mut ctx.instance.runtime.pending;
    let impact_slot = pending
        .pending_spell_impacts
        .iter()
        .position(Option::is_none)
        .unwrap_or_else(|| {
            pending.pending_spell_impacts.push(None);
            pending.spell_impact_generations.push(0);

            pending.pending_spell_impacts.len() - 1
        });
    let generation = pending
        .spell_impact_generations
        .get_mut(impact_slot)
        .expect("pending impact generation parallels its arena slot");

    *generation = generation.wrapping_add(1).max(1);
    let impact = ctx.program.runtime_events.pending_impact(
        u32::try_from(impact_slot).expect("pending impact arena length fits in u32"),
        *generation,
    );

    // #t(rust_unchecked_indexing) impact_slot was obtained from or appended to this exact arena.
    pending.pending_spell_impacts[impact_slot] = Some(PendingSpellImpact {
        damage_binding: ctx.program.damage.spell_request(spell_local),
        spell_local,
        spell_handle: ctx.program.buffer_bindings.spell(spell_local),
        spell_id: spell.spell_id,
        profile_action: ctx.program.damage.spell_action(spell_local),
        damage_effect: spell.damage_effect,
        base_points: payload.base_points,
        damage: payload.damage,
        is_pet: spell.behavior.is_pet,
        may_crit: spell.damage_policy.may_crit,
        attribute_flags: spell.damage_attribute_flags,
        applies_aura: spell.applies_aura,
        applies_aura_duration_ms: payload.aura_duration_ms,
        followup_effects: spell.followup_effects,
        source: ctx.source,
        target: ctx.target,
        cast_complete_at: now,
        travel: spell.travel,
        required_explicit_target_mask: spell.targeting.required_explicit_target_mask,
        locked_source_transform: None,
        locked_target_transform: None,
        cast_destination: None,
    });

    let slot = ctx
        .instance
        .buffer
        .spell_mut_at(ctx.program.buffer_bindings.spell(spell_local));

    slot.in_flight_count += 1;
    slot.is_in_flight = 1;

    #[cfg(feature = "rotation-optimizations")]
    ctx.instance.runtime.rotation_mutations.record_semantic(
        crate::state::runtime::RotationSemanticMutation::SpellState,
        crate::state::runtime::RotationMutationDirection::Rise,
        now,
    );

    if spell.travel.is_fixed() {
        process_spell_launch(ctx, impact);
    } else {
        let launch_at = now.saturating_add(SimTime::from_millis(crate::travel::launch_offset_ms(
            spell.travel,
        )));

        ctx.instance.schedule(Event::SpellLaunch {
            t: launch_at,
            impact,
            source: ctx.source,
            target: ctx.target,
        });
    }
}

pub(crate) fn process_spell_launch(
    ctx: &mut CombatCtx<'_>,
    impact: wowlab_engine_ports::PendingImpactBinding,
) {
    let Some((impact_slot, generation)) =
        ctx.program.runtime_events.validate_pending_impact(impact)
    else {
        return;
    };
    let impact_slot = impact_slot as usize;

    if ctx
        .instance
        .runtime
        .pending
        .spell_impact_generations
        .get(impact_slot)
        .copied()
        != Some(generation)
    {
        return;
    }

    let Some((source, target, cast_complete_at, travel, target_mask, spell_handle)) = ctx
        .instance
        .runtime
        .pending
        .pending_spell_impacts
        .get(impact_slot)
        .and_then(Option::as_ref)
        .map(|pending| {
            (
                pending.source,
                pending.target,
                pending.cast_complete_at,
                pending.travel,
                pending.required_explicit_target_mask,
                pending.spell_handle,
            )
        })
    else {
        return;
    };

    if !ctx.instance.is_valid_target(target) {
        cancel_pending_spell(ctx, impact);

        return;
    }

    let Some(source_transform) = ctx.instance.actor_transform(source) else {
        cancel_pending_spell(ctx, impact);

        return;
    };
    let Some(target_transform) = ctx.instance.actor_transform(ActorId::Enemy(target)) else {
        cancel_pending_spell(ctx, impact);

        return;
    };
    let distance = source_transform
        .position
        .distance(target_transform.position);
    let impact_at = cast_complete_at.saturating_add(SimTime::from_millis(
        crate::travel::impact_offset_ms(travel, distance),
    ));
    let required_targets = SpellCastTargetFlags::from_bits_retain(target_mask);
    let cast_destination = required_targets
        .contains(SpellCastTargetFlags::DEST_LOCATION)
        .then_some(target_transform);

    let Some(pending) = ctx
        .instance
        .runtime
        .pending
        .pending_spell_impacts
        .get_mut(impact_slot)
        .and_then(Option::as_mut)
    else {
        return;
    };

    pending.locked_source_transform = Some(source_transform);
    pending.locked_target_transform = Some(target_transform);
    pending.cast_destination = cast_destination;
    ctx.instance.schedule(Event::SpellImpact {
        t: impact_at,
        impact,
        source,
        target,
    });

    let slot = ctx.instance.buffer.spell_mut_at(spell_handle);

    slot.in_flight_end = slot.in_flight_end.max(impact_at.as_secs_f64());
}

// #t(rust_cyclomatic_complexity) validation, consumption, and damage dispatch are one causal transition.
pub(crate) fn process_spell_impact(
    ctx: &mut CombatCtx<'_>,
    impact: wowlab_engine_ports::PendingImpactBinding,
) {
    let Some((impact_slot, generation)) =
        ctx.program.runtime_events.validate_pending_impact(impact)
    else {
        return;
    };
    let impact_slot = impact_slot as usize;

    if ctx
        .instance
        .runtime
        .pending
        .spell_impact_generations
        .get(impact_slot)
        .copied()
        != Some(generation)
    {
        return;
    }

    let pending = ctx
        .instance
        .runtime
        .pending
        .pending_spell_impacts
        .get_mut(impact_slot)
        .and_then(Option::take);
    let Some(pending) = pending else {
        return;
    };

    if !ctx.instance.is_valid_target(pending.target)
        || pending.locked_source_transform.is_none()
        || pending.locked_target_transform.is_none()
    {
        finish_pending_spell_slot(ctx, &pending);

        return;
    }

    ctx.source = pending.source;
    ctx.target = pending.target;

    let base_impact_flags = pending.attribute_flags
        | (if pending.is_pet {
            DamageFlags::PET
        } else {
            DamageFlags::empty()
        })
        | if pending.may_crit {
            DamageFlags::empty()
        } else {
            DamageFlags::NO_CRIT
        };
    let Some(impact_flags) = resolve_payload_flags(
        ctx,
        pending.profile_action,
        pending.damage,
        pending.applies_aura,
        pending.followup_effects,
        base_impact_flags,
    ) else {
        finish_pending_spell_slot(ctx, &pending);

        return;
    };

    let aura_applied_before_payload = pending.applies_aura.filter(|aura_local| {
        pending.followup_effects.len > 0
            && ctx
                .program
                .auras
                .get(aura_local.as_usize())
                .is_some_and(|aura| aura.on == wowlab_types::sim::AuraOn::Player)
    });

    if let Some(aura_local) = aura_applied_before_payload {
        apply_cast_aura(
            ctx,
            aura_local,
            pending.applies_aura_duration_ms,
            impact_flags,
        );
    }

    if !matches!(pending.damage, RuntimeDamageDef::None) {
        deal_profiled_damage_def_at(
            ctx,
            &ProfiledDamageDef {
                binding: pending
                    .damage_binding
                    .expect("damage-bearing pending impact was validated during finalization")
                    .request,
                effect: pending.damage_effect,
                geometry_effect: pending.damage_effect,
                profile_spell_id: pending.spell_id,
                base_points: Some(pending.base_points),
                def: pending.damage,
                flags: impact_flags,
                source_position: pending.locked_source_transform,
                destination: pending.cast_destination,
            },
        );
    }

    if let Some(aura_local) = pending
        .applies_aura
        .filter(|aura_local| Some(*aura_local) != aura_applied_before_payload)
    {
        apply_cast_aura(
            ctx,
            aura_local,
            pending.applies_aura_duration_ms,
            impact_flags,
        );
    }

    execute_effect_range(
        ctx,
        EffectExecution {
            range: pending.followup_effects,
            profile_spell_id: pending.spell_id,
            profile_action: pending.profile_action,
            flags: impact_flags,
        },
    );

    finish_pending_spell_slot(ctx, &pending);

    #[cfg(not(feature = "rotation-optimizations"))]
    {
        ctx.instance.schedule(Event::OffGcdReady { t: ctx.now });
    };

    fire_expire_hooks(ctx);
}

pub(super) fn cancel_pending_spell(
    ctx: &mut CombatCtx<'_>,
    impact: wowlab_engine_ports::PendingImpactBinding,
) {
    let Some((impact_slot, generation)) =
        ctx.program.runtime_events.validate_pending_impact(impact)
    else {
        return;
    };
    let impact_slot = impact_slot as usize;

    if ctx
        .instance
        .runtime
        .pending
        .spell_impact_generations
        .get(impact_slot)
        .copied()
        != Some(generation)
    {
        return;
    }

    let pending = ctx
        .instance
        .runtime
        .pending
        .pending_spell_impacts
        .get_mut(impact_slot)
        .and_then(Option::take);

    if let Some(pending) = pending {
        finish_pending_spell_slot(ctx, &pending);
    }
}

pub(super) fn finish_pending_spell_slot(ctx: &mut CombatCtx<'_>, pending: &PendingSpellImpact) {
    debug_assert_eq!(
        pending.spell_handle,
        ctx.program.buffer_bindings.spell(pending.spell_local),
        "pending spell impact handle does not match its finalized local identity"
    );
    let changed = {
        let slot = ctx.instance.buffer.spell_mut_at(pending.spell_handle);
        let before = slot.in_flight_count;

        slot.in_flight_count = (slot.in_flight_count - 1).max(0);

        if slot.in_flight_count == 0 {
            slot.is_in_flight = 0;
            slot.in_flight_end = 0.0;
        }

        slot.in_flight_count != before
    };

    #[cfg(feature = "rotation-optimizations")]
    if changed {
        ctx.instance.runtime.rotation_mutations.record_semantic(
            crate::state::runtime::RotationSemanticMutation::SpellState,
            crate::state::runtime::RotationMutationDirection::Fall,
            ctx.now,
        );
    }

    #[cfg(not(feature = "rotation-optimizations"))]
    let _ = changed;
}