wowlab_engine_combat/systems/damage_pipeline/

incoming.rs

use wowlab_engine_domain::dbc::SpellSchoolMask;
use wowlab_types::{
    combat::DamageSchool,
    constants::HUNDRED,
    sim::{ActorId, SimTime},
};

use crate::{
    context::ActorView,
    state::{AbsorbKind, BuffEffect, CombatInstance, DamageTransfer, DamageTransferTiming},
    systems::{absorbs, apply_cast_pushback, break_auras_without_telemetry, buffs},
};

/// Typed hostile damage request before target-side modifiers and health application.
#[derive(Clone, Copy, Debug)]
pub(crate) struct IncomingDamage {
    pub source: ActorId,
    pub target: ActorId,
    pub amount: f64,
    pub school: DamageSchool,
    pub mechanic_mask: u64,
    pub is_aoe: bool,
    pub is_periodic: bool,
    pub at: SimTime,
}

/// Result of the incoming-damage pipeline.
#[derive(Clone, Copy, Debug, Default, PartialEq)]
pub(crate) struct IncomingDamageResult {
    pub requested: f64,
    pub modified: f64,
    pub absorbed: f64,
    pub split: f64,
    pub shared: f64,
    pub applied: f64,
    pub immune: bool,
    pub killed: bool,
}

/// Applies immunity and multiplicative damage-taken effects before removing absolute health.
#[must_use]
pub(crate) fn deal_incoming_damage(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
    damage: IncomingDamage,
) -> IncomingDamageResult {
    let requested = damage.amount.max(0.0);

    if requested <= f64::EPSILON || !state.is_friendly_actor_alive(damage.target) {
        return IncomingDamageResult {
            requested,
            ..IncomingDamageResult::default()
        };
    }

    let school = SpellSchoolMask::from(damage.school);
    let mut split = 0.0;
    let mut remaining = requested;

    let transfer_scratch = std::mem::take(&mut state.runtime.scratch.active_damage_transfers);
    let mut pre_mitigation = active_transfers(
        ActorView::new(program, state, damage.target),
        DamageTransferTiming::PreMitigationSplit,
        school,
        transfer_scratch,
    );

    for (recipient, transfer) in pre_mitigation.iter().copied() {
        let amount = remaining * transfer.fraction.clamp(0.0, 1.0);

        if amount <= f64::EPSILON {
            continue;
        }

        remaining -= amount;
        split += amount;
        let _ = deal_incoming_damage_core(
            program,
            state,
            IncomingDamage {
                target: recipient,
                amount,
                ..damage
            },
        );
    }

    pre_mitigation.clear();
    let nested_scratch = std::mem::replace(
        &mut state.runtime.scratch.active_damage_transfers,
        pre_mitigation,
    );

    debug_assert!(
        nested_scratch.is_empty(),
        "nested pre-mitigation damage calls restore an empty transfer scratch buffer"
    );

    let mut result = deal_incoming_damage_core(
        program,
        state,
        IncomingDamage {
            amount: remaining,
            ..damage
        },
    );
    let mut shared = 0.0;

    if result.applied > f64::EPSILON {
        let transfer_scratch = std::mem::take(&mut state.runtime.scratch.active_damage_transfers);
        let mut post_mitigation = active_transfers(
            ActorView::new(program, state, damage.target),
            DamageTransferTiming::PostMitigationShare,
            school,
            transfer_scratch,
        );

        for (recipient, transfer) in post_mitigation.iter().copied() {
            let amount = result.applied * transfer.fraction.clamp(0.0, 1.0);

            if amount <= f64::EPSILON {
                continue;
            }

            shared += amount;
            let _ = deal_incoming_damage_core(
                program,
                state,
                IncomingDamage {
                    target: recipient,
                    amount,
                    ..damage
                },
            );
        }

        post_mitigation.clear();
        let nested_scratch = std::mem::replace(
            &mut state.runtime.scratch.active_damage_transfers,
            post_mitigation,
        );

        debug_assert!(
            nested_scratch.is_empty(),
            "nested post-mitigation damage calls restore an empty transfer scratch buffer"
        );
    }

    result.requested = requested;
    result.split = split;
    result.shared = shared;

    if !result.immune {
        break_auras_without_telemetry(program, state, damage.target, damage.is_periodic, damage.at);
    }

    if result.applied > f64::EPSILON
        && matches!(damage.source, ActorId::Enemy(_))
        && damage.source != damage.target
        && damage.target == ActorId::Player
        && !damage.is_periodic
    {
        let _ = apply_cast_pushback(program, state, damage.target, damage.at);
    }

    result
}

