overlord_event_system/async_handler/

quests.rs

use crate::{
    async_handler::handler::OverlordAsyncEventHandler, event::OverlordEvent,
    game_config_helpers::GameConfigLookup, quests::make_quest_instance, state::OverlordState,
};

use essences::{
    currency::CurrencySource,
    quest::{QuestGroupType, QuestTemplate, QuestsTrackReward},
};

use event_system::{
    event::EventPluginized, script::runner::ScriptRandom, system::EventHandleResult,
};
use uuid::Uuid;

impl OverlordAsyncEventHandler {
    pub fn handle_claim_quest(
        &mut self,
        quest_id: Uuid,
        rand_gen: rand::rngs::StdRng,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let Ok(quest) = self.get_quest(quest_id) else {
            tracing::error!("Couldn't get quest with id = {} in config", quest_id);
            return EventHandleResult::fail(state);
        };

        let Some(quest_instance) = state.quest_groups.find_in_non_patron(quest_id) else {
            tracing::error!("Couldn't find quest with id = {} in state", quest_id);
            return EventHandleResult::fail(state);
        };

        if quest.quest_group_type == QuestGroupType::PatronDaily
            || quest.quest_group_type == QuestGroupType::PatronLifetime
        {
            tracing::error!("Quest with id = {} is a patron_quest", quest_id);
            return EventHandleResult::fail(state);
        }

        if quest.quest_group_type == QuestGroupType::Hidden {
            tracing::error!("Quest with id = {} is a hidden_quest", quest_id);
            return EventHandleResult::fail(state);
        }

        if !quest_instance.is_completed(quest.progress_target) {
            tracing::error!(
                "Tried claiming quest with id = {}, that is not completed:\n Current: {}, Target: {}",
                quest_id,
                quest_instance.current,
                quest.progress_target,
            );
            return EventHandleResult::fail(state);
        }

        if let Err(e) = state.quest_groups.mark_quest_claimed(quest_id) {
            tracing::error!("Got error, trying to mark quest as claimed: {:?}", e);
            return EventHandleResult::fail(state);
        }

        // TODO MAYBE tmp solution, because daily/weekly quests should be visible, even after claim
        // state.quest_groups.retain_repeatable(quest_id);
        state.quest_groups.retain_lifetime(quest_id);
        state.quest_groups.reset_loop_task(quest_id);

        match quest.quest_group_type {
            QuestGroupType::Daily => {
                state.quest_groups.daily.progress_track.current_points += quest.progression_points;
            }
            QuestGroupType::Weekly => {
                state.quest_groups.weekly.progress_track.current_points += quest.progression_points;
            }
            QuestGroupType::Achievement => {
                state
                    .quest_groups
                    .achievements
                    .progress_track
                    .current_points += quest.progression_points;
            }
            _ => {}
        }

        let mut events = vec![];

        // Add bundle reward if quest has a bundle_id
        if let Some(bundle_id) = quest.bundle_id {
            events.push(EventPluginized::now(OverlordEvent::AddBundleGroup {
                bundle_ids: vec![bundle_id],
            }));
        }

        if !quest.next_quest_ids.is_empty() {
            events.push(EventPluginized::now(OverlordEvent::NewQuests {
                quest_ids: quest.next_quest_ids,
            }));
        }

        if let Some(additional_quests_script) = quest.additional_quests_script {
            match self.script_runner.run_event(
                |mut scope_setter| {
                    scope_setter.set_const("Random", ScriptRandom::new(rand_gen));
                    scope_setter.set_const("CharacterState", state.character_state.clone());
                    scope_setter
                },
                &state,
                &additional_quests_script,
            ) {
                Ok(script_events) => {
                    events.append(
                        &mut script_events
                            .into_iter()
                            .map(EventPluginized::now)
                            .collect(),
                    );
                }
                Err(err) => {
                    tracing::error!("Additional quests script failed with error: {err:?}");
                    return EventHandleResult::fail(state);
                }
            }
        }

        EventHandleResult::ok_events(state, events)
    }

