wowlab_engine_combat/state/runtime/

enemies.rs

use super::{
    ActorId, BecameDead, CombatInstance, EnemyActorDefinition, EnemyDespawnOutcome, EnemyIdx,
    EnemyState, Event, HealthModel, PullId, SimTime, SpatialActor, SpecRuntimeError,
    parry_hasted_deadline,
};
#[cfg(feature = "rotation-optimizations")]
use super::{RotationMutationDirection, RotationSemanticMutation};
use crate::state::AttackPosition;

impl CombatInstance {
    #[must_use]
    pub fn enemy(&self, enemy: EnemyIdx) -> Option<&EnemyState> {
        self.runtime
            .enemies
            .get(enemy.as_usize())
            .filter(|state| state.id() == enemy)
    }

    /// Canonical maximum health for an exact encounter enemy.
    #[must_use]
    pub fn enemy_max_health(
        &self,
        program: &crate::state::CombatProgram,
        enemy: EnemyIdx,
    ) -> Option<f64> {
        program
            .enemy_definition(enemy)
            .map(|definition| definition.health_model().max_health())
    }

    /// Canonical health for an exact encounter enemy at engine time `now`.
    #[must_use]
    pub fn enemy_health(
        &self,
        program: &crate::state::CombatProgram,
        enemy: EnemyIdx,
        now: SimTime,
    ) -> Option<f64> {
        let definition = program.enemy_definition(enemy)?;
        let state = self.enemy(enemy)?;

        match definition.health_model() {
            HealthModel::DamageDriven { .. } => Some(state.current_health()),
            health_model @ HealthModel::ScriptedLinear { .. } => {
                health_model.scripted_health_at(state.spawned_at()?, now)
            }
        }
    }

    /// Canonical health fraction for an exact encounter enemy at engine time `now`.
    #[must_use]
    pub fn enemy_health_fraction(
        &self,
        program: &crate::state::CombatProgram,
        enemy: EnemyIdx,
        now: SimTime,
    ) -> Option<f64> {
        let max_health = self.enemy_max_health(program, enemy)?;

        (max_health > 0.0).then(|| {
            self.enemy_health(program, enemy, now)
                .map(|health| health / max_health)
        })?
    }

    /// Canonical live health fraction for any actor addressable by combat effects.
    #[must_use]
    pub fn actor_health_fraction(
        &self,
        program: &crate::state::CombatProgram,
        actor: ActorId,
        now: SimTime,
    ) -> Option<f64> {
        match actor {
            ActorId::External => None,
            ActorId::Player => Some(self.runtime.health.player_health.fraction()),
            ActorId::Pet(pet) => self
                .runtime
                .health
                .pet_health
                .get(pet.as_usize())
                .and_then(Option::as_ref)
                .map(|health| health.fraction()),
            ActorId::Enemy(enemy) => self.enemy_health_fraction(program, enemy, now),
        }
    }

    #[must_use]
    pub fn enemies(&self) -> impl ExactSizeIterator<Item = &EnemyState> {
        self.runtime.enemies.iter()
    }

    /// Returns the number of active enemies.
    ///
    /// # Panics
    ///
    /// Panics if a validated encounter exceeds the engine's supported enemy count.
    #[must_use]
    pub fn active_enemy_count(&self) -> i32 {
        let count = self.enemies().filter(|enemy| enemy.is_active()).count();

        i32::try_from(count).expect("validated encounter enemy count fits i32")
    }

    /// Returns the number of active, living enemies.
    ///
    /// # Panics
    ///
    /// Panics if a validated encounter exceeds the engine's supported enemy count.
    #[must_use]
    pub fn active_alive_enemy_count(&self) -> i32 {
        let count = self
            .enemies()
            .filter(|enemy| enemy.is_active() && enemy.is_alive())
            .count();

        i32::try_from(count).expect("validated encounter enemy count fits i32")
    }

