wowlab_engine_combat/state/combat_state/

enemies.rs

use super::{
    ActorId, AttackPosition, BecameDead, CombatState, EnemyActorDefinition, EnemyDespawnOutcome,
    EnemyIdx, EnemyState, Event, HealthModel, PullId, SimTime, SpatialActor, SpatialQueryHandle,
    SpecRuntimeError, parry_hasted_deadline,
};

impl CombatState {
    #[must_use]
    pub fn enemy_definition(&self, enemy: EnemyIdx) -> Option<&EnemyActorDefinition> {
        self.defs
            .enemies
            .get(enemy.as_usize())
            .filter(|definition| definition.id() == enemy)
    }

    #[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, enemy: EnemyIdx) -> Option<f64> {
        self.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, enemy: EnemyIdx, now: SimTime) -> Option<f64> {
        let definition = self.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, enemy: EnemyIdx, now: SimTime) -> Option<f64> {
        let max_health = self.enemy_max_health(enemy)?;

        (max_health > 0.0).then(|| {
            self.enemy_health(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, 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(enemy, now),
        }
    }

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

    #[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) {
        self.runtime.enemies = self
            .defs
            .enemies
            .iter()
            .map(EnemyState::from_definition)
            .collect();
        self.runtime.player_transform = self.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(self.config.encounter.definition());
        let active: Vec<_> = self
            .runtime
            .enemies
            .iter()
            .filter(|enemy| enemy.is_active() && enemy.is_alive())
            .map(|enemy| SpatialActor {
                id: enemy.id(),
                transform: enemy.current_transform(),
            })
            .collect();

        self.spatial = SpatialQueryHandle(Box::new(
            wowlab_engine_spatial::build_spatial_query(
                &self.config.encounter.definition().spatial_scene,
                &active,
            )
            .expect("validated encounter spatial scene rebuilds deterministically"),
        ));
        self.retarget();
    }

    #[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 const fn set_attack_position(&mut self, position: AttackPosition) {
        self.runtime.attack_position = position;
    }

    /// Select the active pull's preferred enemy when eligible, otherwise its lowest eligible id.
    pub fn retarget(&mut self) -> Option<EnemyIdx> {
        let active_pull = self.runtime.encounter.active_pull();
        let pull = self
            .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(enemy.id(), active_pull)
                    })
                    .map(EnemyState::id)
            });

        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;
        }

        true
    }

    pub fn refresh_enemy_health(&mut self, enemy: EnemyIdx, now: SimTime) {
        if let Some(state) = self
            .enemy_mut(enemy)
            .filter(|state| state.is_active() && state.is_alive())
        {
            state.refresh_scripted_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();
        let remove_from_index = state.is_active();
        let mut next_state = state.clone();
        let outcome = next_state.apply_damage(amount, at);

        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;

        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, source: EnemyIdx, now: SimTime) {
        let Some(base_ms) = self
            .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]
    pub(crate) fn enemy_belongs_to_pull(&self, enemy: EnemyIdx, pull: PullId) -> bool {
        let definition = self.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;
        }

        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;

        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)
    }
}