    pub fn handle_new_quests(
        &self,
        quest_ids: Vec<Uuid>,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        for quest_id in quest_ids {
            let Ok(quest) = self.get_quest(quest_id) else {
                tracing::error!("Couldn't get quest with id = {}", quest_id);
                return EventHandleResult::fail(state);
            };

            if state.quest_groups.find_in_all(quest_id).is_some() {
                tracing::warn!("Quest with id = {} is already in state, skipping", quest_id);
                continue;
            }

            state.quest_groups.push(
                &make_quest_instance(
                    &quest,
                    &state.character_state,
                    &self.game_config.get(),
                    &self.script_runner,
                ),
                &quest.quest_group_type,
            );
        }

        EventHandleResult::ok(state)
    }

    pub fn handle_update_active_loop_task_id(
        &self,
        quest_id: Uuid,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let resolved_id = if state
            .quest_groups
            .loop_tasks
            .iter()
            .any(|q| q.id == quest_id)
        {
            quest_id
        } else {
            tracing::warn!(
                "Loop task quest_id={quest_id} not found in state.loop_tasks, falling back to default loop task from config"
            );
            let game_config = self.game_config.get();
            let fallback_id = match self.script_runner.run_expression::<Uuid>(
                |mut scope_setter| {
                    scope_setter.set_const(
                        "CustomValues",
                        state.character_state.character.custom_values.clone(),
                    );
                    scope_setter
                },
                &game_config.game_settings.get_default_loop_task_id,
            ) {
                Ok(id) => id,
                Err(err) => {
                    tracing::error!("Failed to evaluate get_default_loop_task_id script: {err}");
                    return EventHandleResult::fail(state);
                }
            };
            if state
                .quest_groups
                .loop_tasks
                .iter()
                .any(|q| q.id == fallback_id)
            {
                fallback_id
            } else if let Some(first_task) = state.quest_groups.loop_tasks.first() {
                tracing::warn!(
                    "Fallback quest {fallback_id} from config not found in state, \
                     using first available loop task {}",
                    first_task.id
                );
                first_task.id
            } else {
                tracing::error!("No loop tasks available in state");
                return EventHandleResult::fail(state);
            }
        };

        state.character_state.character.active_loop_task_id = Some(resolved_id);

        EventHandleResult::ok(state)
    }

    pub fn handle_patron_quest_completed(
        &self,
        quest_id: Uuid,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        if state.patron.is_none() {
            tracing::error!("Tried completing patron quest but there is no patron");
            return EventHandleResult::fail(state);
        }

        let Ok(quest) = self.get_quest(quest_id) else {
            tracing::error!("Couldn't get quest with id = {}", quest_id);
            return EventHandleResult::fail(state);
        };

        let Some(quest_instance) = state.quest_groups.find_in_patron(quest_id) else {
            tracing::error!("Couldn't find quest with id = {} in state", quest_id);
            return EventHandleResult::fail(state);
        };

        if !(quest.quest_group_type == QuestGroupType::PatronDaily
            || quest.quest_group_type == QuestGroupType::PatronLifetime)
        {
            tracing::error!("Quest with id = {} is not patron_quest", quest_id);
            return EventHandleResult::fail(state);
        }

        if !quest_instance.is_completed(quest.progress_target) {
            tracing::error!(
                "Tried claiming quest with id = {}, that is not completed:\n Current: {}, Target: {}",
                quest_id,
                quest_instance.current,
                quest.progress_target,
            );
            return EventHandleResult::fail(state);
        }

        state.quest_groups.retain_patron(quest.id);

        let mut events = vec![];

        if !quest.next_quest_ids.is_empty() {
            events.push(EventPluginized::now(OverlordEvent::NewQuests {
                quest_ids: quest.next_quest_ids,
            }));
        }

        EventHandleResult::ok_events(state, events)
    }

