overlord_event_system/logic/

chapters_management.rs

use crate::{
    entities,
    event::{OverlordEvent, PrepareFightType},
    game_config_helpers::GameConfigLookup,
    logic::handler::OverlordLogic,
    state::OverlordState,
};

use essences::{
    currency::{CurrencyConsumer, CurrencyUnit, check_can_decrease_currencies},
    dungeons::DungeonTemplateId,
    entity::{ActionWithDeadline, Entity, EntityAction, EntityId, EntityState},
    fighting::{
        ActiveDungeon, ActiveFight, EntityTeam, EntityType, FightTemplate, FightTemplateId,
        FightType,
    },
    game::Chapter,
    pvp::PVPState,
};

use analytics::constants::METRICS_TARGET;
use configs::game_config::GameConfig;
use event_system::{event::EventPluginized, script::random::GameRng, system::EventHandleResult};
use rand::Rng;

impl OverlordLogic {
    pub fn is_battle_active(&self, state: &OverlordState) -> bool {
        if let Some(active_fight) = &state.active_fight {
            let has_player = active_fight
                .entities
                .iter()
                .any(|e| e.id == active_fight.player_id);

            let has_enemy = active_fight
                .entities
                .iter()
                .any(|e| e.team == EntityTeam::Enemy);

            has_player && has_enemy
        } else {
            false
        }
    }

    pub fn handle_prepare_fight(
        &mut self,
        prepare_fight_type: PrepareFightType,
        rand_gen: rand::rngs::StdRng,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let game_config = self.game_config.get();

        if state.pvp_state.is_some() {
            return EventHandleResult::fail(state);
        }

        let is_retry_boss_fight = matches!(prepare_fight_type, PrepareFightType::RetryBossFight);

        match prepare_fight_type {
            PrepareFightType::PVEFight => {
                if !self.validate_pve_fight(&state) {
                    return EventHandleResult::fail(state);
                }
            }
            PrepareFightType::PVPFight { .. } => {}
            PrepareFightType::RetryBossFight => {
                if !self.validate_prepare_retry_boss_fight(&state) {
                    return EventHandleResult::fail(state);
                }
            }
            PrepareFightType::DungeonFight {
                dungeon_id,
                difficulty,
            } => {
                if !self.validate_dungeon_fight(&state, dungeon_id, difficulty) {
                    return EventHandleResult::fail(state);
                }
            }
            PrepareFightType::ForfeitDungeonFight => {}
            PrepareFightType::SingleFight { .. } => {}
        };

        // Item TTL: remove expired items here, at the start of the next fight,
        // before its power snapshot is built — so they never drop mid-fight.
        // Snapshot the inventory only when something is removed, so a failed
        // prepare below can roll it back — else it would strip items without
        // emitting ItemsExpired and orphan their DB rows.
        let now = ::time::utc_now();
        let pre_sweep_inventory = state
            .character_state
            .inventory
            .iter()
            .any(|item| item.expires_at.is_some_and(|exp| exp <= now))
            .then(|| state.character_state.inventory.clone());
        let expiry_events = super::items::sweep_expired_items(&mut state, now);

        // The previous fight (if any) is over: drop its pending combat events
        // so the new fight schedules onto a clean clock. The saved clock is
        // restored on every failure exit below, so a failed PrepareFight can't
        // kill the running fight's heartbeat and pending scheduling.
        // The FightProgress heartbeat is re-installed below on success.
        let saved_clock = self.fight_clock.clone();
        self.fight_clock.clear();
        state.active_fight = None;

        let prepare_fight_events = match prepare_fight_type {
            PrepareFightType::PVEFight => self.handle_pve_prepare_fight(&mut state, rand_gen),
            PrepareFightType::ForfeitDungeonFight => {
                self.handle_pve_prepare_fight(&mut state, rand_gen)
            }
            PrepareFightType::PVPFight {
                fight_id,
                pvp_state,
            } => self.handle_pvp_prepare_fight(&mut state, fight_id, pvp_state, rand_gen),
            PrepareFightType::RetryBossFight => {
                match game_config
                    .require_chapter_by_level(state.character_state.character.current_chapter_level)
                {
                    Ok(chapter) => {
                        state.character_state.character.current_fight_number =
                            (chapter.fight_ids.len() - 1) as i64;
                        self.handle_pve_prepare_fight(&mut state, rand_gen)
                    }
                    Err(_) => {
                        tracing::error!(
                            "Failed to get chapter with chapter_level={}",
                            state.character_state.character.current_chapter_level
                        );
                        None
                    }
                }
            }
            PrepareFightType::DungeonFight {
                dungeon_id,
                difficulty,
            } => self.handle_dungeon_prepare_fight(&mut state, dungeon_id, difficulty, rand_gen),
            PrepareFightType::SingleFight { fight_templated_id } => {
                self.handle_single_prepare_fight(&mut state, fight_templated_id, rand_gen)
            }
        };

        let Some(events) = prepare_fight_events else {
            tracing::error!("Preparing fight failed, something went wrong");
            self.fight_clock = saved_clock;
            if let Some(inventory) = pre_sweep_inventory {
                state.character_state.inventory = inventory;
            }
            return EventHandleResult::fail(state);
        };

        if state.active_fight.is_none() {
            tracing::error!("No active fight after preparing fight");
            self.fight_clock = saved_clock;
            if let Some(inventory) = pre_sweep_inventory {
                state.character_state.inventory = inventory;
            }
            return EventHandleResult::fail(state);
        };

        if is_retry_boss_fight {
            // Consume the boss retry only once the prepare succeeded: failure
            // results still apply their state, and a prematurely-set flag
            // makes `validate_prepare_retry_boss_fight` reject every further
            // retry even though the boss fight was never restarted.
            state.character_state.character.last_boss_fight_won = true;
        }

        self.fight_clock.set_heartbeat(
            OverlordEvent::FightProgress {},
            game_config.game_settings.fight_progress_tick,
        );

        // Emit the chapter-start expiry events ahead of the fight's own events.
        let mut events = events;
        events.splice(0..0, expiry_events);

        EventHandleResult::ok_events(state, events)
    }

