overlord_event_system/async_handler/

fighting.rs

use crate::{
    TICKER_UNIT_DURATION_MS,
    async_handler::handler::OverlordAsyncEventHandler,
    entities::{create_pve_entity, event_from_entity_action},
    event::{
        OverlordEvent, OverlordEventCastAbility, OverlordEventCastProjectile,
        OverlordEventStartCastAbility, OverlordEventStartCastProjectile,
    },
    game_config_helpers::GameConfigLookup,
    script::{CustomEventData, StartCastAbilityResult},
    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, EventRhaiEnum, EventStruct},
    script::runner::ScriptRandom,
    system::EventHandleResult,
};

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

impl OverlordAsyncEventHandler {
    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(
        &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 mut events = Vec::new();

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

        entity.being_moved = true;
        entity.coordinates = to.clone();

        events.push(EventPluginized::delayed(
            OverlordEvent::EndMove { entity_id },
            duration_ticks,
        ));

        EventHandleResult::ok_events(state, events)
    }

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

        entity.being_moved = false;

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

    pub fn handle_entity_incr_attribute(
        &mut self,
        entity_id: Uuid,
        attribute: &str,
        delta: i64,
        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(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);
        };

        entity.attributes.add(attribute, delta);

        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 state_cloned = state.clone();

        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 enttiy_cloned = entity.clone();

