overlord_event_system/logic/

cheats.rs

use crate::{
    cases::try_finalize_item,
    entities::create_pve_entity,
    event::{Cheat, OverlordEvent, PrepareFightType},
    gacha::item_case::generate_item_from_template,
    game_config_helpers::GameConfigLookup,
    logic::handler::OverlordLogic,
    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 OverlordLogic {
    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, rand_gen, 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 {},
            ));
        }
        self.fight_clock.schedule(
            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();

        self.fight_clock.schedule(
            OverlordEvent::PrepareFight {
                prepare_fight_type: PrepareFightType::SingleFight { fight_templated_id },
            },
            game_config
                .fight_settings
                .prepare_fight_win_delay_ticks_default,
        );

        EventHandleResult::ok(state)
    }

    #[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.behaviors) {
                    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)
    }

    /// Native port of the dev-only `Cheat::Script` cheats.
    ///
    /// `BehaviorRegistry::run_event` (scoped with `CharacterState`/`Random`). The four
    /// deployed cheat bodies use only loop-task building blocks that already have
    /// native implementations, so we dispatch on `script_id` and reproduce the
    /// produced. No new mechanics — purely a faithful 1:1 port of the shipped
    /// bodies in `overlord/admin/config/scripts/content.templates.cheat_scripts.*`.
    fn handle_cheat_script(
        &mut self,
        script_id: CheatScriptId,
        rand_gen: rand::rngs::StdRng,
        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);
        };

        // The shipped UUID literals are well-formed; `expect` on a literal mirrors
        let parse_uuid =
            |s: &str| uuid::Uuid::parse_str(s).expect("valid cheat-script uuid literal");

        let mut events: Vec<OverlordEvent> = Vec::new();

        match script_id.to_string().as_str() {
            // 019be635: give_quests([...]) + prepare_loop(RNG) + advance_loop.
            // `give_quests([..])` maps to a single `NewQuests` carrying the whole
            // list (matches the old `register_fn("give_quests", ..)`), then the
            // loop-task prepare/advance pair (prepare consumes RNG).
            "019be635-9bc8-7a67-b7df-2cc01c2001c5" => {
                let quest_ids = [
                    "019a4b43-be66-76d6-838f-153a717f82ff",
                    "019a6ef3-740e-7150-b795-b0cbd681ceef",
                    "019b561c-4f34-76c2-8a53-7b55667e7aea",
                    "019b561e-5450-7d29-ae94-d2ddc340030d",
                    "019b561f-bea7-71cc-834f-0909dead9d4b",
                    "019b5621-6475-794b-b850-502d8e124422",
                    "019bc1e6-394d-7c7e-b70c-55764b7455cd",
                    "019bc29c-572e-7c7d-a9e3-8b10a6d28550",
                    "019bc29c-b647-7288-a6ba-668bd37e1c5b",
                    "019bdb53-7ed5-731c-a056-06df0b628065",
                    "019be138-4fee-7ad6-a1a3-7b1539a7bf69",
                    "019be13b-ba5f-71b1-8982-ca1734a7367b",
                ]
                .into_iter()
                .map(parse_uuid)
                .collect::<Vec<_>>();
                events.push(OverlordEvent::NewQuests { quest_ids });

                let rng = event_system::script::random::GameRng::new(rand_gen);
                crate::mechanics::loop_tasks::prepare_loop(
                    &mut events,
                    &game_config,
                    &state.character_state,
                    &rng,
                );
                crate::mechanics::loop_tasks::advance_loop(
                    &mut events,
                    &game_config,
                    self.behaviors.lookups(),
                    &state.character_state,
                );
            }

            // 019bea59: loop_tasks::advance_loop(Result, CharacterState).
            "019bea59-c643-7a11-8985-f02ba314bfd6" => {
                crate::mechanics::loop_tasks::advance_loop(
                    &mut events,
                    &game_config,
                    self.behaviors.lookups(),
                    &state.character_state,
                );
            }

            // 019bfca8: push OverlordEventCustomEvent("CompleteAllLoopTasks", CustomEventData()).
            "019bfca8-953e-76c5-8b33-d83662f9dbb5" => {
                events.push(OverlordEvent::CustomEvent {
                    event_type: "CompleteAllLoopTasks".to_string(),
                    data: crate::event::CustomEventData(Default::default()),
                });
            }

            // 019c1f08: push OverlordEventUpdateActiveLoopTaskId(uuid("019b561e-..")).
            "019c1f08-d84d-7c5f-b71d-1368ac514461" => {
                events.push(OverlordEvent::UpdateActiveLoopTaskId {
                    quest_id: parse_uuid("019b561e-5450-7d29-ae94-d2ddc340030d"),
                });
            }

            // branch also produced no events, so this stays a no-op.
            other => {
                tracing::warn!(
                    "Cheat::Script (id={other}) has no native implementation; \
                     producing no events"
                );
            }
        }

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