overlord_event_system/logic/

fighting.rs

use crate::{
    TICKER_UNIT_DURATION_MS,
    behaviors::combat::start_cast::StartCastAbilityResult,
    entities::{create_pve_entity, event_from_entity_action},
    event::CustomEventData,
    event::OverlordEvent,
    game_config_helpers::GameConfigLookup,
    logic::handler::OverlordLogic,
    state::OverlordState,
};

use essences::{
    abilities::{AbilityId, AbilitySlotId},
    currency::{CurrencySource, CurrencyUnit},
    entity::{ActionWithDeadline, Coordinates, Entity, EntityAction, EntityAttributes, EntityId},
    fighting::{EntityTeam, EntityType, FightEntity, FightType},
    game::EntityTemplateId,
};
use event_system::{event::EventPluginized, script::random::GameRng, system::EventHandleResult};

use rand::Rng;
use uuid::Uuid;

/// Multiplier applied to a campaign-chapter boss's currency drop so that
/// deeper chapters pay out more ("pushing pays"). Grows geometrically as
/// `growth^chapter_level`, bounded by `cap` (and a hard sane ceiling so a
/// cheated/extreme chapter can never produce an infinite reward). Returns
/// `1.0` (no scaling) when growth is unset or `<= 1.0`.
fn boss_reward_chapter_multiplier(
    growth: Option<f64>,
    cap: Option<f64>,
    chapter_level: i64,
) -> f64 {
    let Some(growth) = growth else { return 1.0 };
    if growth <= 1.0 {
        return 1.0;
    }
    // `min(1e6)` guards against `f64::INFINITY` at extreme chapter levels even
    // when no config cap is set; `clamp(0, 1000)` keeps the `powi` exponent sane.
    let cap = cap.unwrap_or(f64::INFINITY).min(1.0e6);
    let exp = chapter_level.clamp(0, 1000) as i32;
    growth.powi(exp).clamp(1.0, cap)
}

impl OverlordLogic {
    fn compute_ability_slot_level(
        &self,
        slot_id: Option<AbilitySlotId>,
        state: &OverlordState,
    ) -> i64 {
        let Some(slot_id) = slot_id else {
            return 0;
        };

        let game_config = self.game_config.get();
        let slot_level = state
            .character_state
            .character
            .ability_slot_levels
            .get(slot_id)
            .copied()
            .unwrap_or(0)
            .max(0);
        game_config
            .game_settings
            .ability_gacha
            .slot_level_bonus_levels
            .get(slot_level as usize)
            .copied()
            .or_else(|| {
                game_config
                    .game_settings
                    .ability_gacha
                    .slot_level_bonus_levels
                    .last()
                    .copied()
            })
            .unwrap_or(0)
    }

    /// Add charge to the pet combat state. If charge reaches max, queue a StartCastAbility
    /// for the pet and reset charge to 0.
    fn charge_pet_ability(&self, state: &mut OverlordState, charge_delta: i64, current_tick: u64) {
        let Some(active_fight) = &mut state.active_fight else {
            return;
        };
        let Some(pet_state) = &mut active_fight.pet_combat_state else {
            return;
        };

        pet_state.charge = (pet_state.charge + charge_delta).min(pet_state.max_charge);

        if pet_state.charge >= pet_state.max_charge {
            let ability_id = pet_state.ability_id;
            let pet_template_id = pet_state.pet_template_id;
            let player_id = active_fight.player_id;

            pet_state.charge = 0;

            if let Some(player) = active_fight.entities.iter_mut().find(|e| e.id == player_id) {
                player.actions_queue.push(&ActionWithDeadline {
                    action: EntityAction::StartCastAbility {
                        ability_id,
                        by_entity_id: player_id,
                        pet_id: Some(pet_template_id),
                    },
                    deadline_tick: current_tick,
                });
            }
        }
    }

    #[allow(clippy::too_many_arguments)]
    pub fn handle_spawn_entity(
        &self,
        id: EntityId,
        entity_template_id: EntityTemplateId,
        position: Coordinates,
        team: EntityTeam,
        has_big_hp_bar: bool,
        entity_attributes: EntityAttributes,
        current_tick: u64,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let game_config = self.game_config.get();

        let Some(active_fight) = &mut state.active_fight else {
            return EventHandleResult::ok(state);
        };

        if active_fight.entities.iter().any(|entity| entity.id == id) {
            tracing::error!("There is already an entity with id: {id}");
            return EventHandleResult::fail(state);
        }

        let fight_entity = FightEntity {
            entity_type: EntityType::PVEEntity { entity_template_id },
            position,
            has_big_hp_bar,
            team,
        };

        let mut created_entity =
            match create_pve_entity(id, &fight_entity, &game_config, Some(entity_attributes)) {
                Ok(entity) => entity,
                Err(err) => {
                    tracing::error!("Couldn't create entity: {}", err.to_string());
                    return EventHandleResult::fail(state);
                }
            };

        if active_fight.current_wave > 1 {
            created_entity.abilities.iter().for_each(|ability| {
                let cooldown = game_config
                    .ability_template(ability.ability.template_id)
                    .map(|t| t.cooldown)
                    .unwrap_or(0);
                created_entity.actions_queue.push(&ActionWithDeadline {
                    action: self.make_start_cast_ability_action(
                        created_entity.id,
                        ability.ability.template_id,
                    ),
                    deadline_tick: current_tick + cooldown,
                })
            });
        }

        active_fight.entities.push(created_entity);

        EventHandleResult::ok(state)
    }
    pub fn handle_start_move(
        &mut self,
        entity_id: Uuid,
        to: Coordinates,
        duration_ticks: u64,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let Some(active_fight) = &mut state.active_fight else {
            return EventHandleResult::ok(state);
        };

        let Some(entity) = active_fight
            .entities
            .iter_mut()
            .find(|entity| entity.id == entity_id)
        else {
            tracing::error!("Failed to find entity in state with id={}", entity_id);
            return EventHandleResult::fail(state);
        };

        // Marks the entity as moving and reserves the destination for the whole
        // run so a concurrently-planning opponent's `advance_entity` will not
        // commit a run onto (or through) it. Cleared by `handle_end_move`.
        entity.move_target = Some(to.clone());

        // Walk the coordinates cell-by-cell over the run instead of teleporting
        // to the destination: opponents must target the cell the runner is
        // actually passing — a multi-cell run would otherwise let them engage
        // him at the destination the moment he starts running.
        let steps = move_progress_steps(&entity.coordinates, &to, duration_ticks);
        if let Some((_, first)) = steps.first() {
            entity.coordinates = first.clone();
        }
        for (delay_ticks, cell) in steps.into_iter().skip(1) {
            self.fight_clock.schedule(
                OverlordEvent::MoveProgress {
                    entity_id,
                    to: cell,
                },
                delay_ticks,
            );
        }

        self.fight_clock
            .schedule(OverlordEvent::EndMove { entity_id }, duration_ticks);

        EventHandleResult::ok(state)
    }

