overlord_event_system/async_handler/

cheats.rs

use crate::{
    async_handler::handler::OverlordAsyncEventHandler,
    cases::try_finalize_item,
    entities::create_pve_entity,
    event::{Cheat, OverlordEvent, PrepareFightType},
    gacha::item_case::generate_item_from_template,
    game_config_helpers::GameConfigLookup,
    state::OverlordState,
};

use configs::cheats::CheatScriptId;
use essences::{
    abilities::AbilityShard,
    entity::{ActionWithDeadline, Coordinates, EntityAttributes},
    fighting::{EntityType, FightEntity, FightTemplateId},
    items::ItemTemplateId,
    skins::SkinId,
};
use essences::{
    currency::{CurrencySource, CurrencyUnit},
    fighting::EntityTeam,
    game::EntityTemplateId,
};
use event_system::{event::EventPluginized, system::EventHandleResult};
use rand::Rng;

impl OverlordAsyncEventHandler {
    pub fn handle_run_cheat(
        &mut self,
        cheat: &Cheat,
        current_tick: u64,
        rand_gen: rand::rngs::StdRng,
        state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        match cheat {
            Cheat::PauseCombat => self.handle_cheat_pause_combat(state),
            Cheat::UnpauseCombat => self.handle_cheat_unpause_combat(state),
            Cheat::GodModeOn => self.handle_cheat_god_mode(state),
            Cheat::GodModeOff => self.handle_cheat_god_mode_off(state),
            Cheat::GetRich => self.handle_cheat_get_rich(state),
            Cheat::StartFight { templated_id } => {
                self.handle_cheat_start_fight(*templated_id, state)
            }
            Cheat::SpawnEntity {
                entity_id,
                x,
                y,
                team,
                attributes,
            } => self.handle_cheat_spawn_entity(
                *entity_id,
                *x,
                *y,
                team.clone(),
                attributes,
                current_tick,
                state,
                rand_gen,
            ),
            Cheat::WearItems { items_ids } => {
                self.handle_cheat_wear_equipment_set(items_ids, state, rand_gen)
            }
            Cheat::ClearInventory => self.handle_cheat_clear_inventory(state),
            Cheat::ClearSlot { item_id } => self.handle_cheat_clear_slot(*item_id, state),
            Cheat::GetAllSpells => self.handle_cheat_get_all_spells(state),
            Cheat::SetChapter { chapter } => self.handle_cheat_set_chapter(*chapter, state),
            Cheat::EquipSkin { skin_id } => self.handle_cheat_equip_skin(*skin_id, state),
            Cheat::UnequipSkin { skin_id } => self.handle_cheat_unequip_skin(*skin_id, state),
            Cheat::NewLevel { level } => self.handle_cheat_new_level(*level, state),
            Cheat::Script { script_id } => self.handle_cheat_script(*script_id, state),
        }
    }

    fn handle_cheat_pause_combat(
        &self,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        if let Some(fight) = &mut state.active_fight {
            fight.paused = true;
        }

        EventHandleResult::ok(state)
    }

    fn handle_cheat_unpause_combat(
        &self,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        if let Some(fight) = &mut state.active_fight {
            fight.paused = false;
        }

        EventHandleResult::ok(state)
    }

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

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

        entity.attributes.set("godmode", 1);