        match self.script_runner.run_event(
            |mut scope_setter| {
                scope_setter.set_const("Entity", enttiy_cloned);
                if let Some(caller_event) = caller_event {
                    caller_event.add_event_to_scope(&mut scope_setter, "Event");
                }
                scope_setter.set_const("Random", ScriptRandom::new(rand_gen));
                scope_setter.set_const("Fight", active_fight_cloned);
                scope_setter.set_const("FightDurationTicks", current_tick - self.start_fight_tick);
                scope_setter
            },
            &state_cloned,
            &effect.script,
        ) {
            Ok(events) => {
                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(),
                )
            }
            Err(err) => {
                tracing::error!("Effect script failed with error: {err:?}");
                EventHandleResult::fail(state)
            }
        }
    }

    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 results = match self.script_runner.run_start_cast_ability(
            |mut scope_setter| {
                scope_setter.set_event(OverlordEventStartCastAbility::from_enum(event));
                scope_setter.set_const("CasterEntity", casted_by_entity_cloned);
                scope_setter.set_const("Fight", active_fight_cloned);
                scope_setter.set_const("Random", ScriptRandom::new(rand_gen));
                scope_setter.set_const("AbilityLevel", ability_level);
                scope_setter.set_const("AbilitySlotLevel", ability_slot_level);
                scope_setter
            },
            state_cloned,
            &ability_template.start_script,
        ) {
            Ok(v) => v,
            Err(err) => {
                if let Some(e) = state
                    .active_fight
                    .as_mut()
                    .and_then(|af| af.entities.iter_mut().find(|e| e.id == by_entity_id))
                {
                    e.actions_queue.push(&ActionWithDeadline {
                        action: self
                            .make_start_cast_ability_action(by_entity_id, ability_template_id),
                        deadline_tick: current_tick + ability_cooldown,
                    });
                }

                tracing::error!("Ability start cast script failed with error: {err:?}");
                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(e) => {
                    tracing::error!(
                        "Error converting StartCastAbilityResultVec = {:?} into EntityActionVec = {:?}",
                        results,
                        e
                    );
                    return EventHandleResult::fail(state);
                }
            };

        casted_by_entity
            .actions_queue
            .append_start_cast_ability_result_actions(
                &actions,
                current_tick,
                ability_template_id,
                ability_cooldown,
            );
        if casted_by_entity.id == active_fight.player_id && !actions.is_empty() {
            active_ability.deadline = Some(
                ::time::utc_now()
                    + chrono::TimeDelta::milliseconds(
                        (ability_cooldown as u128 * TICKER_UNIT_DURATION_MS) as i64,
                    ),
            );
        }

        EventHandleResult::ok_events(state, events)
    }

    #[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);
        };

        match self.script_runner.run_event(
            |mut scope_setter| {
                scope_setter.set_event(OverlordEventCastAbility::from_enum(event));
                scope_setter.set_const("CasterEntity", casted_by_entity.clone());
                scope_setter.set_const("Fight", active_fight_clone);
                scope_setter.set_const("TargetEntity", target_entity);
                scope_setter.set_const("Random", ScriptRandom::new(rand_gen));
                scope_setter.set_const("AbilityLevel", ability.level);
                scope_setter.set_const("AbilitySlotLevel", ability_slot_level);
                scope_setter.set_const("FightDurationTicks", current_tick - self.start_fight_tick);
                scope_setter
            },
            &state_cloned,
            &ability_template.script,
        ) {
            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);
                    }
                }

                EventHandleResult::ok_events(
                    state,
                    events
                        .into_iter()
                        .map(|x| {
                            if let OverlordEvent::StartCastProjectile { delay, .. } = x {
                                EventPluginized::delayed(x, delay.max(1))
                            } else {
                                EventPluginized::now(x)
                            }
                        })
                        .collect(),
                )
            }
            Err(err) => {
                tracing::error!("Ability cast script failed with error: {err:?}");
                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 result = match self.script_runner.run_start_cast_projectile(
            |mut scope_setter| {
                scope_setter.set_event(OverlordEventStartCastProjectile::from_enum(event));
                scope_setter.set_const("CasterEntity", casted_by_entity.clone());
                scope_setter.set_const("Fight", active_fight_clone);
                scope_setter.set_const("TargetEntity", target_entity.clone());
                scope_setter.set_const("ProjectileLevel", level);
                scope_setter.set_const("FightDurationTicks", current_tick - self.start_fight_tick);
                scope_setter
            },
            &projectile.start_script,
        ) {
            Ok(v) => v,
            Err(err) => {
                tracing::error!("Projectile start cast script failed with error: {err:?}");
                return EventHandleResult::fail(state);
            }
        };

        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,
                }),
                EventPluginized::delayed(
                    OverlordEvent::CastProjectile {
                        by_entity_id,
                        to_entity_id,
                        projectile_id,
                        level,
                        projectile_data: result.projectile_data,
                    },
                    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);
        };

        match self.script_runner.run_event(
            |mut scope_setter| {
                scope_setter.set_event(OverlordEventCastProjectile::from_enum(event));
                scope_setter.set_const("Random", ScriptRandom::new(rand_gen));
                scope_setter.set_const("CasterEntity", casted_by_entity.clone());
                scope_setter.set_const("Fight", active_fight.clone());
                scope_setter.set_const("TargetEntity", target_entity);
                scope_setter.set_const("ProjectileLevel", level);
                scope_setter.set_const("CustomEventData", projectile_data.clone());
                scope_setter.set_const("FightDurationTicks", current_tick - self.start_fight_tick);
                scope_setter
            },
            &state,
            &projectile.script,
        ) {
            Ok(events) => EventHandleResult::ok_events(
                state,
                events
                    .into_iter()
                    .map(|x| {
                        if let OverlordEvent::StartCastProjectile { delay, .. } = x {
                            EventPluginized::delayed(x, delay.max(1))
                        } else {
                            EventPluginized::now(x)
                        }
                    })
                    .collect(),
            ),
            Err(err) => {
                tracing::error!("Projectile cast script failed with error: {err:?}");
                EventHandleResult::fail(state)
            }
        }
    }

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

        let mut events = Vec::new();

        active_fight.entities = Vec::new();

        let fight_uuid = active_fight.id;
        active_fight.fight_ended = true;

        events.push(EventPluginized::delayed(
            OverlordEvent::EndFight {
                fight_id: fight_uuid,
                is_win: false,
                pvp_state: state.pvp_state.clone(),
            },
            self.get_end_fight_delay(active_fight.fight_id),
        ));

        EventHandleResult::ok_events(state, events)
    }

    pub fn handle_entity_death(
        &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);
        };

        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;
                events.reserve(2);
                events.push(EventPluginized::delayed(
                    OverlordEvent::EndFight {
                        fight_id: fight_uuid,
                        is_win: true,
                        pvp_state: state.pvp_state.clone(),
                    },
                    self.get_end_fight_delay(active_fight.fight_id),
                ));
                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;
                let prepare_fight_events = match self.script_runner.run_event(
                    |mut scope_setter| {
                        scope_setter.set_const("Random", ScriptRandom::new(rand_gen));
                        scope_setter.set_const("Fight", active_fight_cloned);
                        scope_setter.set_const("CurrentChapter", current_chapter);
                        scope_setter
                    },
                    &state,
                    &fight.prepare_fight_script,
                ) {
                    Ok(events) => events,
                    Err(err) => {
                        tracing::error!(
                            "Prepare wave script 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(),
                        }));
                        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(),
                    }));
                    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(),
                    }));
                    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 pet only when the player is involved in the damage
        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 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() {
                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 amount = 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
                            };
                            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(
        &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();
            return EventHandleResult::ok_events(
                state,
                vec![EventPluginized::delayed(
                    OverlordEvent::EndFight {
                        fight_id: fight_uuid,
                        is_win: false,
                        pvp_state,
                    },
                    end_fight_delay,
                )],
            );
        }

        let mut events = vec![];

        for entity in &mut active_fight.entities {
            if !entity.being_moved
                && 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)
    }
}