    pub fn handle_move_progress(
        &self,
        entity_id: Uuid,
        to: Coordinates,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let Some(active_fight) = &mut state.active_fight else {
            return EventHandleResult::ok(state);
        };

        // The runner can die or the move can end before a scheduled waypoint
        // fires; a stale waypoint is normal, not an error.
        if let Some(entity) = active_fight
            .entities
            .iter_mut()
            .find(|entity| entity.id == entity_id)
            && entity.move_target.is_some()
        {
            entity.coordinates = to;
        }

        EventHandleResult::ok(state)
    }

    pub fn handle_end_move(
        &self,
        entity_id: Uuid,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let Some(active_fight) = &mut state.active_fight else {
            return EventHandleResult::ok(state);
        };

        let Some(entity) = active_fight
            .entities
            .iter_mut()
            .find(|entity| entity.id == entity_id)
        else {
            tracing::error!("Failed to find entity in state with id={}", entity_id);
            return EventHandleResult::fail(state);
        };

        // Arrived: release the cell reservation (also clears the moving state).
        entity.move_target = None;

        EventHandleResult::ok_events(
            state,
            vec![EventPluginized::now(OverlordEvent::FightProgress {})],
        )
    }

    pub fn handle_entity_stun(
        &mut self,
        entity_id: Uuid,
        duration_ticks: u64,
        current_tick: u64,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let game_config = self.game_config.get();
        let baseline_speed = game_config.game_settings.baseline_speed;
        let player_id = state.active_fight.as_ref().map(|f| f.player_id);

        let Some(active_fight) = &mut state.active_fight else {
            tracing::error!("EntityStun received with no active fight (entity_id = {entity_id})");
            return EventHandleResult::fail(state);
        };

        let Some(entity) = active_fight.entities.iter_mut().find(|e| e.id == entity_id) else {
            tracing::error!("EntityStun: entity_id = {entity_id} not found in active fight");
            return EventHandleResult::fail(state);
        };

        let entity_speed = entity.attributes.speed_or_baseline(baseline_speed);
        let ability_ids: Vec<AbilityId> = entity
            .abilities
            .iter()
            .map(|aa| aa.ability.template_id)
            .collect();

        for ability_id in ability_ids {
            let base_cooldown = game_config
                .ability_template(ability_id)
                .map(|t| t.cooldown)
                .unwrap_or(0);
            let scaled_cooldown = essences::entity::scale_cooldown_for_speed(
                base_cooldown,
                entity_speed,
                baseline_speed,
            );
            entity.actions_queue.stun_ability(
                ability_id,
                duration_ticks,
                scaled_cooldown,
                current_tick,
            );
        }

        // Mirror the stun to the player's wall-clock ActiveAbility.deadline values so Unity's
        // cooldown bars freeze for the stun duration. For each ability:
        // - mid-cast (deadline was None or in the past) → set deadline = now + full + stun
        // - on cooldown → extend deadline by stun_duration_ms
        // - off cooldown (no deadline) → set deadline = now + stun_duration_ms
        if Some(entity.id) == player_id {
            let now = ::time::utc_now();
            let stun_ms = (duration_ticks as u128 * TICKER_UNIT_DURATION_MS) as i64;
            for active_ability in entity.abilities.iter_mut() {
                let base_cooldown = game_config
                    .ability_template(active_ability.ability.template_id)
                    .map(|t| t.cooldown)
                    .unwrap_or(0);
                let scaled_cooldown = essences::entity::scale_cooldown_for_speed(
                    base_cooldown,
                    entity_speed,
                    baseline_speed,
                );
                let cooldown_ms = (scaled_cooldown as u128 * TICKER_UNIT_DURATION_MS) as i64;

                let new_deadline = match active_ability.deadline {
                    Some(existing) if existing > now => {
                        // On cooldown — extend by stun duration.
                        existing + chrono::TimeDelta::milliseconds(stun_ms)
                    }
                    _ => {
                        // Off cooldown OR mid-cast (no current deadline tracked client-side).
                        // The queue's cancel-cast logic above already handled the in-flight case;
                        // here we just expose the resulting freeze duration to the client. Use
                        // full + stun to match the queue, falling back to stun-only when there is
                        // no full cooldown (e.g. ability_template missing).
                        let total_ms = if base_cooldown > 0 {
                            cooldown_ms + stun_ms
                        } else {
                            stun_ms
                        };
                        now + chrono::TimeDelta::milliseconds(total_ms)
                    }
                };
                active_ability.deadline = Some(new_deadline);
            }
        }

        EventHandleResult::ok(state)
    }

    pub fn handle_entity_cancel_cast_with_cooldown(
        &mut self,
        entity_id: Uuid,
        ability_id: Uuid,
        current_tick: u64,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let game_config = self.game_config.get();

        let Some(active_fight) = &mut state.active_fight else {
            tracing::error!(
                "EntityCancelCastWithCooldown received with no active fight (entity_id = {entity_id})"
            );
            return EventHandleResult::fail(state);
        };

        let Some(entity) = active_fight.entities.iter_mut().find(|e| e.id == entity_id) else {
            tracing::error!(
                "EntityCancelCastWithCooldown: entity_id = {entity_id} not found in active fight"
            );
            return EventHandleResult::fail(state);
        };

        let Some(ability_template) = game_config.ability_template(ability_id) else {
            tracing::error!(
                "EntityCancelCastWithCooldown: ability_template not found for ability_id = {ability_id}"
            );
            return EventHandleResult::fail(state);
        };
        let cooldown = ability_template.cooldown;

        let cancelled = entity
            .actions_queue
            .cancel_cast_and_set_cooldown(ability_id, current_tick + cooldown);

        if !cancelled {
            tracing::error!(
                "EntityCancelCastWithCooldown: no in-flight cast for ability_id = {ability_id} on entity {entity_id}"
            );
            return EventHandleResult::fail(state);
        }

        EventHandleResult::ok(state)
    }

    pub fn handle_entity_add_ability_cooldown(
        &mut self,
        entity_id: Uuid,
        ability_id: Uuid,
        delta_ticks: i64,
        current_tick: u64,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let Some(active_fight) = &mut state.active_fight else {
            tracing::error!(
                "EntityAddAbilityCooldown received with no active fight (entity_id = {entity_id})"
            );
            return EventHandleResult::fail(state);
        };

        let Some(entity) = active_fight.entities.iter_mut().find(|e| e.id == entity_id) else {
            tracing::error!(
                "EntityAddAbilityCooldown: entity_id = {entity_id} not found in active fight"
            );
            return EventHandleResult::fail(state);
        };

        if !entity
            .actions_queue
            .adjust_ability_cooldown(ability_id, delta_ticks, current_tick)
        {
            tracing::error!(
                "EntityAddAbilityCooldown: ability_id = {ability_id} not in cooldown queue for entity {entity_id}"
            );
            return EventHandleResult::fail(state);
        }

        EventHandleResult::ok(state)
    }