    fn validate_pve_fight(&self, state: &OverlordState) -> bool {
        if let Some(active_fight) = &state.active_fight
            && !active_fight.fight_ended
            && active_fight.dungeon.is_some()
        {
            tracing::error!("Dungeon fight is in progress");
            return false;
        };

        true
    }

    fn validate_prepare_retry_boss_fight(&self, state: &OverlordState) -> bool {
        let game_config = self.game_config.get();

        // These validation failures are expected in normal client-server
        // async play: the server state has already moved on while the
        // client's cached state is a few state_patches behind. They should
        // log at info, not error — otherwise they bury real bugs in error
        // metrics/alerts during every boss defeat or fight overlap.
        if state.character_state.character.last_boss_fight_won {
            tracing::info!("The last boss fight was won, so we can't try to retry boss fight");
            return false;
        }

        let Some(active_fight) = &state.active_fight else {
            return true;
        };

        if active_fight.dungeon.is_some() {
            tracing::info!("Dungeon fight is in progress");
            return false;
        }

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

        if fight.fight_type == FightType::CampaignBossFight && self.is_battle_active(state) {
            tracing::info!("The current fight is a boss fight, so we can't retry a boss fight");
            return false;
        };

        true
    }

    fn validate_dungeon_fight(
        &self,
        state: &OverlordState,
        dungeon_id: DungeonTemplateId,
        difficulty: i64,
    ) -> bool {
        let game_config = self.game_config.get();

        if *state
            .dungeons
            .completed_difficulties
            .get(&dungeon_id)
            .unwrap_or(&0)
            + 1
            < difficulty
        {
            tracing::error!(
                "Maximum available difficulty is {} ",
                *state
                    .dungeons
                    .completed_difficulties
                    .get(&dungeon_id)
                    .unwrap_or(&0)
                    + 1
            );
            return false;
        }

        let Ok(dungeon) = game_config.require_dungeon_template(dungeon_id) else {
            tracing::error!("Failed to get dungeon_template with id {} ", dungeon_id);
            return false;
        };

        if state.character_state.character.current_chapter_level < dungeon.chapter_level_unlock {
            tracing::error!(
                "Current chapter level is: {}, required is {} ",
                state.character_state.character.current_chapter_level,
                dungeon.chapter_level_unlock
            );
            return false;
        }

        if difficulty > dungeon.max_difficulty_level {
            tracing::error!(
                "Maximum difficulty for dungeon with id: {}, is {} ",
                dungeon_id,
                dungeon.max_difficulty_level
            );
            return false;
        }

        let keys_required = vec![CurrencyUnit {
            currency_id: dungeon.key_currency_id,
            amount: 1,
        }];

        if !check_can_decrease_currencies(&state.character_state.currencies, &keys_required) {
            tracing::error!("Not enough keys for running dungeon: {}", dungeon_id);
            return false;
        }

        true
    }

    fn generate_pve_fight_entities(
        &self,
        entities: &mut Vec<Entity>,
        fight: &FightTemplate,
        state: &mut OverlordState,
        rand_gen: &mut rand::rngs::StdRng,
    ) -> anyhow::Result<(Entity, Option<EntityId>)> {
        let game_config = self.game_config.get();

        fight.fight_entities.iter().for_each(|entity| {
            let created_entity = match entities::create_pve_entity(
                uuid::Builder::from_random_bytes(rand_gen.random()).into_uuid(),
                entity,
                &game_config,
                None,
            ) {
                Ok(entity) => entity,
                Err(err) => {
                    tracing::error!("Failed creating entity {}", err.to_string());
                    return;
                }
            };

            entities.push(created_entity);
        });

        let player = match entities::create_player_entity(
            &state.character_state,
            uuid::Builder::from_random_bytes(rand_gen.random()).into_uuid(),
            &game_config,
        ) {
            Ok(entity) => entity,
            Err(err) => {
                anyhow::bail!("Failed creating player entity {}", err);
            }
        };

        entities.push(player.clone());

        let mut party_player_id = None;
        if let Some(party_state) = &state.party.party_state {
            match entities::create_party_entity(
                party_state,
                uuid::Builder::from_random_bytes(rand_gen.random()).into_uuid(),
                &game_config,
            ) {
                Ok(party_ally) => {
                    party_player_id = Some(party_ally.id);
                    entities.push(party_ally);
                }
                Err(err) => {
                    tracing::error!("Failed creating party ally entity {}", err);
                }
            }
        }

        Ok((player, party_player_id))
    }