    /// Restores enemy and spatial state to the validated encounter definition.
    ///
    /// # Panics
    ///
    /// Panics if rebuilding a previously validated spatial scene fails.
    pub fn reset_enemies(&mut self, program: &crate::state::CombatProgram) {
        debug_assert_eq!(
            self.runtime.enemies.len(),
            program.enemies.len(),
            "enemy runtime length must match the finalized encounter"
        );

        for index in 0..program.enemies.len() {
            let current = self
                .runtime
                .enemies
                .get(index)
                .expect("bounded runtime enemy index");
            let current_indexed = current.is_active() && current.is_alive();
            let current_actor = SpatialActor {
                id: current.id(),
                transform: current.current_transform(),
            };
            let reset = EnemyState::from_definition(
                program
                    .enemies
                    .get(index)
                    .expect("bounded enemy definition index"),
            );
            let reset_indexed = reset.is_active() && reset.is_alive();
            let reset_actor = SpatialActor {
                id: reset.id(),
                transform: reset.current_transform(),
            };

            match (current_indexed, reset_indexed) {
                (true, true) if current_actor.transform != reset_actor.transform => self
                    .spatial
                    .relocate_actor(
                        current_actor.id,
                        current_actor.transform,
                        reset_actor.transform,
                    )
                    .expect("validated encounter actor relocates during reset"),
                (true, false) => self
                    .spatial
                    .remove_actor(current_actor)
                    .expect("indexed encounter actor is removable during reset"),
                (false, true) => {
                    let _ = self.spatial.remove_actor(current_actor);

                    self.spatial
                        .insert_actor(reset_actor)
                        .expect("validated encounter actor inserts during reset");
                }
                _ => {}
            }

            *self
                .runtime
                .enemies
                .get_mut(index)
                .expect("bounded runtime enemy index") = reset;
        }

        self.runtime.player_transform = program
            .config
            .encounter
            .definition()
            .initial_player_transform;
        self.runtime.attack_position = AttackPosition::Behind;
        self.runtime.health.enemy_swing_deadlines.fill(None);
        self.runtime
            .health
            .enemy_invulnerable_until
            .fill(SimTime::ZERO);
        self.runtime
            .encounter
            .reset(program.config.encounter.definition());
        self.retarget(program, SimTime::ZERO);
    }

    #[must_use]
    pub fn is_valid_target(&self, enemy: EnemyIdx) -> bool {
        self.enemy(enemy)
            .is_some_and(|actor| actor.is_active() && actor.is_alive())
    }

    #[must_use]
    pub const fn current_target(&self) -> Option<EnemyIdx> {
        self.runtime.current_target
    }

    #[must_use]
    pub const fn attack_position(&self) -> AttackPosition {
        self.runtime.attack_position
    }

    pub fn set_attack_position(&mut self, position: AttackPosition, _at: SimTime) {
        if self.runtime.attack_position == position {
            return;
        }

        self.runtime.attack_position = position;

        #[cfg(feature = "rotation-optimizations")]
        {
            self.runtime.rotation_mutations.record_semantic(
                RotationSemanticMutation::Spatial,
                RotationMutationDirection::Rise,
                _at,
            );
            self.runtime.rotation_mutations.record_semantic(
                RotationSemanticMutation::Spatial,
                RotationMutationDirection::Fall,
                _at,
            );
        }
    }