    pub fn handle_entity_incr_attribute(
        &mut self,
        entity_id: Uuid,
        attribute: &str,
        delta: i64,
        current_tick: u64,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let game_config = self.game_config.get();
        let baseline_speed = game_config.game_settings.baseline_speed;
        let player_id = state.active_fight.as_ref().map(|f| f.player_id);

        let Some(active_fight) = &mut state.active_fight else {
            return EventHandleResult::ok(state);
        };

        let Some(entity) = active_fight.entities.iter_mut().find(|e| e.id == entity_id) else {
            tracing::debug!("Couldn't find entity_id = {}", entity_id);
            return EventHandleResult::fail(state);
        };

        let old_speed = entity.attributes.speed_or_baseline(baseline_speed);
        entity.attributes.add(attribute, delta);
        let new_speed = entity.attributes.speed_or_baseline(baseline_speed);

        if attribute == "speed" && old_speed != new_speed {
            entity.actions_queue.rescale_cooldowns(
                old_speed,
                new_speed,
                current_tick,
                baseline_speed,
            );

            if Some(entity.id) == player_id {
                let now = ::time::utc_now();
                let baseline = baseline_speed.max(1) as i128;
                let old_s = if old_speed <= 0 {
                    baseline
                } else {
                    old_speed as i128
                };
                let new_s = if new_speed <= 0 {
                    baseline
                } else {
                    new_speed as i128
                };
                for active_ability in entity.abilities.iter_mut() {
                    let Some(deadline) = active_ability.deadline else {
                        continue;
                    };
                    let remaining_ms = (deadline - now).num_milliseconds();
                    if remaining_ms <= 0 {
                        continue;
                    }
                    let scaled_ms = ((remaining_ms as i128) * old_s / new_s) as i64;
                    let scaled_ms = scaled_ms.max(1);
                    active_ability.deadline =
                        Some(now + chrono::TimeDelta::milliseconds(scaled_ms));
                }
            }
        }

        entity.effect_ids = entity
            .effect_ids
            .iter()
            .filter(|effect_id| {
                if let Some(effect) = game_config.effect(**effect_id) {
                    // tracing::error!("Found this effect: {effect:?}");
                    // tracing::error!("Got this attributes: {:?}", entity.attributes);
                    if effect.has_at_least_one_required_attribute(&entity.attributes) {
                        true
                    } else {
                        if effect.interval_ticks.is_some() {
                            entity.actions_queue.remove_cast_effect_action(effect.id);
                        }
                        false
                    }
                } else {
                    false
                }
            })
            .cloned()
            .collect();

        EventHandleResult::ok(state)
    }

    pub fn handle_entity_apply_effect(
        &mut self,
        entity_id: Uuid,
        effect_id: Uuid,
        current_tick: u64,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let Some(active_fight) = &mut state.active_fight else {
            return EventHandleResult::ok(state);
        };

        let game_config = self.game_config.get();

        let Some(entity) = active_fight.entities.iter_mut().find(|e| e.id == entity_id) else {
            tracing::debug!("Couldn't find entity_id = {}", entity_id);
            return EventHandleResult::fail(state);
        };

        let Ok(effect) = game_config.require_effect(effect_id) else {
            tracing::debug!("Couldn't find effect_id = {}", effect_id);
            return EventHandleResult::fail(state);
        };

        if let Some(required_attributes) = &effect.required_attributes
            && !required_attributes
                .iter()
                .any(|attr| entity.attributes.0.contains_key(attr))
        {
            tracing::error!("Effect has required attributes, but they are not set");
            return EventHandleResult::fail(state);
        }

        for existing_effect_id in &entity.effect_ids {
            if *existing_effect_id == effect.id {
                tracing::error!("Effect is already set on entity");
                return EventHandleResult::fail(state);
            }
        }

        entity.effect_ids.push(effect.id);

        if let Some(interval_ticks) = &effect.interval_ticks {
            entity.actions_queue.push(&ActionWithDeadline {
                action: self.make_cast_effect_action(entity_id, effect.id),
                deadline_tick: current_tick + interval_ticks,
            });
        }

        EventHandleResult::ok(state)
    }

    #[allow(clippy::too_many_arguments)]
    pub fn handle_cast_effect(
        &mut self,
        entity_id: Uuid,
        effect_id: Uuid,
        caller_event: Option<Box<OverlordEvent>>,
        rand_gen: rand::rngs::StdRng,
        current_tick: u64,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let Some(active_fight) = &mut state.active_fight else {
            return EventHandleResult::ok(state);
        };

        let active_fight_cloned = active_fight.clone();

        let game_config = self.game_config.get();

        let Some(entity) = active_fight.entities.iter_mut().find(|e| e.id == entity_id) else {
            tracing::debug!("Couldn't find entity_id = {}", entity_id);
            return EventHandleResult::fail(state);
        };

        let Ok(effect) = game_config.require_effect(effect_id) else {
            tracing::debug!("Couldn't find effect_id = {}", effect_id);
            return EventHandleResult::fail(state);
        };

        if !entity.effect_ids.contains(&effect_id) {
            tracing::error!("entity_id = {} has no effect_id = {}", entity_id, effect_id);
            return EventHandleResult::fail(state);
        }

        let entity_cloned = entity.clone();

        // Native `event` (effect) port: look up the effect's `script` fn
        // and run it on the RNG snapshot.
        let Some(native_name) = effect.behavior.as_deref() else {
            tracing::error!("Effect {} has no script registered", effect_id);
            return EventHandleResult::fail(state);
        };
        let Some(native_fn) = self.behaviors.event_fn(native_name) else {
            tracing::error!("No native event fn registered for {native_name}");
            return EventHandleResult::fail(state);
        };

        let rng = GameRng::new(rand_gen);
        let events = match native_fn(&crate::behaviors::combat::effects::EventCtx {
            entity: &entity_cloned,
            fight: &active_fight_cloned,
            rng: &rng,
            current_tick,
            fight_duration_ticks: current_tick - self.start_fight_tick,
            caller_event: caller_event.as_deref(),
            config: &game_config,
            lookups: self.behaviors.lookups(),
        }) {
            Ok(events) => events,
            Err(err) => {
                tracing::error!("Effect script failed with error: {err:?}");
                return EventHandleResult::fail(state);
            }
        };

        if let Some(interval_ticks) = effect.interval_ticks {
            entity.actions_queue.push(&ActionWithDeadline {
                action: self.make_cast_effect_action(entity_id, effect.id),
                deadline_tick: current_tick + interval_ticks,
            });
        }

        EventHandleResult::ok_events(
            state,
            events.into_iter().map(EventPluginized::now).collect(),
        )
    }

