wowlab_engine_combat/systems/damage_pipeline/

incoming.rs

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

use crate::{
    context::ActorView,
    state::{AbsorbKind, BuffEffect, CombatState, 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(
    state: &mut CombatState,
    buf: &mut DenseBuffer,
    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;

    for (recipient, transfer) in active_transfers(
        ActorView::new(state, buf, damage.target),
        DamageTransferTiming::PreMitigationSplit,
        school,
    ) {
        let amount = remaining * transfer.fraction.clamp(0.0, 1.0);

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

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

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

    if result.applied > f64::EPSILON {
        for (recipient, transfer) in active_transfers(
            ActorView::new(state, buf, damage.target),
            DamageTransferTiming::PostMitigationShare,
            school,
        ) {
            let amount = result.applied * transfer.fraction.clamp(0.0, 1.0);

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

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

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

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

    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(state, buf, 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(
    state: &mut CombatState,
    buf: &mut DenseBuffer,
    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_active_actor_aura_effect(
        ActorView::new(state, buf, damage.target),
        |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. This
    // mirrors SimC's `player_t::demise()`, which freezes `iteration_fight_length` at the death.

    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,
) -> Vec<(ActorId, DamageTransfer)> {
    let ActorView {
        state,
        buf,
        actor: target,
    } = view;
    let mut transfers = Vec::new();

    for key in buf.aura_keys().filter(|key| key.affected() == target) {
        if !buf
            .aura(key)
            .is_some_and(wowlab_engine_domain::rotation::AuraSlot::is_occupied)
        {
            continue;
        }

        let Some(local) = state.aura_local_for_key(key) else {
            continue;
        };

        // BOUNDS: aura_local_for_key returns an index from this definition table.
        let Some(aura) = state.defs.auras.get(local.as_usize()) else {
            continue;
        };

        for effect in aura.effects.iter().flatten() {
            let BuffEffect::DamageTransfer(transfer) = effect else {
                continue;
            };

            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;