    fn generate_pvp_fight_entities(
        &self,
        entities: &mut Vec<Entity>,
        fight: &FightTemplate,
        pvp_state: &PVPState,
        state: &mut OverlordState,
        rand_gen: &mut rand::rngs::StdRng,
    ) -> anyhow::Result<(Entity, Option<EntityId>)> {
        let game_config = self.game_config.get();

        fight.fight_entities.iter().for_each(|entity| {
            let created_entity = match entity.entity_type {
                EntityType::PVEEntity {
                    entity_template_id: _,
                } => {
                    match entities::create_pve_entity(
                        uuid::Builder::from_random_bytes(rand_gen.random()).into_uuid(),
                        entity,
                        &game_config,
                        None,
                    ) {
                        Ok(entity) => entity,
                        Err(err) => {
                            tracing::error!("{}", err.to_string());
                            return;
                        }
                    }
                }
                EntityType::PVPEntity => {
                    match entities::create_pvp_entity(
                        &EntityState::Opponent(&pvp_state.opponent_state),
                        entity,
                        &game_config,
                    ) {
                        Ok(entity) => entity,
                        Err(err) => {
                            tracing::error!("{}", err.to_string());
                            return;
                        }
                    }
                }
            };

            entities.push(created_entity);
        });

        let player = match entities::create_player_entity(
            &state.character_state,
            uuid::Builder::from_random_bytes(rand_gen.random()).into_uuid(),
            &game_config,
        ) {
            Ok(entity) => entity,
            Err(err) => {
                anyhow::bail!("Failed creating player entity {}", err);
            }
        };

        entities.push(player.clone());

        // No party ally in PvP — arena is strictly 1v1
        let party_player_id = None;

        Ok((player, party_player_id))
    }

    fn run_prepare_fight_script(
        &self,
        events: &mut Vec<EventPluginized<OverlordEvent, OverlordState>>,
        fight: &FightTemplate,
        active_fight: &ActiveFight,
        state: &mut OverlordState,
        rand_gen: rand::rngs::StdRng,
    ) -> anyhow::Result<()> {
        let game_config = self.game_config.get();
        let current_chapter = state.character_state.character.current_chapter_level;

        // Native `prepare_fight` interpreter: spawn the initial wave from the
        // typed `prepare_fight_waves` config (the native data source), replacing
        // migrated next-wave path in `logic::fighting`.
        //
        // `base_power` was a literal argument of the legacy `spawn_wave(...)`
        // script, transpiled at deploy time from the template's TOP-LEVEL
        // `power` field (`$.power`). The earlier port passed
        // `wave_data.power` — the waves-blob's inner `power`, an unrelated
        // value that runs 4-26x larger on live campaign templates — which
        // inflated every campaign mob's hp/attack by 2-5x vs the legacy
        // engine. Pass the template's own `power`, like the scripts did.
        // Templates that spawn their enemies directly via `fight_entities` carry
        // optional extra wave-spawn step, not a requirement). Treat an absent
        // wave config as "nothing to spawn here" instead of an error — the
        // initial entities are already built by `generate_pve_fight_entities`.
        let Some(waves_cfg) = fight.prepare_fight_waves.as_ref() else {
            return Ok(());
        };

        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);
        if let Err(err) = crate::mechanics::fight::spawn_wave(
            &mut sink,
            &rng,
            &game_config,
            self.behaviors.lookups(),
            active_fight,
            &wave_data,
            fight.power.map(|p| p as f64).unwrap_or(0.0),
            current_chapter,
            &fight_type_str,
        ) {
            anyhow::bail!("Prepare fight wave spawn failed with error: {err:?}");
        }

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