    pub fn handle_start_cast_ability(
        &mut self,
        _event: OverlordEvent,
        by_entity_id: Uuid,
        ability_id: AbilityId,
        rand_gen: rand::rngs::StdRng,
        current_tick: u64,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let game_config = self.game_config.get();

        let state_cloned = state.clone();

        let Some(active_fight) = &mut state.active_fight else {
            tracing::error!("No active fight for start_cast_ability");
            return EventHandleResult::ok(state);
        };
        let active_fight_cloned = active_fight.clone();
        let Some(casted_by_entity) = active_fight
            .entities
            .iter_mut()
            .find(|e| e.id == by_entity_id)
        else {
            tracing::debug!("Couldn't find caster entity_id = {}", by_entity_id);
            return EventHandleResult::fail(state);
        };
        let casted_by_entity_cloned = casted_by_entity.clone();
        let Some(active_ability) = casted_by_entity
            .abilities
            .iter_mut()
            .find(|equipped_ability| equipped_ability.ability.template_id == ability_id)
        else {
            tracing::error!(
                "Couldn't find ability_id = {} in caster entity {:?}",
                ability_id,
                casted_by_entity
            );
            return EventHandleResult::fail(state);
        };
        let ability = &active_ability.ability;
        let ability_template_id = ability.template_id;
        let ability_level = ability.level;

        let Some(ability_template) = game_config.ability_template(ability_template_id).cloned()
        else {
            tracing::error!(
                "Couldn't find template for ability_id = {}",
                ability_template_id
            );
            return EventHandleResult::fail(state);
        };
        let ability_cooldown = ability_template.cooldown;

        let _ability_slot_level =
            self.compute_ability_slot_level(active_ability.slot_id, &state_cloned);
        let _ = (ability_level, &state_cloned);

        // Native `start_cast_ability` port: look up the ability's
        // `start_behavior` fn and run it on the RNG snapshot.
        let native_result = (|| {
            let name = ability_template.start_behavior.as_deref()?;
            let f = self.behaviors.start_cast_ability_fn(name)?;
            Some(f(
                &crate::behaviors::combat::start_cast::StartCastAbilityCtx {
                    caster: &casted_by_entity_cloned,
                    fight: &active_fight_cloned,
                    rng: &GameRng::new(rand_gen),
                    ability_template_id,
                    config: &game_config,
                    lookups: self.behaviors.lookups(),
                },
            ))
        })();

        let results = match native_result {
            Some(Ok(v)) => v,
            other => {
                if let Some(e) = state
                    .active_fight
                    .as_mut()
                    .and_then(|af| af.entities.iter_mut().find(|e| e.id == by_entity_id))
                {
                    let baseline_speed = game_config.game_settings.baseline_speed;
                    let scaled_cooldown = essences::entity::scale_cooldown_for_speed(
                        ability_cooldown,
                        e.attributes.speed_or_baseline(baseline_speed),
                        baseline_speed,
                    );
                    e.actions_queue.push(&ActionWithDeadline {
                        action: self
                            .make_start_cast_ability_action(by_entity_id, ability_template_id),
                        deadline_tick: current_tick + scaled_cooldown,
                    });
                }

                match other {
                    Some(Err(err)) => {
                        tracing::error!("Ability start cast script failed with error: {err:?}")
                    }
                    _ => tracing::error!(
                        "Ability {ability_template_id} has no start_behavior registered"
                    ),
                }
                return EventHandleResult::fail(state);
            }
        };

        let (actions, events) =
            match StartCastAbilityResult::vec_into_actions_with_deadlines_and_events(
                &results,
                state.character_state.character.class,
                &game_config,
                ability_template_id,
                by_entity_id,
                current_tick,
            ) {
                Ok((actions, events)) => (actions, events),
                Err(err) => {
                    tracing::error!(
                        "Error converting StartCastAbilityResultVec = {:?} into EntityActionVec = {:?}",
                        results,
                        err
                    );
                    // The StartCastAbility action was already popped from the
                    // actions queue by `handle_fight_progress`; requeue it
                    // (like the script-failure path above) so a deterministic
                    // conversion error doesn't stall the entity for the rest
                    // of the fight.
                    if let Some(entity) = state
                        .active_fight
                        .as_mut()
                        .and_then(|af| af.entities.iter_mut().find(|e| e.id == by_entity_id))
                    {
                        let baseline_speed = game_config.game_settings.baseline_speed;
                        let scaled_cooldown = essences::entity::scale_cooldown_for_speed(
                            ability_cooldown,
                            entity.attributes.speed_or_baseline(baseline_speed),
                            baseline_speed,
                        );
                        entity.actions_queue.push(&ActionWithDeadline {
                            action: self
                                .make_start_cast_ability_action(by_entity_id, ability_template_id),
                            deadline_tick: current_tick + scaled_cooldown,
                        });
                    }
                    return EventHandleResult::fail(state);
                }
            };

        let baseline_speed = game_config.game_settings.baseline_speed;
        let scaled_cooldown = essences::entity::scale_cooldown_for_speed(
            ability_cooldown,
            casted_by_entity
                .attributes
                .speed_or_baseline(baseline_speed),
            baseline_speed,
        );
        casted_by_entity
            .actions_queue
            .append_start_cast_ability_result_actions(
                &actions,
                current_tick,
                ability_template_id,
                scaled_cooldown,
            );
        if casted_by_entity.id == active_fight.player_id && !actions.is_empty() {
            active_ability.deadline = Some(
                ::time::utc_now()
                    + chrono::TimeDelta::milliseconds(
                        (scaled_cooldown as u128 * TICKER_UNIT_DURATION_MS) as i64,
                    ),
            );
        }

        let now_events = self.route_delayed_to_clock(events);

        EventHandleResult::ok_events(state, now_events)
    }

    /// Route delayed-marked pluginized events (StartedCastAbility wind-ups)
    /// onto the combat clock; immediate ones flow out as regular events.
    fn route_delayed_to_clock(
        &mut self,
        events: Vec<EventPluginized<OverlordEvent, OverlordState>>,
    ) -> Vec<EventPluginized<OverlordEvent, OverlordState>> {
        events
            .into_iter()
            .filter_map(|pluginized| {
                let (event, delayed, _cron) = pluginized.into_parts();
                if let Some(delayed) = delayed {
                    self.fight_clock.schedule(event, delayed.ticks);
                    None
                } else {
                    Some(EventPluginized::now(event))
                }
            })
            .collect()
    }