        EventHandleResult::ok(state)
    }

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

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

        entity.attributes.set("godmode", 0);

        EventHandleResult::ok(state)
    }

    fn handle_cheat_get_rich(
        &mut self,
        state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let game_config = self.game_config.get();

        let currencies: Vec<CurrencyUnit> = game_config
            .currencies
            .iter()
            .map(|currency| CurrencyUnit {
                currency_id: currency.id,
                amount: 1000000,
            })
            .collect();

        let events = vec![Self::currency_increase(&currencies, CurrencySource::Cheat)];
        EventHandleResult::ok_events(state, events)
    }

    fn handle_cheat_clear_inventory(
        &mut self,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        // Remove all items from inventory
        state.character_state.inventory.clear();

        EventHandleResult::ok(state)
    }

    fn handle_cheat_clear_slot(
        &mut self,
        item_id: uuid::Uuid,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let Some(inv_item_idx) = state
            .character_state
            .inventory
            .iter()
            .position(|x| x.id == item_id)
        else {
            tracing::error!("Tried clearing undefined item: item_id={}", item_id);
            return EventHandleResult::fail(state);
        };

        state.character_state.inventory.remove(inv_item_idx);

        EventHandleResult::ok(state)
    }

    fn handle_cheat_get_all_spells(
        &mut self,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let game_config = self.game_config.get();

        // Collect all gacha abilities with 1 shard each
        let ability_shards: Vec<AbilityShard> = game_config
            .abilities
            .iter()
            .filter(|ability| ability.is_gacha_ability)
            .map(|ability| AbilityShard {
                ability_id: ability.id,
                shards_amount: 1,
            })
            .collect();

        // Update existing abilities or add new ones
        for shard in &ability_shards {
            if let Some(existing_ability) = state
                .character_state
                .all_abilities
                .iter_mut()
                .find(|a| a.template_id == shard.ability_id)
            {
                // Add shards to existing ability
                existing_ability.shards_amount += shard.shards_amount;
            } else {
                // This is a new ability, we need to create it
                let Some(template) = game_config.ability_template(shard.ability_id) else {
                    tracing::error!(
                        "Failed to find ability template with id={}",
                        shard.ability_id
                    );
                    continue;
                };

                let new_ability = essences::abilities::Ability::from_template(template, None, None);
                state.character_state.all_abilities.push(new_ability);
            }
        }

        EventHandleResult::ok(state)
    }

    fn handle_cheat_set_chapter(
        &mut self,
        chapter: i64,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let game_config = self.game_config.get();

        let prev_chapter_level = state.character_state.character.current_chapter_level;
        state.character_state.character.current_chapter_level = chapter;
        state.character_state.character.current_fight_number = 0;
        state.character_state.character.last_boss_fight_won = true;

        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(true, &current_chapter, &state);

        let mut events = vec![];
        if self.should_reset_afk_timer_on_gating_unlock(prev_chapter_level, &state) {
            events.push(EventPluginized::now(
                OverlordEvent::AfkRewardsGatingUnlocked {},
            ));
        }
        events.push(EventPluginized::delayed(
            OverlordEvent::PrepareFight {
                prepare_fight_type: PrepareFightType::PVEFight,
            },
            prepare_fight_delay_ticks,
        ));

        EventHandleResult::ok_events(state, events)
    }

    fn handle_cheat_start_fight(
        &mut self,
        fight_templated_id: FightTemplateId,
        state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let game_config = self.game_config.get();

        EventHandleResult::ok_events(
            state,
            vec![EventPluginized::delayed(
                OverlordEvent::PrepareFight {
                    prepare_fight_type: PrepareFightType::SingleFight { fight_templated_id },
                },
                game_config
                    .fight_settings
                    .prepare_fight_win_delay_ticks_default,
            )],
        )
    }

    #[allow(clippy::too_many_arguments)]
    fn handle_cheat_spawn_entity(
        &mut self,
        entity_template_id: EntityTemplateId,
        x: i64,
        y: i64,
        team: EntityTeam,
        attributes: &Vec<(String, i64)>,
        current_tick: u64,
        mut state: OverlordState,
        mut rand_gen: rand::rngs::StdRng,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let game_config = self.game_config.get();

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

        let entity_id = uuid::Builder::from_random_bytes(rand_gen.random()).into_uuid();

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

        let Some(player) = active_fight.get_player() else {
            tracing::error!("No player in fight");
            return EventHandleResult::fail(state);
        };

        let position = Coordinates {
            x: player.coordinates.x + x,
            y: (player.coordinates.y + y).clamp(0, 2),
        };

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

        let mut entity_attributes = EntityAttributes::default();

        for (key, value) in attributes {
            entity_attributes.add(key, *value);
        }

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

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

        active_fight.entities.push(created_entity);

        EventHandleResult::ok(state)
    }

    fn handle_cheat_wear_equipment_set(
        &mut self,
        items_ids: &Vec<ItemTemplateId>,
        mut state: OverlordState,
        mut rand_gen: rand::rngs::StdRng,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let game_config = self.game_config.get();

        state.character_state.inventory.clear();

        for item_id in items_ids {
            let item_template = game_config
                .require_item_template(*item_id)
                .unwrap_or_else(|_| panic!("Failed to get item with id={item_id}"));

            let rarity = game_config
                .require_item_rarity(item_template.rarity_id)
                .unwrap_or_else(|_| {
                    panic!("Failed to get rarity with id={}", item_template.rarity_id)
                })
                .clone();

            let mut item = generate_item_from_template(
                item_template,
                rarity,
                state.character_state.character.character_level,
                &game_config,
                &mut rand_gen,
            );

            let mut finalized_item =
                match try_finalize_item(&mut item, &game_config, &self.script_runner) {
                    Ok(()) => item,
                    Err(e) => {
                        tracing::error!("Failed to finalize item: {}", e);
                        return EventHandleResult::fail(state);
                    }
                };

            finalized_item.is_equipped = true;

            state.character_state.inventory.push(finalized_item);
        }

        EventHandleResult::ok(state)
    }

    fn handle_cheat_equip_skin(
        &mut self,
        skin_id: SkinId,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let game_config = self.game_config.get();

        let Some(config_skin) = game_config.skin(skin_id) else {
            tracing::error!("Failed to find skin with id: {skin_id}");
            return EventHandleResult::fail(state);
        };

        let new_skin_type = config_skin.skin_type;

        if let Some(pos) = state
            .character_state
            .character_skins
            .equipped
            .iter()
            .position(|&s| {
                game_config
                    .skin(s)
                    .is_some_and(|cs| cs.skin_type == new_skin_type)
            })
        {
            let old_skin_id = state.character_state.character_skins.equipped.remove(pos);
            state
                .character_state
                .character_skins
                .available
                .push(old_skin_id);
        }

        state.character_state.character_skins.equipped.push(skin_id);

        EventHandleResult::ok(state)
    }

    fn handle_cheat_unequip_skin(
        &mut self,
        skin_id: SkinId,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        if let Some(pos) = state
            .character_state
            .character_skins
            .equipped
            .iter()
            .position(|&s| s == skin_id)
        {
            state.character_state.character_skins.equipped.remove(pos);
            state
                .character_state
                .character_skins
                .available
                .push(skin_id);
        }

        EventHandleResult::ok(state)
    }

    fn handle_cheat_new_level(
        &mut self,
        level: i64,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        state.character_state.character.character_level = level;
        EventHandleResult::ok(state)
    }

    fn handle_cheat_script(
        &mut self,
        script_id: CheatScriptId,
        state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let game_config = self.game_config.get();

        let Some(cheat_script) = game_config.cheat_script(script_id) else {
            tracing::error!("Failed to find cheat_script with id: {script_id}");
            return EventHandleResult::fail(state);
        };

        let mut events = vec![];

        match self.script_runner.run_event(
            |mut scope_setter| {
                scope_setter.set_const("CharacterState", state.character_state.clone());
                scope_setter
            },
            &state,
            &cheat_script.script,
        ) {
            Ok(script_events) => {
                events.append(
                    &mut script_events
                        .into_iter()
                        .map(EventPluginized::now)
                        .collect(),
                );
            }
            Err(err) => {
                tracing::error!("Cheat script failed with error: {err:?}");
                return EventHandleResult::fail(state);
            }
        }

        EventHandleResult::ok_events(state, events)
    }
}