    /// Select the active pull's preferred enemy when eligible, otherwise its lowest eligible id.
    pub fn retarget(
        &mut self,
        program: &crate::state::CombatProgram,
        at: SimTime,
    ) -> Option<EnemyIdx> {
        let previous = self.runtime.current_target;
        let active_pull = self.runtime.encounter.active_pull();
        let pull = program
            .config
            .encounter
            .definition()
            .pulls
            .get(active_pull.as_usize())
            .filter(|pull| pull.id == active_pull);
        let preferred = pull.map(|pull| pull.preferred_target);

        self.runtime.current_target = preferred
            .filter(|enemy| self.is_valid_target(*enemy))
            .or_else(|| {
                self.enemies()
                    .find(|enemy| {
                        enemy.is_active()
                            && enemy.is_alive()
                            && self.enemy_belongs_to_pull(program, enemy.id(), active_pull)
                    })
                    .map(EnemyState::id)
            });

        if self.runtime.current_target != previous {
            self.mark_projection_dirty(
                super::ProjectionDirty::TARGET_HEALTH
                    | super::ProjectionDirty::TARGET_IDENTITY_RANGE_TRAVEL,
                at,
            );

            #[cfg(feature = "rotation-optimizations")]
            {
                self.runtime.rotation_mutations.record_semantic(
                    RotationSemanticMutation::TargetIdentity,
                    RotationMutationDirection::Rise,
                    at,
                );
                self.runtime.rotation_mutations.record_semantic(
                    RotationSemanticMutation::TargetIdentity,
                    RotationMutationDirection::Fall,
                    at,
                );
            }
        }

        self.runtime.current_target
    }

    pub fn activate_enemy(&mut self, enemy: EnemyIdx, at: SimTime) -> bool {
        let Some(actor) = self.enemy(enemy) else {
            return false;
        };

        if actor.is_active() || !actor.is_alive() {
            return false;
        }

        let transform = actor.current_transform();
        let spatial_actor = SpatialActor {
            id: enemy,
            transform,
        };

        if self.spatial.insert_actor(spatial_actor).is_err() {
            return false;
        }

        if !self
            .enemy_mut(enemy)
            .is_some_and(|actor| actor.activate(at))
        {
            let _ = self.spatial.remove_actor(spatial_actor);

            return false;
        }

        self.mark_projection_dirty(super::ProjectionDirty::POPULATION, at);

        #[cfg(feature = "rotation-optimizations")]
        self.runtime.rotation_mutations.record_semantic(
            RotationSemanticMutation::EncounterPopulation,
            RotationMutationDirection::Rise,
            at,
        );

        true
    }

    pub fn refresh_enemy_health(&mut self, enemy: EnemyIdx, now: SimTime) {
        #[cfg(feature = "rotation-optimizations")]
        let before = self.enemy(enemy).map(EnemyState::current_health);

        if let Some(state) = self
            .enemy_mut(enemy)
            .filter(|state| state.is_active() && state.is_alive())
        {
            state.refresh_scripted_health(now);
        }

        #[cfg(feature = "rotation-optimizations")]
        if let (Some(before), Some(after)) =
            (before, self.enemy(enemy).map(EnemyState::current_health))
        {
            let direction = if after > before {
                Some(RotationMutationDirection::Rise)
            } else if after < before {
                Some(RotationMutationDirection::Fall)
            } else {
                None
            };

            if let Some(direction) = direction {
                self.runtime.rotation_mutations.record_semantic(
                    RotationSemanticMutation::TargetHealth,
                    direction,
                    now,
                );
            }
        }

        if self.current_target() == Some(enemy) {
            self.mark_projection_dirty(super::ProjectionDirty::TARGET_HEALTH, now);
        }
    }

    #[must_use]
    pub fn enemy_time_to_die(&self, enemy: EnemyIdx, now: SimTime) -> Option<f64> {
        self.enemy(enemy)?.time_to_die(now)
    }