    /// Route `StartCastProjectile` script outputs onto the combat clock
    /// (clamped to at least one tick so the projectile fires on a later
    /// tick); everything else flows out as immediate events.
    fn route_projectiles_to_clock(
        &mut self,
        events: Vec<OverlordEvent>,
    ) -> Vec<EventPluginized<OverlordEvent, OverlordState>> {
        events
            .into_iter()
            .filter_map(|x| {
                if let OverlordEvent::StartCastProjectile { delay, .. } = x {
                    let delay = delay.max(1);
                    self.fight_clock.schedule(x, delay);
                    None
                } else {
                    Some(EventPluginized::now(x))
                }
            })
            .collect()
    }

    #[allow(clippy::too_many_arguments)]
    pub fn handle_cast_ability(
        &mut self,
        _event: OverlordEvent,
        by_entity_id: Uuid,
        to_entity_id: Uuid,
        ability_id: AbilityId,
        rand_gen: rand::rngs::StdRng,
        current_tick: u64,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let game_config = self.game_config.get();
        let state_cloned = state.clone();

        let Some(active_fight) = &mut state.active_fight else {
            return EventHandleResult::ok(state);
        };

        let Some(target_entity) = active_fight
            .entities
            .iter()
            .find(|e| e.id == to_entity_id)
            .cloned()
        else {
            tracing::debug!("Couldn't find target entity_id = {to_entity_id}");
            return EventHandleResult::fail(state);
        };

        let active_fight_clone = active_fight.clone();

        let Some(casted_by_entity) = active_fight
            .entities
            .iter_mut()
            .find(|e| e.id == by_entity_id)
        else {
            tracing::debug!("Couldn't find caster entity_id = {by_entity_id}");
            return EventHandleResult::fail(state);
        };

        let Some(active_ability) = casted_by_entity
            .abilities
            .iter()
            .find(|equipped_ability| equipped_ability.ability.template_id == ability_id)
            .cloned()
        else {
            tracing::error!(
                "Couldn't find ability_id = {} in caster entity {:?}",
                ability_id,
                casted_by_entity
            );
            return EventHandleResult::fail(state);
        };
        let ability = active_ability.ability;
        let ability_slot_level =
            self.compute_ability_slot_level(active_ability.slot_id, &state_cloned);

        let player_id = active_fight.player_id;

        let Some(ability_template) = game_config.ability_template(ability.template_id).cloned()
        else {
            tracing::error!(
                "Couldn't find template for ability_id = {}",
                ability.template_id
            );
            return EventHandleResult::fail(state);
        };

        let _ = (&state_cloned, ability_slot_level);

        // Native `cast_ability` port: look up the ability's `script` fn
        // and run it on the RNG snapshot.
        let native_result = (|| {
            let name = ability_template.behavior.as_deref()?;
            let f = self.behaviors.cast_ability_fn(name)?;
            Some(f(&crate::behaviors::combat::cast_ability::CastAbilityCtx {
                caster_entity: casted_by_entity,
                target_entity: &target_entity,
                fight: &active_fight_clone,
                rng: &GameRng::new(rand_gen),
                ability_level: ability.level,
                config: &game_config,
                lookups: self.behaviors.lookups(),
            }))
        })();

        match native_result {
            Some(Ok(events)) => {
                // Charge pet ability on player skill use
                if by_entity_id == player_id {
                    let game_config = self.game_config.get();
                    if let Some(charge_rate) = state
                        .active_fight
                        .as_ref()
                        .and_then(|af| af.pet_combat_state.as_ref())
                        .and_then(|ps| game_config.pet_template(ps.pet_template_id))
                        .map(|t| t.charge_rate_on_skill_use)
                    {
                        self.charge_pet_ability(&mut state, charge_rate, current_tick);
                    }
                }

                let now_events = self.route_projectiles_to_clock(events);
                EventHandleResult::ok_events(state, now_events)
            }
            Some(Err(err)) => {
                tracing::error!("Ability cast script failed with error: {err:?}");
                EventHandleResult::fail(state)
            }
            None => {
                tracing::error!("Ability {} has no script registered", ability.template_id);
                EventHandleResult::fail(state)
            }
        }
    }

    #[allow(clippy::too_many_arguments)]
    pub fn handle_start_cast_projectile(
        &mut self,
        _event: OverlordEvent,
        by_entity_id: Uuid,
        to_entity_id: Uuid,
        projectile_id: Uuid,
        level: i64,
        current_tick: u64,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let game_config = self.game_config.get();

        let Some(active_fight) = &mut state.active_fight else {
            return EventHandleResult::ok(state);
        };

        let Some(target_entity) = active_fight
            .entities
            .iter()
            .find(|e| e.id == to_entity_id)
            .cloned()
        else {
            tracing::debug!("Couldn't find entity_id = {}", to_entity_id);
            return EventHandleResult::fail(state);
        };

        let Ok(projectile) = game_config.require_projectile(projectile_id) else {
            tracing::error!("Couldn't find projectile_id = {} in config", projectile_id);
            return EventHandleResult::fail(state);
        };

        let active_fight_clone = active_fight.clone();

        let Some(casted_by_entity) = active_fight
            .entities
            .iter_mut()
            .find(|e| e.id == by_entity_id)
        else {
            tracing::debug!("Couldn't find caster entity_id = {}", by_entity_id);
            return EventHandleResult::fail(state);
        };

        let _ = (&active_fight_clone, current_tick);

        // Native `start_cast_projectile` port: look up the projectile's
        // `start_behavior` fn and run it.
        let native_result = (|| {
            let name = projectile.start_behavior.as_deref()?;
            let f = self.behaviors.start_cast_projectile_fn(name)?;
            Some(f(
                &crate::behaviors::combat::start_cast::StartCastProjectileCtx {
                    caster_entity: casted_by_entity,
                    target_entity: &target_entity,
                },
            ))
        })();

        let result = match native_result {
            Some(Ok(v)) => v,
            Some(Err(err)) => {
                tracing::error!("Projectile start cast script failed with error: {err:?}");
                return EventHandleResult::fail(state);
            }
            None => {
                tracing::error!("Projectile {projectile_id} has no start_behavior registered");
                return EventHandleResult::fail(state);
            }
        };

        self.fight_clock.schedule(
            OverlordEvent::CastProjectile {
                by_entity_id,
                to_entity_id,
                projectile_id,
                level,
                projectile_data: result.projectile_data,
            },
            result.animation_duration_ticks as u64,
        );

        EventHandleResult::ok_events(
            state,
            vec![EventPluginized::now(OverlordEvent::StartedCastProjectile {
                by_entity_id,
                to_entity_id,
                projectile_id,
                duration_ticks: result.animation_duration_ticks as u64,
            })],
        )
    }