// #t(fn: rust_cyclomatic_complexity) explicit immunity, modifier, absorb, overkill, and health stages mirror server ordering
fn deal_incoming_damage_core(
    program: &crate::state::CombatProgram,
    state: &mut CombatInstance,
    damage: IncomingDamage,
) -> IncomingDamageResult {
    let requested = damage.amount.max(0.0);
    let school = SpellSchoolMask::from(damage.school);
    let mut multiplier = 1.0;
    let mut immune = false;

    state
        .runtime
        .health
        .immunity_windows
        .retain(|window| window.until > damage.at);
    immune |= state.runtime.health.immunity_windows.iter().any(|window| {
        window.actor == damage.target
            && (window.schools.intersects(school)
                || (damage.mechanic_mask != 0 && window.mechanic_mask & damage.mechanic_mask != 0))
    });

    buffs::for_each_planned_actor_effect(
        ActorView::new(program, state, damage.target),
        crate::state::EffectFamily::INCOMING_DAMAGE | crate::state::EffectFamily::IMMUNITY,
        |stacks, effect| match effect {
            BuffEffect::IncomingDamagePercent { percent, schools }
                if schools.intersects(school) =>
            {
                multiplier *= (1.0 + percent / HUNDRED).max(0.0).powf(stacks);
            }
            BuffEffect::IncomingAoeDamagePercent { percent, schools }
                if damage.is_aoe && schools.intersects(school) =>
            {
                multiplier *= (1.0 + percent / HUNDRED).max(0.0).powf(stacks);
            }
            BuffEffect::SchoolImmunity(schools) if schools.intersects(school) => immune = true,
            BuffEffect::MechanicImmunity(mask)
                if damage.mechanic_mask != 0 && mask & damage.mechanic_mask != 0 =>
            {
                immune = true;
            }
            _ => {}
        },
    );

    if immune {
        return IncomingDamageResult {
            requested,
            immune: true,
            ..IncomingDamageResult::default()
        };
    }

    let modified = requested * multiplier;
    let mut absorbed =
        absorbs::consume_absorbs(state, damage.target, AbsorbKind::Damage, school, modified);
    let mut after_absorb = (modified - absorbed).max(0.0);
    let current_health = state.friendly_actor_health(damage.target).unwrap_or(0.0);
    let mut grant_death_credit = false;

    if after_absorb + f64::EPSILON >= current_health {
        let maximum_health = state
            .friendly_actor_max_health(damage.target)
            .unwrap_or(current_health);
        let overkill = absorbs::resolve_overkill_absorbs(
            state,
            &damage,
            after_absorb,
            current_health,
            maximum_health,
        );

        absorbed += overkill.absorbed;
        after_absorb = (after_absorb - overkill.absorbed).max(0.0);
        grant_death_credit = overkill.absorbed > 0.0 && !overkill.death_fully_prevented;
    }

    let applied = state
        .apply_friendly_actor_damage(damage.target, after_absorb)
        .unwrap_or(0.0);
    let mut killed = applied > 0.0 && !state.is_friendly_actor_alive(damage.target);

    if grant_death_credit {
        killed |= state.transition_friendly_actor_to_dead(damage.target);
    }

    // A dead player stops evaluating its rotation, so the iteration ends here instead of idling to
    // the encounter endpoint and averaging its damage over time it was never alive for.

    if killed && damage.target == ActorId::Player {
        state.runtime.encounter.terminate(damage.at);
    }

    IncomingDamageResult {
        requested,
        modified,
        absorbed,
        split: 0.0,
        shared: 0.0,
        applied,
        immune: false,
        killed,
    }
}

fn active_transfers(
    view: ActorView<'_>,
    timing: DamageTransferTiming,
    school: SpellSchoolMask,
    mut transfers: Vec<(ActorId, DamageTransfer)>,
) -> Vec<(ActorId, DamageTransfer)> {
    let ActorView { actor: target, .. } = view;

    transfers.clear();

    buffs::for_each_planned_actor_aura_effect(
        view,
        crate::state::EffectFamily::DAMAGE_TRANSFER,
        |key, _local, _stacks, effect| {
            let BuffEffect::DamageTransfer(transfer) = effect else {
                return;
            };

            if transfer.timing == timing
                && (transfer.schools.is_empty() || transfer.schools.intersects(school))
                && !matches!(key.source(), ActorId::Enemy(_))
                && key.source() != target
            {
                transfers.push((key.source(), *transfer));
            }
        },
    );

    transfers
}

#[cfg(test)]
mod tests;