overlord_event_system/async_handler/

chapters_management.rs

use crate::{
    async_handler::handler::OverlordAsyncEventHandler,
    entities,
    event::{OverlordEvent, OverlordEventStartFight, PrepareFightType},
    game_config_helpers::GameConfigLookup,
    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, StarsChange},
};

use event_system::{
    event::{EventPluginized, EventStruct},
    plugin::cron::CronMark,
    script::runner::ScriptRandom,
    system::EventHandleResult,
};
use rand::Rng;

impl OverlordAsyncEventHandler {
    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);
        }

        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);
                }
                state.character_state.character.last_boss_fight_won = true
            }
            PrepareFightType::DungeonFight {
                dungeon_id,
                difficulty,
            } => {
                if !self.validate_dungeon_fight(&state, dungeon_id, difficulty) {
                    return EventHandleResult::fail(state);
                }
            }
            PrepareFightType::ForfeitDungeonFight => {}
            PrepareFightType::SingleFight { .. } => {}
        };

        let mut events = vec![];

        // It triggers only on game start
        // Should be moved to StartGame event later, when crons can be used in SyncHandler
        // Moving this will break calculate_pvp_result function, should start calling fight_progress in it
        if state.active_fight.is_none() {
            events.push(EventPluginized::cron(
                OverlordEvent::FightProgress {},
                CronMark::AddCron {
                    rate_ticks: game_config.game_settings.fight_progress_tick,
                    begin_in_cooldown: false,
                    is_ready: None,
                },
            ));
        }

        state.active_fight = None;

        let mut 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 => {
                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 EventHandleResult::fail(state);
                };

                state.character_state.character.current_fight_number =
                    (chapter.fight_ids.len() - 1) as i64;
                self.handle_pve_prepare_fight(&mut state, rand_gen)
            }
            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)
            }
        };

        if prepare_fight_events.is_empty() {
            tracing::error!("Preparing fight returned an empty vec, something went wrong");
            return EventHandleResult::fail(state);
        };

        if state.active_fight.is_none() {
            tracing::error!("No active fight after preparing fight");
            return EventHandleResult::fail(state);
        };

        events.append(&mut prepare_fight_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();

        if state.character_state.character.last_boss_fight_won {
            tracing::error!("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::error!("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::error!("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,
            &self.script_runner,
        ) {
            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,
                &self.script_runner,
            ) {
                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: Box<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,
                        &self.script_runner,
                    ) {
                        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,
            &self.script_runner,
        ) {
            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 current_chapter = state.character_state.character.current_chapter_level;
        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.clone());
                scope_setter.set_const("CurrentChapter", current_chapter);
                scope_setter
            },
            state,
            &fight.prepare_fight_script,
        ) {
            Ok(start_fight_events) => {
                events.append(
                    &mut start_fight_events
                        .into_iter()
                        .map(EventPluginized::now)
                        .collect(),
                );
            }
            Err(err) => {
                anyhow::bail!("Prepare pvp fight script failed with error: {err:?}");
            }
        };

        Ok(())
    }

    fn handle_pve_prepare_fight(
        &self,
        state: &mut OverlordState,
        mut rand_gen: rand::rngs::StdRng,
    ) -> 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 vec![];
        };

        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 vec![];
        };

        let Ok(fight) = game_config.require_fight_template(fight_id) else {
            tracing::error!("Failed to get fight_template with id {} ", fight_id,);
            return 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 PVE entities: {}", err);
                    return vec![];
                }
            };

        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 vec![];
        }

        let start_fight_delay = fight
            .start_fight_delay_ticks
            .unwrap_or(game_config.fight_settings.start_fight_delay_ticks_default);

        events.push(EventPluginized::delayed(
            OverlordEvent::StartFight {
                fight_id: active_fight.id,
            },
            start_fight_delay,
        ));

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

        events
    }

    fn handle_pvp_prepare_fight(
        &self,
        state: &mut OverlordState,
        fight_id: FightTemplateId,
        pvp_state: Box<PVPState>,
        mut rand_gen: rand::rngs::StdRng,
    ) -> Vec<EventPluginized<OverlordEvent, OverlordState>> {
        let game_config = self.game_config.get();
        state.pvp_state = Some(*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 vec![];
        };

        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 vec![];
            }
        };

        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 vec![];
        }

        let start_fight_delay = fight
            .start_fight_delay_ticks
            .unwrap_or(game_config.fight_settings.start_fight_delay_ticks_default);

        events.push(EventPluginized::delayed(
            OverlordEvent::StartFight {
                fight_id: active_fight.id,
            },
            start_fight_delay,
        ));

        events
    }

    fn handle_dungeon_prepare_fight(
        &self,
        state: &mut OverlordState,
        dungeon_id: DungeonTemplateId,
        difficulty: i64,
        mut rand_gen: rand::rngs::StdRng,
    ) -> 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 vec![];
        };

        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 vec![];
        };

        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 vec![];
        };

        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 vec![];
                }
            };

        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 vec![];
        }

        let start_fight_delay = fight
            .start_fight_delay_ticks
            .unwrap_or(game_config.fight_settings.start_fight_delay_ticks_default);

        events.push(EventPluginized::delayed(
            OverlordEvent::StartFight {
                fight_id: active_fight.id,
            },
            start_fight_delay,
        ));

        events
    }

    fn handle_single_prepare_fight(
        &self,
        state: &mut OverlordState,
        fight_template_id: FightTemplateId,
        mut rand_gen: rand::rngs::StdRng,
    ) -> 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 vec![];
        };

        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 vec![];
                }
            };

        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 pvp prepare_fight script: {err:?}");
            return vec![];
        }

        let start_fight_delay = fight
            .start_fight_delay_ticks
            .unwrap_or(game_config.fight_settings.start_fight_delay_ticks_default);

        events.push(EventPluginized::delayed(
            OverlordEvent::StartFight {
                fight_id: active_fight.id,
            },
            start_fight_delay,
        ));

        events
    }

    pub fn handle_start_fight(
        &mut self,
        event: OverlordEvent,
        fight_id: uuid::Uuid,
        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_cloned = active_fight.clone();

        match self.script_runner.run_event(
            |mut scope_setter| {
                scope_setter.set_event(OverlordEventStartFight::from_enum(event));
                scope_setter.set_const("Random", ScriptRandom::new(rand_gen));
                scope_setter.set_const("Fight", active_fight_cloned);
                scope_setter
            },
            &state,
            &fight_template.start_script,
        ) {
            Ok(start_fight_events) => {
                events.append(
                    &mut start_fight_events
                        .into_iter()
                        .map(EventPluginized::now)
                        .collect(),
                );
            }
            Err(err) => {
                tracing::error!("Start fight script 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)
    }

    fn end_pvp_fight(
        &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],
                    }));
                }
            } 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;
            }
        }

        if let Some(stars_change) = &pvp_state.stars_change {
            match stars_change {
                StarsChange::LimitExceeded => {}
                StarsChange::StarsOnly {
                    final_stars_count, ..
                } => {
                    state.character_state.character.arena_stars = *final_stars_count;
                }
                StarsChange::StarsWithReward {
                    final_stars_count,
                    bundle_step_generic,
                    new_daily_claims_count,
                    ..
                } => {
                    state.character_state.character.arena_stars = *final_stars_count;
                    state.character_state.bundle_step_generic = vec![bundle_step_generic.clone()];
                    state.character_state.arena_stars.arena_stars_daily_claims =
                        *new_daily_claims_count;
                }
            }
        }

        state.pvp_state = None;

        // If (is_win && stop_on_win) or (!is_win && stop_on_lose) - we stop fighting
        if (!is_win || !current_fight.stop_on_win) && (is_win || !current_fight.stop_on_lose) {
            events.push(EventPluginized::now(
                OverlordEvent::RefreshPartyMemberState {},
            ));
            events.push(EventPluginized::delayed(
                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;
        }

        EventHandleResult::ok_events(state, events)
    }

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

                if !state.character_state.character.last_boss_fight_won
                    && next_fight.fight_type == FightType::CampaignBossFight
                {
                    next_fight_number = 0;
                }
            }

            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 let Some(bundle_id) = current_fight.bundle_reward_id {
                events.push(EventPluginized::now(OverlordEvent::AddBundleGroup {
                    bundle_ids: vec![bundle_id],
                }));
            }
        } 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;
        }

        // If (is_win && stop_on_win) or (!is_win && stop_on_lose) - we stop fighting
        if (!is_win || !current_fight.stop_on_win) && (is_win || !current_fight.stop_on_lose) {
            events.push(EventPluginized::now(
                OverlordEvent::RefreshPartyMemberState {},
            ));
            events.push(EventPluginized::delayed(
                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;
        }

        EventHandleResult::ok_events(state, events)
    }

    fn end_dungeon_fight(
        &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],
                }));
            }

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

        // If (is_win && stop_on_win) or (!is_win && stop_on_lose) - we stop fighting
        if (!is_win || !current_fight.stop_on_win) && (is_win || !current_fight.stop_on_lose) {
            events.push(EventPluginized::now(
                OverlordEvent::RefreshPartyMemberState {},
            ));
            events.push(EventPluginized::delayed(
                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;
        }

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

        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;

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

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