wowlab_engine_combat/pipeline/

impact.rs

use super::{
    ActorId, CombatCtx, DamageFlags, EffectExecution, Event, PendingSpellImpact, ProfiledDamageDef,
    RuntimeDamageDef, SimTime, SpellCastPayload, SpellCastTargetFlags, SpellData, SpellIdx,
    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: &SpellData,
    payload: SpellCastPayload,
    now: SimTime,
) {
    let impact_id = u32::try_from(ctx.state.runtime.pending.pending_spell_impacts.len())
        .expect("pending impact arena length fits in u32");

    ctx.state
        .runtime
        .pending
        .pending_spell_impacts
        .push(Some(PendingSpellImpact {
            spell_id: spell.spell_id,
            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,
            locked_source_transform: None,
            locked_target_transform: None,
            cast_destination: None,
        }));

    if let Some(slot) = ctx.buf.spell_mut(SpellIdx::from_raw(spell.spell_id)) {
        slot.in_flight_count += 1;
        slot.is_in_flight = 1;
    }

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

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

pub(crate) fn process_spell_launch(ctx: &mut CombatCtx<'_>, impact_id: u32) {
    let Some((spell_id, source, target, cast_complete_at, travel)) = ctx
        .state
        .runtime
        .pending
        .pending_spell_impacts
        .get(impact_id as usize)
        .and_then(Option::as_ref)
        .map(|pending| {
            (
                pending.spell_id,
                pending.source,
                pending.target,
                pending.cast_complete_at,
                pending.travel,
            )
        })
    else {
        return;
    };

    if !ctx.state.is_valid_target(target) {
        cancel_pending_spell(ctx, impact_id);

        return;
    }

    let Some(source_transform) = ctx.state.actor_transform(source) else {
        cancel_pending_spell(ctx, impact_id);

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

        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(
        ctx.state
            .config
            .game_data
            .required_explicit_target_mask(SpellIdx::from_raw(spell_id))
            .unwrap_or_default(),
    );
    let cast_destination = required_targets
        .contains(SpellCastTargetFlags::DEST_LOCATION)
        .then_some(target_transform);

    let Some(pending) = ctx
        .state
        .runtime
        .pending
        .pending_spell_impacts
        .get_mut(impact_id as usize)
        .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.state.schedule(Event::SpellImpact {
        t: impact_at,
        impact_id,
        source,
        target,
    });

    if let Some(slot) = ctx.buf.spell_mut(SpellIdx::from_raw(spell_id)) {
        slot.in_flight_end = slot.in_flight_end.max(impact_at.as_secs_f64());
    }
}

pub(crate) fn process_spell_impact(ctx: &mut CombatCtx<'_>, impact_id: u32) {
    let pending = ctx
        .state
        .runtime
        .pending
        .pending_spell_impacts
        .get_mut(impact_id as usize)
        .and_then(Option::take);
    let Some(pending) = pending else {
        return;
    };

    if !ctx.state.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.spell_id,
        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
                .state
                .defs
                .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 {
                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,
            flags: impact_flags,
        },
    );

    finish_pending_spell_slot(ctx, &pending);
    // Same-time wake lets usable-while-casting actions react to impact state changes.
    ctx.state.schedule(Event::OffGcdReady { t: ctx.now });
    fire_expire_hooks(ctx);
}

pub(super) fn cancel_pending_spell(ctx: &mut CombatCtx<'_>, impact_id: u32) {
    let pending = ctx
        .state
        .runtime
        .pending
        .pending_spell_impacts
        .get_mut(impact_id as usize)
        .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) {
    if let Some(slot) = ctx.buf.spell_mut(SpellIdx::from_raw(pending.spell_id)) {
        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;
        }
    }
}