    pub fn handle_hidden_quest_completed(
        &self,
        quest_id: Uuid,
        rand_gen: rand::rngs::StdRng,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let Ok(quest) = self.get_quest(quest_id) else {
            tracing::error!("Couldn't get quest with id = {}", quest_id);
            return EventHandleResult::fail(state);
        };

        let Some(quest_instance) = state.quest_groups.find_in_hidden(quest_id) else {
            tracing::error!("Couldn't find quest with id = {} in state", quest_id);
            return EventHandleResult::fail(state);
        };

        if quest.quest_group_type != QuestGroupType::Hidden {
            tracing::error!("Quest with id = {} is not hidden", quest_id);
            return EventHandleResult::fail(state);
        }

        if !quest_instance.is_completed(quest.progress_target) {
            tracing::error!(
                "Tried claiming quest with id = {}, that is not completed:\n Current: {}, Target: {}",
                quest_id,
                quest_instance.current,
                quest.progress_target,
            );
            return EventHandleResult::fail(state);
        }

        state.quest_groups.retain_hidden(quest.id);

        let mut events = vec![];

        // Add bundle reward if quest has a bundle_id
        if let Some(bundle_id) = quest.bundle_id {
            events.push(EventPluginized::now(OverlordEvent::AddBundleGroup {
                bundle_ids: vec![bundle_id],
            }));
        }

        if !quest.next_quest_ids.is_empty() {
            events.push(EventPluginized::now(OverlordEvent::NewQuests {
                quest_ids: quest.next_quest_ids,
            }));
        }

        if let Some(additional_quests_script) = quest.additional_quests_script {
            match self.script_runner.run_event(
                |mut scope_setter| {
                    scope_setter.set_const("Random", ScriptRandom::new(rand_gen));
                    scope_setter.set_const("CharacterState", state.character_state.clone());
                    scope_setter
                },
                &state,
                &additional_quests_script,
            ) {
                Ok(script_events) => {
                    events.append(
                        &mut script_events
                            .into_iter()
                            .map(EventPluginized::now)
                            .collect(),
                    );
                }
                Err(err) => {
                    // TODOO should this fallback run always?
                    tracing::error!("Additional quests script failed with error: {err:?}");
                    return EventHandleResult::fail(state);
                }
            }
        }

        EventHandleResult::ok_events(state, events)
    }

    pub fn handle_claim_quest_progression_reward(
        &self,
        quest_group_type: QuestGroupType,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let (current_points, rewards) = match quest_group_type {
            QuestGroupType::Daily => (
                state.quest_groups.daily.progress_track.current_points,
                &mut state.quest_groups.daily.progress_track.rewards,
            ),
            QuestGroupType::Weekly => (
                state.quest_groups.weekly.progress_track.current_points,
                &mut state.quest_groups.weekly.progress_track.rewards,
            ),
            QuestGroupType::Achievement => (
                state
                    .quest_groups
                    .achievements
                    .progress_track
                    .current_points,
                &mut state.quest_groups.achievements.progress_track.rewards,
            ),
            _ => {
                tracing::error!(
                    "Tried claiming quest progression reward with quest_group_type = {quest_group_type:?}"
                );
                return EventHandleResult::fail(state);
            }
        };

        let mut available_rewards: Vec<&mut QuestsTrackReward> = rewards
            .iter_mut()
            .filter(|x| !x.is_claimed && current_points >= x.points_required)
            .collect();

        if available_rewards.is_empty() {
            tracing::error!(
                "No available rewards found for current_points = {} and quest_group_type = {}",
                current_points,
                quest_group_type
            );
            return EventHandleResult::fail(state);
        }

        // For achievements, claim only the next (lowest) reward per call
        let mut all_claimed_rewards = vec![];
        if quest_group_type == QuestGroupType::Achievement {
            available_rewards.sort_by_key(|r| r.points_required);
            let reward = &mut available_rewards[0];
            reward.is_claimed = true;
            all_claimed_rewards.extend(reward.reward.iter().cloned());
        } else {
            for reward in available_rewards {
                reward.is_claimed = true;
                all_claimed_rewards.extend(reward.reward.iter().cloned());
            }
        }

        let events = vec![Self::currency_increase(
            &all_claimed_rewards,
            CurrencySource::QuestsTrackReward,
        )];

        EventHandleResult::ok_events(state, events)
    }

    fn get_quest(&self, quest_id: Uuid) -> anyhow::Result<QuestTemplate> {
        let game_config = self.game_config.get();

        Ok(game_config.require_quest(quest_id)?.clone())
    }

    pub fn handle_reset_repeating_quests(
        &self,
        quest_ids: Vec<Uuid>,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        for quest_id in quest_ids {
            let Some(quest) = state.quest_groups.find_in_repeatable_mut(quest_id) else {
                tracing::error!(
                    "Couldn't find repeatable quest with id = {}, in state",
                    quest_id
                );
                return EventHandleResult::fail(state);
            };

            quest.current = 0;
            quest.is_claimed = false;
        }

        EventHandleResult::ok(state)
    }
}