        Ok(())
    }

    /// Schedule `StartFight` for a freshly prepared fight, honoring the
    /// template's start delay override.
    fn schedule_start_fight(
        &mut self,
        fight: &FightTemplate,
        fight_id: uuid::Uuid,
        game_config: &GameConfig,
    ) {
        let start_fight_delay = fight
            .start_fight_delay_ticks
            .unwrap_or(game_config.fight_settings.start_fight_delay_ticks_default);

        self.fight_clock
            .schedule(OverlordEvent::StartFight { fight_id }, start_fight_delay);
    }

    fn handle_pve_prepare_fight(
        &mut self,
        state: &mut OverlordState,
        mut rand_gen: rand::rngs::StdRng,
    ) -> Option<Vec<EventPluginized<OverlordEvent, OverlordState>>> {
        let game_config = self.game_config.get();

        let mut events = vec![];
        let Ok(chapter) = game_config
            .require_chapter_by_level(state.character_state.character.current_chapter_level)
        else {
            tracing::error!(
                "Failed to get chapter with chapter_level={}",
                state.character_state.character.current_chapter_level
            );
            return None;
        };

        let Some(fight_id) = chapter
            .fight_ids
            .get(state.character_state.character.current_fight_number as usize)
            .cloned()
        else {
            tracing::error!(
                "Failed to get fight {} for chapter_level={}",
                state.character_state.character.current_fight_number,
                state.character_state.character.current_chapter_level
            );
            return None;
        };

        let Ok(fight) = game_config.require_fight_template(fight_id) else {
            tracing::error!("Failed to get fight_template with id {} ", fight_id,);
            return None;
        };

        let mut entities = vec![];

        let (player, party_player_id) =
            match self.generate_pve_fight_entities(&mut entities, fight, state, &mut rand_gen) {
                Ok(result) => result,
                Err(err) => {
                    tracing::error!("Got error, while creating PVE entities: {}", err);
                    return None;
                }
            };

        let (pet_combat_state, leader_pet_template_id) = self.build_pet_combat_state(state);

        let active_fight = ActiveFight {
            id: uuid::Builder::from_random_bytes(rand_gen.random()).into_uuid(),
            fight_id,
            current_wave: 1,
            player_id: player.id,
            party_player_id,
            entities,
            max_duration_ticks: fight.max_duration_ticks,
            fight_stopped: false,
            fight_ended: false,
            dungeon: None,
            paused: false,
            pet_combat_state,
            leader_pet_template_id,
        };

        state.active_fight = Some(active_fight.clone());

        if let Err(err) =
            self.run_prepare_fight_script(&mut events, fight, &active_fight, state, rand_gen)
        {
            tracing::error!("Error running pve prepare_fight script: {err:?}");
            return None;
        }

        self.schedule_start_fight(fight, active_fight.id, &game_config);

        tracing::debug!(
            "Starting chapter_level={}, fight_number={}, fight_id={}",
            chapter.level,
            state.character_state.character.current_fight_number,
            fight_id,
        );

        Some(events)
    }

    fn handle_pvp_prepare_fight(
        &mut self,
        state: &mut OverlordState,
        fight_id: FightTemplateId,
        pvp_state: Box<PVPState>,
        mut rand_gen: rand::rngs::StdRng,
    ) -> Option<Vec<EventPluginized<OverlordEvent, OverlordState>>> {
        let game_config = self.game_config.get();
        // Applied to the state only after the fight is successfully built:
        // failure results still apply their state, and a half-set `pvp_state`
        // would make `handle_prepare_fight`'s entry guard reject every
        // subsequent PrepareFight for the session.
        let prepared_pvp_state = *pvp_state.clone();

        let mut events = vec![];

        let Ok(fight) = game_config.require_fight_template(fight_id) else {
            tracing::error!("Failed to get fight_template with id {} ", fight_id);
            return None;
        };

        let mut entities = vec![];

        let (player, party_player_id) = match self.generate_pvp_fight_entities(
            &mut entities,
            fight,
            &pvp_state,
            state,
            &mut rand_gen,
        ) {
            Ok(result) => result,
            Err(err) => {
                tracing::error!("Got error, while creating PVP entities: {}", err);
                return None;
            }
        };

        let (pet_combat_state, leader_pet_template_id) = self.build_pet_combat_state(state);

        let active_fight = ActiveFight {
            id: uuid::Builder::from_random_bytes(rand_gen.random()).into_uuid(),
            fight_id,
            current_wave: 1,
            player_id: player.id,
            party_player_id,
            entities,
            max_duration_ticks: fight.max_duration_ticks,
            fight_stopped: false,
            fight_ended: false,
            dungeon: None,
            paused: false,
            pet_combat_state,
            leader_pet_template_id,
        };

        state.active_fight = Some(active_fight.clone());

        if let Err(err) =
            self.run_prepare_fight_script(&mut events, fight, &active_fight, state, rand_gen)
        {
            tracing::error!("Error running pvp prepare_fight script: {err:?}");
            return None;
        }

        state.pvp_state = Some(prepared_pvp_state);

        self.schedule_start_fight(fight, active_fight.id, &game_config);

        Some(events)
    }

    fn handle_dungeon_prepare_fight(
        &mut self,
        state: &mut OverlordState,
        dungeon_id: DungeonTemplateId,
        difficulty: i64,
        mut rand_gen: rand::rngs::StdRng,
    ) -> Option<Vec<EventPluginized<OverlordEvent, OverlordState>>> {
        let game_config = self.game_config.get();

        let Ok(dungeon) = game_config.require_dungeon_template(dungeon_id) else {
            tracing::error!("Failed to get dungeon_template with id {} ", dungeon_id);
            return None;
        };

        let Some(fight_template_id) = dungeon.fight_template_ids.get((difficulty - 1) as usize)
        else {
            tracing::error!(
                "Failed to get fight_template from dungeon with id {}, for difficulty: {}",
                dungeon_id,
                difficulty
            );
            return None;
        };

        let Ok(fight) = game_config.require_fight_template(*fight_template_id) else {
            tracing::error!(
                "Failed to get fight_template with id {} ",
                fight_template_id
            );
            return None;
        };

        let mut events = vec![];

        let mut entities = vec![];

        let (player, party_player_id) =
            match self.generate_pve_fight_entities(&mut entities, fight, state, &mut rand_gen) {
                Ok(result) => result,
                Err(err) => {
                    tracing::error!("Got error, while creating entities: {}", err);
                    return None;
                }
            };

        let (pet_combat_state, leader_pet_template_id) = self.build_pet_combat_state(state);

        let active_fight = ActiveFight {
            id: uuid::Builder::from_random_bytes(rand_gen.random()).into_uuid(),
            fight_id: *fight_template_id,
            current_wave: 1,
            player_id: player.id,
            party_player_id,
            entities,
            max_duration_ticks: fight.max_duration_ticks,
            fight_stopped: false,
            fight_ended: false,
            dungeon: Some(ActiveDungeon {
                id: dungeon_id,
                difficulty,
            }),
            paused: false,
            pet_combat_state,
            leader_pet_template_id,
        };

        state.active_fight = Some(active_fight.clone());

        if let Err(err) =
            self.run_prepare_fight_script(&mut events, fight, &active_fight, state, rand_gen)
        {
            tracing::error!("Error running pvp prepare_fight script: {err:?}");
            return None;
        }

        self.schedule_start_fight(fight, active_fight.id, &game_config);

        Some(events)
    }

    fn handle_single_prepare_fight(
        &mut self,
        state: &mut OverlordState,
        fight_template_id: FightTemplateId,
        mut rand_gen: rand::rngs::StdRng,
    ) -> Option<Vec<EventPluginized<OverlordEvent, OverlordState>>> {
        let game_config = self.game_config.get();

        let Ok(fight) = game_config.require_fight_template(fight_template_id) else {
            tracing::error!(
                "Failed to get fight_template with id {} ",
                fight_template_id
            );
            return None;
        };

        let mut events = vec![];

        let mut entities = vec![];

        let (player, party_player_id) =
            match self.generate_pve_fight_entities(&mut entities, fight, state, &mut rand_gen) {
                Ok(result) => result,
                Err(err) => {
                    tracing::error!("Got error, while creating entities: {}", err);
                    return None;
                }
            };

        let (pet_combat_state, leader_pet_template_id) = self.build_pet_combat_state(state);

        let active_fight = ActiveFight {
            id: uuid::Builder::from_random_bytes(rand_gen.random()).into_uuid(),
            fight_id: fight_template_id,
            current_wave: 1,
            player_id: player.id,
            party_player_id,
            entities,
            max_duration_ticks: fight.max_duration_ticks,
            fight_stopped: false,
            paused: false,
            fight_ended: false,
            dungeon: None,
            pet_combat_state,
            leader_pet_template_id,
        };

        state.active_fight = Some(active_fight.clone());

        if let Err(err) =
            self.run_prepare_fight_script(&mut events, fight, &active_fight, state, rand_gen)
        {
            tracing::error!("Error running single prepare_fight script: {err:?}");
            return None;
        }

        self.schedule_start_fight(fight, active_fight.id, &game_config);

        Some(events)
    }

    pub fn handle_start_fight(
        &mut self,
        event: OverlordEvent,
        fight_id: uuid::Uuid,
        // The native `fight_start` fns are RNG-free (init_fight + optional static
        _rand_gen: rand::rngs::StdRng,
        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!("No active fight for start_fight");
            return EventHandleResult::fail(state);
        };

        if active_fight.id != fight_id {
            tracing::error!(
                "StartFight fight_id mismatch: expected {}, got {}",
                active_fight.id,
                fight_id
            );
            return EventHandleResult::fail(state);
        }

        let Ok(fight_template) = game_config.require_fight_template(active_fight.fight_id) else {
            tracing::error!("No fight template with fight_id: {}", active_fight.fight_id);
            return EventHandleResult::fail(state);
        };

        self.start_fight_tick = current_tick;

        let mut events = vec![];

        active_fight.entities.iter_mut().for_each(|e| {
            e.abilities.iter_mut().for_each(|ability| {
                e.actions_queue.push(&ActionWithDeadline {
                    action: self.make_start_cast_ability_action(e.id, ability.ability.template_id),
                    deadline_tick: current_tick,
                })
            })
        });

        // Emit StartCastAbility for support pets' passive abilities at fight start
        let player_id = active_fight.player_id;
        for pet in state.character_state.equipped_pets.supports() {
            if let Some(ability_template) = pet
                .passive_ability_id
                .and_then(|id| game_config.ability_template(id))
            {
                let passive_ability =
                    essences::abilities::Ability::from_template(ability_template, None, None);
                let passive_ability_id = passive_ability.template_id;

                // Add passive as a one-shot ability on the player entity
                if let Some(player_entity) =
                    active_fight.entities.iter_mut().find(|e| e.id == player_id)
                {
                    player_entity
                        .abilities
                        .push(essences::abilities::ActiveAbility {
                            ability: passive_ability,
                            deadline: None,
                            slot_id: None,
                        });
                    player_entity.actions_queue.push(&ActionWithDeadline {
                        action: EntityAction::StartCastAbility {
                            ability_id: passive_ability_id,
                            by_entity_id: player_id,
                            pet_id: Some(pet.template_id),
                        },
                        deadline_tick: current_tick,
                    });
                }
            }
        }

        active_fight.max_duration_ticks = fight_template.max_duration_ticks;

        let active_fight_for_native = active_fight.clone();
        let start_behavior = fight_template.start_behavior.clone();
        // scope; the native `fight_start` fns read it from `Fight`/`State`, so
        // the StartFight event itself is no longer an input.
        let _ = event;

        // Native `fight_start` port: look up the named fn on the registry and
        // drive it with `FightStartCtx`. Falls back to no events when no native
        // ref / fn is present.
        let Some(native_name) = start_behavior.as_deref() else {
            tracing::error!("Fight template {} has no start_behavior", fight_template.id);
            return EventHandleResult::fail(state);
        };
        let Some(native_fn) = self.behaviors.fight_start_fn(native_name) else {
            tracing::error!("No registered fight_start native fn named {native_name}");
            return EventHandleResult::fail(state);
        };
        match native_fn(&crate::behaviors::combat::fight_start::FightStartCtx {
            fight: &active_fight_for_native,
            state: &state,
            lookups: self.behaviors.lookups(),
        }) {
            Ok(start_fight_events) => {
                events.append(
                    &mut start_fight_events
                        .into_iter()
                        .map(EventPluginized::now)
                        .collect(),
                );
            }
            Err(err) => {
                tracing::error!("Start fight native fn failed with error: {err:?}");
                return EventHandleResult::fail(state);
            }
        };

        EventHandleResult::ok_events(state, events)
    }

    pub fn get_prepare_fight_delay(
        &self,
        is_win: bool,
        chapter: &Chapter,
        state: &OverlordState,
    ) -> u64 {
        let game_config = self.game_config.get();

        let Some(fight_id) = chapter
            .fight_ids
            .get(state.character_state.character.current_fight_number as usize)
            .cloned()
        else {
            tracing::error!(
                "Failed to get fight {} for chapter_level={}",
                state.character_state.character.current_fight_number,
                state.character_state.character.current_chapter_level
            );
            return 0;
        };

        let Ok(fight) = game_config.require_fight_template(fight_id) else {
            tracing::error!("Failed to get fight_template with id {} ", fight_id,);
            return 0;
        };

        if is_win {
            fight.prepare_fight_win_duration_ticks.unwrap_or(
                game_config
                    .fight_settings
                    .prepare_fight_win_delay_ticks_default,
            )
        } else {
            fight.prepare_fight_lose_duration_ticks.unwrap_or(
                game_config
                    .fight_settings
                    .prepare_fight_lose_delay_ticks_default,
            )
        }
    }

    pub fn get_end_fight_delay(&self, fight_id: FightTemplateId) -> u64 {
        let game_config = self.game_config.get();

        let Ok(fight) = game_config.require_fight_template(fight_id) else {
            tracing::error!("Failed to get fight_template with id {} ", fight_id,);
            return 0;
        };

        fight
            .end_fight_delay_ticks
            .unwrap_or(game_config.fight_settings.end_fight_delay_ticks_default)
    }

    /// Shared end-of-fight tail: keep the loop going by scheduling the next
    /// PrepareFight, or stop fighting when the template says so.
    /// If (is_win && stop_on_win) or (!is_win && stop_on_lose) - we stop fighting
    fn continue_or_stop_fight_loop(
        &mut self,
        state: &mut OverlordState,
        events: &mut Vec<EventPluginized<OverlordEvent, OverlordState>>,
        current_fight: &FightTemplate,
        is_win: bool,
        prepare_fight_delay_ticks: u64,
    ) {
        if (!is_win || !current_fight.stop_on_win) && (is_win || !current_fight.stop_on_lose) {
            events.push(EventPluginized::now(
                OverlordEvent::RefreshPartyMemberState {},
            ));
            self.fight_clock.schedule(
                OverlordEvent::PrepareFight {
                    prepare_fight_type: PrepareFightType::PVEFight,
                },
                prepare_fight_delay_ticks,
            );
        } else if let Some(fight) = state.active_fight.as_mut() {
            fight.fight_stopped = true;
        }
    }

    fn end_pvp_fight(
        &mut self,
        is_win: bool,
        pvp_state: &PVPState,
        prepare_fight_delay_ticks: u64,
        current_fight: &FightTemplate,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let mut events = vec![];
        if let Some(vassal) = &pvp_state.vassal {
            if is_win {
                state.character_state.vassals.push(vassal.clone());
                if let Some(bundle_id) = current_fight.bundle_reward_id {
                    events.push(EventPluginized::now(OverlordEvent::AddBundleGroup {
                        bundle_ids: vec![bundle_id],
                        source: essences::currency::CurrencySource::PvpVassalReward,
                    }));
                }
            } else {
                tracing::error!("Expected to add vassal, but PVP is lost");
            }
        }

        if let Some(rating_change) = &pvp_state.rating_change {
            if is_win {
                state.character_state.character.arena_rating +=
                    rating_change.winner_rating_increase;
            } else {
                state.character_state.character.arena_rating += rating_change.loser_rating_decrease;
            }
        }

        state.pvp_state = None;

        self.continue_or_stop_fight_loop(
            &mut state,
            &mut events,
            current_fight,
            is_win,
            prepare_fight_delay_ticks,
        );

        EventHandleResult::ok_events(state, events)
    }

    fn end_pve_fight(
        &mut self,
        is_win: bool,
        current_chapter: &Chapter,
        prepare_fight_delay_ticks: u64,
        current_fight: &FightTemplate,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let game_config = self.game_config.get();

        let mut events = vec![];

        let prev_chapter_level = state.character_state.character.current_chapter_level;
        let mut next_chapter_level = prev_chapter_level;
        let mut next_fight_number = state.character_state.character.current_fight_number + 1;

        if is_win {
            if next_fight_number >= current_chapter.fight_ids.len() as i64 {
                next_fight_number = 0;
                if game_config
                    .chapter_by_level(next_chapter_level + 1)
                    .is_some()
                {
                    state.character_state.character.last_boss_fight_won = true;
                    next_chapter_level += 1;
                }
            } else {
                let next_fight_id = &current_chapter.fight_ids[next_fight_number as usize];

                let Ok(next_fight) = game_config.require_fight_template(*next_fight_id) else {
                    tracing::error!(
                        "Failed to get next fight_template with id={}",
                        next_fight_id
                    );
                    return EventHandleResult::fail(state);
                };

                // Uncomment to restore the old behavior where losing the boss
                // gates auto-progression wave -> boss until a RetryBossFight event.
                // if !state.character_state.character.last_boss_fight_won
                //     && next_fight.fight_type == FightType::CampaignBossFight
                // {
                //     next_fight_number = 0;
                // }
                let _ = next_fight;
            }

            state.character_state.character.current_chapter_level = next_chapter_level;
            state.character_state.character.current_fight_number = next_fight_number;

            if self.should_reset_afk_timer_on_gating_unlock(prev_chapter_level, &state) {
                events.push(EventPluginized::now(
                    OverlordEvent::AfkRewardsGatingUnlocked {},
                ));
            }

            if !state.character_state.character.rate_us_shown
                && let Some(threshold) = game_config.game_settings.rate_us_chapter
                && prev_chapter_level < threshold
                && next_chapter_level >= threshold
            {
                events.push(EventPluginized::now(OverlordEvent::ShowRateUs {}));
                tracing::info!(
                    target: METRICS_TARGET,
                    event_type = "show_rate_us",
                    character_id = %state.character_state.character.id,
                    chapter_level = next_chapter_level,
                    trigger = "chapter_advance",
                    "Show rate us",
                );
            }

            if let Some(bundle_id) = current_fight.bundle_reward_id {
                events.push(EventPluginized::now(OverlordEvent::AddBundleGroup {
                    bundle_ids: vec![bundle_id],
                    source: essences::currency::CurrencySource::ChapterReward,
                }));
            }
        } else {
            if current_fight.fight_type == FightType::CampaignBossFight {
                state.character_state.character.last_boss_fight_won = false;
            }

            next_fight_number = 0;
            state.character_state.character.current_fight_number = next_fight_number;
        }

        self.continue_or_stop_fight_loop(
            &mut state,
            &mut events,
            current_fight,
            is_win,
            prepare_fight_delay_ticks,
        );

        EventHandleResult::ok_events(state, events)
    }

    fn end_dungeon_fight(
        &mut self,
        is_win: bool,
        prepare_fight_delay_ticks: u64,
        active_dungeon: &ActiveDungeon,
        current_fight: &FightTemplate,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let game_config = self.game_config.get();

        let Ok(dungeon) = game_config.require_dungeon_template(active_dungeon.id) else {
            tracing::error!(
                "Failed to get dungeon_template with id {} ",
                active_dungeon.id
            );
            return EventHandleResult::fail(state);
        };

        let mut events = vec![];

        if is_win {
            let keys_price = vec![CurrencyUnit {
                currency_id: dungeon.key_currency_id,
                amount: 1,
            }];

            let Some(currency_event) =
                Self::currency_decrease(&state, &keys_price, CurrencyConsumer::DungeonFightEnd)
            else {
                return EventHandleResult::fail(state);
            };
            events.push(currency_event);

            if let Some(bundle_id) = current_fight.bundle_reward_id {
                events.push(EventPluginized::now(OverlordEvent::AddBundleGroup {
                    bundle_ids: vec![bundle_id],
                    source: essences::currency::CurrencySource::DungeonReward,
                }));
            }

            state
                .dungeons
                .completed_difficulties
                .entry(dungeon.id)
                .and_modify(|v| {
                    if active_dungeon.difficulty > *v {
                        *v = active_dungeon.difficulty;
                    }
                })
                .or_insert(active_dungeon.difficulty);
        }

        self.continue_or_stop_fight_loop(
            &mut state,
            &mut events,
            current_fight,
            is_win,
            prepare_fight_delay_ticks,
        );

        EventHandleResult::ok_events(state, events)
    }

    /// Pure predicate: is the chapter transition crossing the AFK rewards unlock
    /// threshold *and* is the elapsed time since the last claim shorter than
    /// `min_required_time_sec`? Callers use this to decide whether to emit
    /// `AfkRewardsGatingUnlocked`; the async handler for that event owns the
    /// actual state mutation.
    pub(crate) fn should_reset_afk_timer_on_gating_unlock(
        &self,
        prev_chapter_level: i64,
        state: &OverlordState,
    ) -> bool {
        let game_config = self.game_config.get();
        let unlock_chapter = game_config.gatings.afk_rewards_button_unlock_chapter;
        let new_chapter_level = state.character_state.character.current_chapter_level;

        if prev_chapter_level >= unlock_chapter || new_chapter_level < unlock_chapter {
            return false;
        }

        let min_required_time_sec = game_config.afk_rewards_settings.min_required_time_sec as i64;
        let elapsed = ::time::utc_now()
            .signed_duration_since(state.character_state.character.last_afk_reward_claimed_at)
            .num_seconds();

        elapsed < min_required_time_sec
    }

    pub fn handle_afk_rewards_gating_unlocked(
        &self,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let min_required_time_sec = self
            .game_config
            .get()
            .afk_rewards_settings
            .min_required_time_sec as i64;
        state.character_state.character.last_afk_reward_claimed_at =
            ::time::utc_now() - chrono::Duration::seconds(min_required_time_sec);
        EventHandleResult::ok(state)
    }

    pub fn handle_end_fight(
        &mut self,
        fight_id: uuid::Uuid,
        is_win: bool,
        pvp_state: Option<&PVPState>,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let game_config = self.game_config.get();

        let Some(active_fight) = &mut state.active_fight else {
            tracing::error!("No active fight for end_fight");
            return EventHandleResult::fail(state);
        };

        if active_fight.id != fight_id {
            tracing::error!(
                "EndFight fight_id mismatch: expected {}, got {}",
                active_fight.id,
                fight_id
            );
            return EventHandleResult::fail(state);
        }

        if self.ended_fight_id == Some(fight_id) {
            // A duplicate EndFight for the same fight is an expected race:
            // the max-duration timeout and an in-flight combat event (e.g. a
            // projectile killing the last entity) can each schedule one. The
            // end-of-fight pipeline (PvP rating, vassal, reward bundles,
            // chapter advance) must run exactly once per fight. (The
            // `fight_ended` flag can't be the guard here: producers set it
            // before scheduling the EndFight event.)
            tracing::info!("Fight {fight_id} already ended, ignoring duplicate EndFight");
            return EventHandleResult::fail(state);
        }

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

        active_fight.fight_ended = true;
        self.ended_fight_id = Some(fight_id);

        if current_fight.fight_type == FightType::SingleFight {
            self.fight_clock.schedule(
                OverlordEvent::PrepareFight {
                    prepare_fight_type: PrepareFightType::PVEFight,
                },
                game_config
                    .fight_settings
                    .prepare_fight_win_delay_ticks_default,
            );
            return EventHandleResult::ok_events(
                state,
                vec![EventPluginized::now(
                    OverlordEvent::RefreshPartyMemberState {},
                )],
            );
        }

        let active_fight = active_fight.clone();

        let Ok(current_chapter) = game_config
            .require_chapter_by_level(state.character_state.character.current_chapter_level)
            .cloned()
        else {
            tracing::error!(
                "Failed to get chapter with chapter_level={}",
                state.character_state.character.current_chapter_level
            );
            return EventHandleResult::fail(state);
        };

        let prepare_fight_delay_ticks =
            self.get_prepare_fight_delay(is_win, &current_chapter, &state);

        if let Some(pvp_state) = pvp_state {
            return self.end_pvp_fight(
                is_win,
                pvp_state,
                prepare_fight_delay_ticks,
                current_fight,
                state,
            );
        }

        if let Some(active_dungeon) = &active_fight.dungeon {
            return self.end_dungeon_fight(
                is_win,
                prepare_fight_delay_ticks,
                active_dungeon,
                current_fight,
                state,
            );
        }

        self.end_pve_fight(
            is_win,
            &current_chapter,
            prepare_fight_delay_ticks,
            current_fight,
            state,
        )
    }
}