    #[allow(clippy::too_many_arguments)]
    pub fn handle_cast_projectile(
        &mut self,
        _event: OverlordEvent,
        by_entity_id: Uuid,
        to_entity_id: Uuid,
        projectile_id: Uuid,
        level: i64,
        projectile_data: &CustomEventData,
        rand_gen: rand::rngs::StdRng,
        current_tick: u64,
        state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let game_config = self.game_config.get();

        let Some(active_fight) = &state.active_fight else {
            return EventHandleResult::ok(state);
        };

        let Some(casted_by_entity) = active_fight.entities.iter().find(|e| e.id == by_entity_id)
        else {
            tracing::debug!("Couldn't find caster entity_id = {}", by_entity_id);
            return EventHandleResult::fail(state);
        };

        let Some(target_entity) = active_fight
            .entities
            .iter()
            .find(|e| e.id == to_entity_id)
            .cloned()
        else {
            tracing::debug!("Couldn't find target entity_id = {}", to_entity_id);
            return EventHandleResult::fail(state);
        };

        let Ok(projectile) = game_config.require_projectile(projectile_id) else {
            tracing::error!("Couldn't find projectile_id = {} in config", projectile_id);
            return EventHandleResult::fail(state);
        };

        let _ = (projectile_data, current_tick);

        // Native `cast_projectile` port: look up the projectile's `script`
        // fn and run it on the RNG snapshot.
        let native_result = (|| {
            let name = projectile.behavior.as_deref()?;
            let f = self.behaviors.cast_projectile_fn(name)?;
            Some(f(
                &crate::behaviors::combat::cast_projectile::CastProjectileCtx {
                    caster_entity: casted_by_entity,
                    target_entity: &target_entity,
                    fight: active_fight,
                    rng: &GameRng::new(rand_gen),
                    projectile_level: level,
                    config: &game_config,
                    lookups: self.behaviors.lookups(),
                },
            ))
        })();

        match native_result {
            Some(Ok(events)) => {
                let now_events = self.route_projectiles_to_clock(events);
                EventHandleResult::ok_events(state, now_events)
            }
            Some(Err(err)) => {
                tracing::error!("Projectile cast script failed with error: {err:?}");
                EventHandleResult::fail(state)
            }
            None => {
                tracing::error!("Projectile {projectile_id} has no script registered");
                EventHandleResult::fail(state)
            }
        }
    }

    pub fn handle_player_death(
        &mut self,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let Some(active_fight) = &mut state.active_fight else {
            return EventHandleResult::ok(state);
        };

        // The fight already ended (e.g. max-duration timeout): an in-flight
        // combat event killed the player afterwards. Don't schedule a second
        // EndFight for the same fight.
        if active_fight.fight_ended {
            return EventHandleResult::ok(state);
        }

        active_fight.entities = Vec::new();

        let fight_uuid = active_fight.id;
        active_fight.fight_ended = true;
        let end_fight_delay = self.get_end_fight_delay(active_fight.fight_id);

        self.fight_clock.schedule(
            OverlordEvent::EndFight {
                fight_id: fight_uuid,
                is_win: false,
                pvp_state: state.pvp_state.clone().map(Box::new),
            },
            end_fight_delay,
        );

        EventHandleResult::ok(state)
    }

    pub fn handle_entity_death(
        &mut self,
        entity_id: Uuid,
        reward: Vec<CurrencyUnit>,
        rand_gen: rand::rngs::StdRng,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let game_config = self.game_config.get();

        let Some(active_fight) = &mut state.active_fight else {
            return EventHandleResult::ok(state);
        };

        // The fight already ended (e.g. max-duration timeout): an in-flight
        // combat event killed an entity afterwards. Don't process the death —
        // it could schedule a second EndFight (or spawn a next wave) for a
        // fight that is already over.
        if active_fight.fight_ended {
            return EventHandleResult::ok(state);
        }

        let Some(entity_idx) = active_fight
            .entities
            .iter()
            .position(|entity| entity.id == entity_id)
        else {
            tracing::error!("Failed to get entity with entity_id={}", entity_id);
            return EventHandleResult::fail(state);
        };

        active_fight.entities.swap_remove(entity_idx);

        let mut events = Vec::new();

        events.push(Self::currency_increase(
            &reward,
            CurrencySource::EntityDeath,
        ));

        let Some(active_fight) = &mut state.active_fight else {
            return EventHandleResult::ok(state);
        };
        let Ok(fight) = game_config.require_fight_template(active_fight.fight_id) else {
            tracing::error!(
                "Failed to get fight_template with id {} ",
                active_fight.fight_id
            );
            return EventHandleResult::fail(state);
        };

        let has_any_ally = active_fight
            .entities
            .iter()
            .any(|e| e.team == EntityTeam::Ally);

        if active_fight.get_enemies_amount() == 0 && has_any_ally {
            if active_fight.current_wave == fight.waves_amount {
                let fight_uuid = active_fight.id;
                active_fight.fight_ended = true;
                let end_fight_delay = self.get_end_fight_delay(active_fight.fight_id);
                self.fight_clock.schedule(
                    OverlordEvent::EndFight {
                        fight_id: fight_uuid,
                        is_win: true,
                        pvp_state: state.pvp_state.clone().map(Box::new),
                    },
                    end_fight_delay,
                );
                if fight.fight_type == FightType::CampaignBossFight {
                    events.push(EventPluginized::now(OverlordEvent::StageCleared {}));
                }
            } else {
                let fight_uuid = active_fight.id;
                active_fight.current_wave += 1;
                let active_fight_cloned = active_fight.clone();
                let current_chapter = state.character_state.character.current_chapter_level;

                // Native `prepare_fight` interpreter: spawn the current wave from
                // the typed `prepare_fight_waves` config (the native data source),
                //
                // `base_power` was a literal argument of the legacy
                // `spawn_wave(...)` script, transpiled from the template's
                // TOP-LEVEL `power` field (`$.power`). Pass that — NOT
                // `wave_data.power` (the waves-blob's inner value, 4-26x
                // larger on live templates), which inflated campaign mob
                // stats 2-5x vs the legacy engine. See the matching fix in
                // `chapters_management.rs`.
                let prepare_fight_events = match fight.prepare_fight_waves.as_ref() {
                    Some(waves_cfg) => {
                        let wave_data = crate::mechanics::fight::wave_data_from_config(waves_cfg);
                        let fight_type_str = format!("{:?}", fight.fight_type);
                        let mut sink = crate::mechanics::fight::NativeSink::default();
                        let rng = GameRng::new(rand_gen);
                        match crate::mechanics::fight::spawn_wave(
                            &mut sink,
                            &rng,
                            &game_config,
                            self.behaviors.lookups(),
                            &active_fight_cloned,
                            &wave_data,
                            fight.power.map(|p| p as f64).unwrap_or(0.0),
                            current_chapter,
                            &fight_type_str,
                        ) {
                            Ok(()) => sink.events,
                            Err(err) => {
                                tracing::error!(
                                    "Prepare wave for new wave failed with error: {err:?}"
                                );
                                events.push(EventPluginized::now(OverlordEvent::EndFight {
                                    fight_id: fight_uuid,
                                    is_win: false,
                                    pvp_state: state.pvp_state.clone().map(Box::new),
                                }));
                                return EventHandleResult::ok_events(state, events);
                            }
                        }
                    }
                    None => {
                        tracing::error!(
                            "Fight {} has no prepare_fight_waves for next wave",
                            fight.id
                        );
                        events.push(EventPluginized::now(OverlordEvent::EndFight {
                            fight_id: fight_uuid,
                            is_win: false,
                            pvp_state: state.pvp_state.clone().map(Box::new),
                        }));
                        return EventHandleResult::ok_events(state, events);
                    }
                };

                if prepare_fight_events.is_empty() {
                    tracing::error!("Prepare wave script returned no events");
                    events.push(EventPluginized::now(OverlordEvent::EndFight {
                        fight_id: fight_uuid,
                        is_win: false,
                        pvp_state: state.pvp_state.clone().map(Box::new),
                    }));
                    return EventHandleResult::ok_events(state, events);
                }

                if !prepare_fight_events
                    .iter()
                    .any(|ev| matches!(ev, OverlordEvent::SpawnEntity { .. }))
                {
                    tracing::error!("Prepare wave script returned no SpawnEntity events");
                    events.push(EventPluginized::now(OverlordEvent::EndFight {
                        fight_id: fight_uuid,
                        is_win: false,
                        pvp_state: state.pvp_state.clone().map(Box::new),
                    }));
                    return EventHandleResult::ok_events(state, events);
                }

                events.append(
                    &mut prepare_fight_events
                        .into_iter()
                        .map(EventPluginized::now)
                        .collect(),
                );

                events.push(EventPluginized::now(OverlordEvent::WaveCleared {}));
            }
        }

        EventHandleResult::ok_events(state, events)
    }

