wowlab_engine_combat/state/

health.rs

use wowlab_engine_domain::dbc::SpellSchoolMask;
use wowlab_engine_ports::SpecRuntime;
use wowlab_types::sim::{ActorId, AuraKey, SimTime};

use super::CombatState;

/// Pool selected by an absorb aura.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
#[non_exhaustive]
pub enum AbsorbKind {
    Damage,
    Healing,
    Overkill,
}

/// Aura-316 input resolved independently for each lethal hit.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct OverkillAbsorbEvent {
    pub aura: AuraKey,
    pub target: ActorId,
    pub school: SpellSchoolMask,
    pub incoming_damage: f64,
    pub remaining_damage: f64,
    pub current_health: f64,
    pub maximum_health: f64,
    pub at: SimTime,
}

/// Per-hit absorb amount and death-state decision returned by an aura-316 script.
#[derive(Clone, Copy, Debug, Default, PartialEq)]
pub struct OverkillAbsorbDecision {
    pub absorbed: f64,
    pub death_fully_prevented: bool,
}

/// Stateful runtime context exposed to an authored aura-316 script.
#[derive(Debug)]
#[must_use]
pub struct OverkillAbsorbScriptContext<'a> {
    state: &'a mut CombatState,
    event: OverkillAbsorbEvent,
}

impl<'a> OverkillAbsorbScriptContext<'a> {
    pub(crate) fn new(state: &'a mut CombatState, event: OverkillAbsorbEvent) -> Self {
        Self { state, event }
    }

    /// Immutable per-hit inputs, including the active aura identity.
    #[must_use]
    pub const fn event(&self) -> OverkillAbsorbEvent {
        self.event
    }

    /// Whether this aura application's script cooldown is ready for the current hit.
    #[must_use]
    pub fn cooldown_ready(&self) -> bool {
        self.state
            .runtime
            .pools
            .overkill_absorb_ready_at
            .is_ready(&self.event.aura, self.event.at)
    }

    /// Starts this aura application's script cooldown from the current hit time.
    pub fn start_cooldown(&mut self, duration: SimTime) -> SimTime {
        self.state.runtime.pools.overkill_absorb_ready_at.start_for(
            self.event.aura,
            self.event.at,
            duration,
        )
    }

    /// Reads the current absolute health of a friendly combat actor.
    #[must_use]
    pub fn friendly_actor_health(&self, actor: ActorId) -> Option<f64> {
        self.state.friendly_actor_health(actor)
    }

    /// Downcasts the resettable per-spec runtime state.
    #[must_use]
    pub fn spec_runtime<T>(&self) -> Option<&T>
    where
        T: SpecRuntime,
    {
        self.state.spec_runtime::<T>()
    }

    /// Mutably downcasts the resettable per-spec runtime state.
    pub fn spec_runtime_mut<T>(&mut self) -> Option<&mut T>
    where
        T: SpecRuntime,
    {
        self.state.spec_runtime_mut::<T>()
    }
}

/// Authored aura-316 strategy invoked for every eligible lethal hit.
pub(crate) type OverkillAbsorbScriptFn =
    fn(&mut OverkillAbsorbScriptContext<'_>) -> OverkillAbsorbDecision;

/// Static absorb payload contributed by an aura effect.
#[derive(Clone, Copy, Debug)]
pub struct AbsorbEffect {
    pub amount: f64,
    pub effect_index: u8,
    pub schools: SpellSchoolMask,
    pub kind: AbsorbKind,
    pub high_priority: bool,
    pub overkill_script: Option<OverkillAbsorbScriptFn>,
    /// `TrinityCore`'s secondary absorb ordering key (`EffectMiscValue[1]`).
    pub priority: i32,
}

/// Per-application mutable remainder for an absorb aura.
#[derive(Clone, Copy, Debug)]
pub(crate) struct ActiveAbsorb {
    pub key: AuraKey,
    pub kind: AbsorbKind,
    pub schools: SpellSchoolMask,
    pub remaining: f64,
    pub high_priority: bool,
    pub overkill_script: Option<OverkillAbsorbScriptFn>,
    pub priority: i32,
    pub application_order: u64,
}

/// Orchestration-owned immunity interval consumed by the incoming-damage pipeline.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct IncomingImmunityWindow {
    pub actor: ActorId,
    pub schools: SpellSchoolMask,
    pub mechanic_mask: u64,
    pub until: SimTime,
}

/// Mutable absolute-health state for a friendly combat actor.
#[derive(Clone, Copy, Debug, PartialEq)]
pub(crate) struct HealthPool {
    current: f64,
    maximum: f64,
    fraction_when_unknown: f64,
}

impl HealthPool {
    #[must_use]
    pub(crate) fn full(maximum: f64) -> Self {
        let maximum = maximum.max(0.0);

        Self {
            current: maximum,
            maximum,
            fraction_when_unknown: 1.0,
        }
    }

    #[must_use]
    pub(crate) const fn current(self) -> f64 {
        self.current
    }

    #[must_use]
    pub(crate) const fn maximum(self) -> f64 {
        self.maximum
    }

    #[must_use]
    pub(crate) fn fraction(self) -> f64 {
        if self.maximum > 0.0 {
            self.current / self.maximum
        } else {
            self.fraction_when_unknown
        }
    }

    #[must_use]
    pub(crate) fn is_alive(self) -> bool {
        self.maximum <= 0.0 || self.current > 0.0
    }

    pub(crate) fn reset(&mut self) {
        self.current = self.maximum;
        self.fraction_when_unknown = 1.0;
    }

    pub(crate) fn set_maximum_preserve_fraction(&mut self, maximum: f64) {
        let fraction = self.fraction();

        self.maximum = maximum.max(0.0);
        self.current = self.maximum * fraction;
    }

    pub(crate) fn set_maximum_clamp_current(&mut self, maximum: f64) {
        self.maximum = maximum.max(0.0);
        self.current = self.current.min(self.maximum);
    }

    pub(crate) fn set_fraction(&mut self, fraction: f64) -> f64 {
        let previous = self.fraction();

        let fraction = fraction.clamp(0.0, 1.0);

        self.current = self.maximum * fraction;
        self.fraction_when_unknown = fraction;

        previous
    }

    /// Removes health and returns the amount that reached the pool after overkill clamping.
    pub(crate) fn apply_damage(&mut self, amount: f64) -> f64 {
        let amount = amount.max(0.0).min(self.current);

        self.current -= amount;

        amount
    }

    pub(crate) fn transition_to_dead(&mut self) {
        self.current = 0.0;
        self.fraction_when_unknown = 0.0;
    }

    /// Restores health and returns the effective amount after overheal clamping.
    pub(crate) fn apply_heal(&mut self, amount: f64) -> f64 {
        let amount = amount.max(0.0).min((self.maximum - self.current).max(0.0));

        self.current += amount;

        amount
    }
}

#[cfg(test)]
mod tests;