    /// Apply damage to one enemy and report whether the hit caused its death transition.
    ///
    /// # Errors
    ///
    /// Returns [`SpecRuntimeError`] when `enemy` is absent from the active encounter state.
    pub fn apply_enemy_damage(
        &mut self,
        enemy: EnemyIdx,
        amount: f64,
        at: SimTime,
    ) -> Result<Option<BecameDead>, SpecRuntimeError> {
        let state = self
            .runtime
            .enemies
            .get_mut(enemy.as_usize())
            .filter(|state| state.id() == enemy)
            .ok_or_else(|| SpecRuntimeError::missing_enemy(enemy))?;
        let transform = state.current_transform();
        #[cfg(feature = "rotation-optimizations")]
        let health_before = state.current_health();
        let remove_from_index = state.is_active();
        let mut next_state = state.clone();
        let outcome = next_state.apply_damage(amount, at);
        #[cfg(feature = "rotation-optimizations")]
        let health_after = next_state.current_health();

        if outcome.is_some() && remove_from_index {
            self.spatial
                .remove_actor(SpatialActor {
                    id: enemy,
                    transform,
                })
                .map_err(|source| SpecRuntimeError::enemy_death_spatial_removal(enemy, source))?;
        }

        *state = next_state;

        #[cfg(feature = "rotation-optimizations")]
        if health_after < health_before {
            self.runtime.rotation_mutations.record_semantic(
                RotationSemanticMutation::TargetHealth,
                RotationMutationDirection::Fall,
                at,
            );
        }

        #[cfg(feature = "rotation-optimizations")]
        if outcome.is_some() {
            self.runtime.rotation_mutations.record_semantic(
                RotationSemanticMutation::EncounterPopulation,
                RotationMutationDirection::Fall,
                at,
            );
        }

        let mut dirty = super::ProjectionDirty::empty();

        if self.current_target() == Some(enemy) {
            dirty |= super::ProjectionDirty::TARGET_HEALTH;
        }

        if outcome.is_some() {
            dirty |= super::ProjectionDirty::POPULATION;
        }

        if !dirty.is_empty() {
            self.mark_projection_dirty(dirty, at);
        }

        Ok(outcome)
    }

    pub(crate) fn schedule_enemy_auto_attack(
        &mut self,
        source: EnemyIdx,
        target: ActorId,
        at: SimTime,
    ) {
        let Some(deadline) = self
            .runtime
            .health
            .enemy_swing_deadlines
            .get_mut(source.as_usize())
        else {
            return;
        };

        *deadline = Some(at);
        self.schedule(Event::EnemyAutoAttack {
            t: at,
            source,
            target,
        });
    }

    pub(crate) fn grant_enemy_invulnerability(&mut self, target: EnemyIdx, until: SimTime) {
        if let Some(existing) = self
            .runtime
            .health
            .enemy_invulnerable_until
            .get_mut(target.as_usize())
        {
            *existing = (*existing).max(until);
        }
    }

    #[must_use]
    pub(crate) fn enemy_is_invulnerable(&self, target: EnemyIdx, now: SimTime) -> bool {
        self.runtime
            .health
            .enemy_invulnerable_until
            .get(target.as_usize())
            .is_some_and(|until| now < *until)
    }

    pub(crate) fn enemy_auto_attack_is_current(&self, source: EnemyIdx, at: SimTime) -> bool {
        self.runtime
            .health
            .enemy_swing_deadlines
            .get(source.as_usize())
            .is_some_and(|deadline| *deadline == Some(at))
    }

    pub(crate) fn apply_enemy_parry_haste(
        &mut self,
        program: &crate::state::CombatProgram,
        source: EnemyIdx,
        now: SimTime,
    ) {
        let Some(base_ms) = program
            .enemy_definition(source)
            .and_then(EnemyActorDefinition::auto_attack_swing_ms)
        else {
            return;
        };
        let Some(Some(current)) = self
            .runtime
            .health
            .enemy_swing_deadlines
            .get(source.as_usize())
        else {
            return;
        };
        let Some(accelerated_deadline) = parry_hasted_deadline(base_ms, *current, now) else {
            return;
        };

        self.schedule_enemy_auto_attack(source, ActorId::Player, accelerated_deadline);
    }