    pub fn handle_heal(
        &self,
        entity_id: Uuid,
        heal: u64,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let Some(active_fight) = &mut state.active_fight else {
            return EventHandleResult::ok(state);
        };

        let Some(healed_entity) = active_fight
            .entities
            .iter_mut()
            .find(|entity| entity.id == entity_id)
        else {
            tracing::error!("Failed to get entity with entity_id={}", entity_id);
            return EventHandleResult::fail(state);
        };

        healed_entity.hp = healed_entity
            .hp
            .saturating_add(heal)
            .min(healed_entity.max_hp);

        EventHandleResult::ok(state)
    }

    pub fn handle_damage(
        &self,
        entity_id: Uuid,
        damage: u64,
        current_tick: u64,
        mut rand_gen: rand::rngs::StdRng,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let Some(active_fight) = &mut state.active_fight else {
            return EventHandleResult::ok(state);
        };

        let player_id = active_fight.player_id;

        let Some(damaged_entity) = active_fight
            .entities
            .iter_mut()
            .find(|entity| entity.id == entity_id)
        else {
            tracing::error!("Failed to get entity with entity_id={}", entity_id);
            return EventHandleResult::fail(state);
        };

        let new_hp = damaged_entity.hp - damage.min(damaged_entity.hp);
        damaged_entity.hp = new_hp;

        // Charge the pet when the player's side is involved in the damage:
        // either the player takes the hit, or an enemy takes a hit. The `Damage`
        // event carries no dealer id, so "enemy took damage" is the proxy for
        // "the player's side dealt it" — exact in PvE (all enemy damage,
        // including DoTs, originates from the player's side). In PvP this also
        // credits damage the party ally deals; tightening it would require
        // threading a damage-source id through the `Damage` event.
        let is_player_taking_damage = entity_id == player_id;
        let is_player_dealing_damage = !is_player_taking_damage
            && state
                .active_fight
                .as_ref()
                .and_then(|af| af.entities.iter().find(|e| e.id == entity_id))
                .is_some_and(|e| e.team == EntityTeam::Enemy);
        let game_config = self.game_config.get();
        let charge_rate = if is_player_taking_damage || is_player_dealing_damage {
            state
                .active_fight
                .as_ref()
                .and_then(|af| af.pet_combat_state.as_ref())
                .and_then(|ps| game_config.pet_template(ps.pet_template_id))
                .map(|t| {
                    if is_player_taking_damage {
                        t.charge_rate_on_damage_taken
                    } else {
                        t.charge_rate_on_damage_dealt
                    }
                })
        } else {
            None
        };

        if let Some(rate) = charge_rate
            && rate > 0
        {
            self.charge_pet_ability(&mut state, rate, current_tick);
        }

        if new_hp > 0 {
            return EventHandleResult::ok(state);
        }

        let Some(active_fight) = &mut state.active_fight else {
            return EventHandleResult::ok(state);
        };

        let Some(damaged_entity) = active_fight
            .entities
            .iter_mut()
            .find(|entity| entity.id == entity_id)
        else {
            return EventHandleResult::fail(state);
        };

        // Capture values before dropping the mutable borrow
        let damaged_id = damaged_entity.id;
        let damaged_team = damaged_entity.team.clone();
        let damaged_rewards = damaged_entity.rewards.clone();
        let damaged_template_id = damaged_entity.entity_template_id;

        let has_remaining_allies = active_fight
            .entities
            .iter()
            .any(|e| e.team == EntityTeam::Ally && e.id != damaged_id);

        let mut events = Vec::new();

        if damaged_team == EntityTeam::Enemy {
            // Enemy death — compute and drop rewards
            let mut currencies = Vec::new();

            if state.pvp_state.is_none() {
                // "Pushing pays": a campaign-chapter boss drops more reward
                // currency the deeper the chapter, so clearing a fresh chapter
                // visibly pays out more from the boss (reusing the existing
                // fly-out drop VFX). Trash mobs and non-campaign fights (dungeon,
                // arena, single) are unaffected — only `is_boss` entities in a
                // campaign fight scale.
                let reward_multiplier = {
                    let is_boss = damaged_template_id
                        .and_then(|tid| game_config.entity_template(tid))
                        .is_some_and(|t| t.is_boss);
                    let is_campaign = game_config
                        .require_fight_template(active_fight.fight_id)
                        .map(|f| {
                            matches!(
                                f.fight_type,
                                FightType::CampaignFight | FightType::CampaignBossFight
                            )
                        })
                        .unwrap_or(false);
                    if is_boss && is_campaign {
                        boss_reward_chapter_multiplier(
                            game_config.game_settings.boss_reward_chapter_growth,
                            game_config.game_settings.boss_reward_max_multiplier,
                            state.character_state.character.current_chapter_level,
                        )
                    } else {
                        1.0
                    }
                };

                if let Some(rewards) = damaged_rewards {
                    for reward in rewards {
                        if rand_gen.random_range(0.0..100.0) < reward.drop_chance.clamp(0.0, 100.0)
                        {
                            let rolled = if reward.from <= reward.to {
                                rand_gen.random_range(reward.from..=reward.to)
                            } else {
                                tracing::error!(
                                    "Entity {} has a bad reward range: {:?}",
                                    damaged_id,
                                    reward
                                );
                                0
                            };
                            let amount = if reward_multiplier > 1.0 {
                                ((rolled as f64) * reward_multiplier).round() as i64
                            } else {
                                rolled
                            };
                            currencies.push(CurrencyUnit {
                                currency_id: reward.currency_id,
                                amount,
                            });
                        }
                    }
                } else {
                    tracing::error!(
                        "Failed to get reward from damaged_entity with entity_id={}",
                        entity_id
                    );
                };
            }

            events.push(EventPluginized::now(OverlordEvent::EntityDeath {
                entity_id: damaged_id,
                reward: currencies,
            }));
        } else if has_remaining_allies {
            // An ally dies but other allies survive — remove from fight, continue
            events.push(EventPluginized::now(OverlordEvent::EntityDeath {
                entity_id: damaged_id,
                reward: Vec::new(),
            }));
        } else {
            // Last ally dies — fight lost
            events.push(EventPluginized::now(OverlordEvent::PlayerDeath {}));
        }

        EventHandleResult::ok_events(state, events)
    }