    #[must_use]
    #[expect(
        clippy::unused_self,
        reason = "pull membership is exposed through the enemy runtime query API"
    )]
    pub(crate) fn enemy_belongs_to_pull(
        &self,
        program: &crate::state::CombatProgram,
        enemy: EnemyIdx,
        pull: PullId,
    ) -> bool {
        let definition = program.config.encounter.definition();
        let Some(actor) = definition.enemies.get(enemy.as_usize()) else {
            return false;
        };
        let Some(group) = definition.groups.get(actor.group_id.as_usize()) else {
            return false;
        };

        definition
            .waves
            .get(group.wave_id.as_usize())
            .is_some_and(|wave| wave.pull_id == pull)
    }

    pub(crate) fn transition_enemy_despawn(
        &mut self,
        enemy: EnemyIdx,
        at: SimTime,
    ) -> EnemyDespawnOutcome {
        let Some(actor) = self.enemy(enemy) else {
            return EnemyDespawnOutcome::UnknownEnemy;
        };

        if !actor.is_active() {
            return EnemyDespawnOutcome::AlreadyInactive;
        }

        let transform = actor.current_transform();
        let spatial_actor = SpatialActor {
            id: enemy,
            transform,
        };

        if self.spatial.remove_actor(spatial_actor).is_err() {
            return EnemyDespawnOutcome::AlreadyInactive;
        }

        if !self.enemy_mut(enemy).is_some_and(|actor| actor.despawn(at)) {
            let _ = self.spatial.insert_actor(spatial_actor);

            return EnemyDespawnOutcome::AlreadyInactive;
        }

        let mut dirty = super::ProjectionDirty::POPULATION;

        if self.current_target() == Some(enemy) {
            dirty |= super::ProjectionDirty::TARGET_HEALTH;
        }

        self.mark_projection_dirty(dirty, at);

        #[cfg(feature = "rotation-optimizations")]
        {
            self.runtime.rotation_mutations.record_semantic(
                RotationSemanticMutation::EncounterPopulation,
                RotationMutationDirection::Fall,
                at,
            );
            self.runtime.rotation_mutations.record_semantic(
                RotationSemanticMutation::TargetHealth,
                RotationMutationDirection::Fall,
                at,
            );
        }

        EnemyDespawnOutcome::Despawned
    }

    pub(crate) fn finalize_scripted_enemy_death(
        &mut self,
        enemy: EnemyIdx,
        at: SimTime,
    ) -> Result<bool, SpecRuntimeError> {
        let state = self
            .runtime
            .enemies
            .get_mut(enemy.as_usize())
            .filter(|state| state.id() == enemy)
            .ok_or_else(|| SpecRuntimeError::missing_enemy(enemy))?;

        if !state.is_active() || !state.is_alive() {
            return Ok(false);
        }

        let transform = state.current_transform();
        let mut next_state = state.clone();

        if !next_state.finalize_scripted_death(at) {
            return Ok(false);
        }

        self.spatial
            .remove_actor(SpatialActor {
                id: enemy,
                transform,
            })
            .map_err(|source| SpecRuntimeError::enemy_death_spatial_removal(enemy, source))?;
        *state = next_state;

        let mut dirty = super::ProjectionDirty::POPULATION;

        if self.current_target() == Some(enemy) {
            dirty |= super::ProjectionDirty::TARGET_HEALTH;
        }

        self.mark_projection_dirty(dirty, at);

        #[cfg(feature = "rotation-optimizations")]
        {
            self.runtime.rotation_mutations.record_semantic(
                RotationSemanticMutation::EncounterPopulation,
                RotationMutationDirection::Fall,
                at,
            );
            self.runtime.rotation_mutations.record_semantic(
                RotationSemanticMutation::TargetHealth,
                RotationMutationDirection::Fall,
                at,
            );
        }

        Ok(true)
    }

    pub(super) fn enemy_mut(&mut self, enemy: EnemyIdx) -> Option<&mut EnemyState> {
        self.runtime
            .enemies
            .get_mut(enemy.as_usize())
            .filter(|state| state.id() == enemy)
    }
}