    #[allow(dead_code)]
    fn get_entity_index_with_closest_start_cast(&self, entities: &[Entity]) -> usize {
        entities
            .iter()
            .enumerate()
            .filter_map(|(index, entity)| {
                entity
                    .actions_queue
                    .get_closest_start_cast_action_deadline()
                    .map(|deadline| (index, deadline))
            })
            .min_by_key(|&(_, deadline)| deadline)
            .map(|(index, _)| index)
            .unwrap_or(0)
    }

    pub fn handle_fight_progress(
        &mut self,
        current_tick: u64,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let Some(active_fight) = &mut state.active_fight else {
            tracing::error!("No active_fight for fight_progress");
            return EventHandleResult::ok(state);
        };

        if active_fight.fight_ended {
            return EventHandleResult::ok(state);
        }

        if active_fight.fight_stopped {
            return EventHandleResult::ok(state);
        }

        if active_fight.entities.is_empty() {
            tracing::error!("No entities in fight");
            return EventHandleResult::ok(state);
        }

        if current_tick - self.start_fight_tick >= active_fight.max_duration_ticks {
            active_fight.fight_ended = true;
            tracing::debug!("Fight lasted too long, ending it");
            let fight_uuid = active_fight.id;
            let fight_id = active_fight.fight_id;
            let end_fight_delay = self.get_end_fight_delay(fight_id);
            let pvp_state = state.pvp_state.clone().map(Box::new);
            self.fight_clock.schedule(
                OverlordEvent::EndFight {
                    fight_id: fight_uuid,
                    is_win: false,
                    pvp_state,
                },
                end_fight_delay,
            );
            return EventHandleResult::ok(state);
        }

        let mut events = vec![];

        for entity in &mut active_fight.entities {
            if entity.move_target.is_none()
                && let Some(action) = entity.actions_queue.pop(current_tick)
            {
                events.push(event_from_entity_action(action, entity.id));
            }
        }

        EventHandleResult::ok_events(state, events)
    }

    pub fn handle_set_max_hp(
        &mut self,
        entity_id: EntityId,
        new_max_hp: u64,
        new_hp: u64,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let Some(active_fight) = &mut state.active_fight else {
            tracing::error!("No active fight for end_fight");
            return EventHandleResult::fail(state);
        };

        let Some(entity) = active_fight
            .entities
            .iter_mut()
            .find(|entity| entity.id == entity_id)
        else {
            tracing::error!("Failed to get entity with entity_id={}", entity_id);
            return EventHandleResult::fail(state);
        };

        entity.max_hp = new_max_hp;
        entity.hp = new_hp.min(new_max_hp);

        EventHandleResult::ok(state)
    }
}

/// Per-cell waypoints of a run from `from` to `to`: `(delay_ticks, cell)` for
/// every cell entered, in traversal order. The runner "enters" a cell at the
/// start of its traversal — the first waypoint has delay 0 (applied
/// immediately by `handle_start_move`) and the destination cell is reached one
/// cell-time before `EndMove`, the same coordinate timeline the old
/// one-`StartMove`-per-cell movement produced.
fn move_progress_steps(
    from: &Coordinates,
    to: &Coordinates,
    duration_ticks: u64,
) -> Vec<(u64, Coordinates)> {
    let dx = to.x - from.x;
    let dy = to.y - from.y;
    let steps = dx.abs().max(dy.abs()).max(1);
    (1..=steps)
        .map(|k| {
            let cell = Coordinates {
                x: from.x + dx * k / steps,
                y: from.y + dy * k / steps,
            };
            (duration_ticks * (k as u64 - 1) / steps as u64, cell)
        })
        .collect()
}

#[cfg(test)]
mod tests {
    use super::*;

    fn at(x: i64, y: i64) -> Coordinates {
        Coordinates { x, y }
    }

    /// The waypoints must reproduce the old one-StartMove-per-cell coordinate
    /// timeline: enter cell k at (k-1)/N of the run, destination entered one
    /// cell-time before EndMove.
    #[test]
    fn move_progress_steps_match_per_cell_timeline() {
        // straight 4-cell run, 500ms per cell
        assert_eq!(
            move_progress_steps(&at(0, 1), &at(4, 1), 2000),
            vec![
                (0, at(1, 1)),
                (500, at(2, 1)),
                (1000, at(3, 1)),
                (1500, at(4, 1)),
            ]
        );

        // single-cell diagonal sidestep: one immediate waypoint, like the old code
        assert_eq!(
            move_progress_steps(&at(2, 1), &at(3, 2), 707),
            vec![(0, at(3, 2))]
        );

        // degenerate zero-distance move still yields the destination
        assert_eq!(
            move_progress_steps(&at(2, 1), &at(2, 1), 0),
            vec![(0, at(2, 1))]
        );
    }
}