overlord_event_system/logic/

quests.rs

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

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

use event_system::{event::EventPluginized, script::random::GameRng, system::EventHandleResult};
use uuid::Uuid;

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

        let previous_points = match quest.quest_group_type {
            QuestGroupType::Daily => state.quest_groups.daily.progress_track.current_points,
            QuestGroupType::Weekly => state.quest_groups.weekly.progress_track.current_points,
            QuestGroupType::Achievement => {
                state
                    .quest_groups
                    .achievements
                    .progress_track
                    .current_points
            }
            _ => 0,
        };

        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;
            }
            _ => {}
        }

        snapshot_core_progression_thresholds(
            &self.game_config.get(),
            quest.quest_group_type,
            previous_points,
            &mut state,
        );

        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],
                source: essences::currency::CurrencySource::QuestClaim,
            }));
        }

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

        if let Some(native_name) = quest.additional_quests_behavior.as_deref() {
            match self.run_additional_quests(native_name, rand_gen, &state.character_state) {
                Ok(mut script_events) => {
                    events.append(&mut script_events.drain(..).map(EventPluginized::now).collect());
                }
                Err(err) => {
                    tracing::error!("Additional quests script failed with error: {err:?}");
                    return EventHandleResult::fail(state);
                }
            }
        }

        EventHandleResult::ok_events(state, events)
    }

    /// Run a quest's native `additional_quests` port. The `prepare_loop` pattern
    /// draws RNG, so `rand_gen` is the authoritative session RNG for this event.
    fn run_additional_quests(
        &self,
        native_name: &str,
        rand_gen: rand::rngs::StdRng,
        character_state: &essences::character_state::CharacterState,
    ) -> anyhow::Result<Vec<OverlordEvent>> {
        let Some(f) = self.behaviors.additional_quests_fn(native_name) else {
            anyhow::bail!("No registered additional_quests native fn named {native_name}");
        };
        let game_config = self.game_config.get();
        let rng = GameRng::new(rand_gen);
        f(&crate::behaviors::quests::loop_tasks::AdditionalQuestsCtx {
            character_state,
            rng: &rng,
            config: &game_config,
            lookups: self.behaviors.lookups(),
        })
    }

    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.behaviors,
                ),
                &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 Some(f) = self
                .behaviors
                .default_loop_task_fn("default_loop_task_const")
            else {
                tracing::error!(
                    "No registered default_loop_task native fn named default_loop_task_const"
                );
                return EventHandleResult::fail(state);
            };
            let fallback_id = match f(&crate::behaviors::quests::loop_tasks::DefaultLoopTaskCtx) {
                Ok(id) => id,
                Err(err) => {
                    tracing::error!("Failed to evaluate default_loop_task native fn: {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],
                source: essences::currency::CurrencySource::QuestClaim,
            }));
        }

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

        if let Some(native_name) = quest.additional_quests_behavior.as_deref() {
            match self.run_additional_quests(native_name, rand_gen, &state.character_state) {
                Ok(mut script_events) => {
                    events.append(&mut script_events.drain(..).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_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> {
        use crate::mechanics::quest_board::is_board_managed;

        let game_config = self.game_config.get();

        // The list carries BOTH the reset targets and today's board
        // membership: `state_updater` appends the
        // freshly selected daily board / weekly set so a mid-session day flip
        // rotates the board without a reconnect. Instances present in state
        // are reset; listed-but-absent board-managed quests rotated IN today
        // are instantiated.
        for quest_id in &quest_ids {
            if let Some(quest) = state.quest_groups.find_in_repeatable_mut(*quest_id) {
                quest.current = 0;
                quest.is_claimed = false;
                continue;
            }
            let Some(tpl) = game_config.quest(*quest_id) else {
                tracing::warn!("ResetRepeatingQuests: quest {quest_id} not in config, skipping");
                continue;
            };
            if is_board_managed(tpl) {
                state.quest_groups.push(
                    &make_quest_instance(
                        tpl,
                        &state.character_state,
                        &game_config,
                        &self.behaviors,
                    ),
                    &tpl.quest_group_type,
                );
            } else {
                // Legacy semantics: a non-board quest in the list should have
                // had an instance. Not fatal — log and continue (failing the
                // whole event on one missing row lost every other reset).
                tracing::warn!("ResetRepeatingQuests: no instance for quest {quest_id}");
            }
        }

        // Rotate OUT: board-managed instances absent from today's list — but
        // only within groups the list actually covers (a daily-only flip must
        // not strip the weekly set, whose ids are absent from that list).
        let listed: std::collections::HashSet<Uuid> = quest_ids.iter().copied().collect();
        for group in [QuestGroupType::Daily, QuestGroupType::Weekly] {
            let covers_group = quest_ids.iter().any(|id| {
                game_config
                    .quest(*id)
                    .is_some_and(|t| t.quest_group_type == group && is_board_managed(t))
            });
            if !covers_group {
                continue;
            }
            let instances = match group {
                QuestGroupType::Daily => &mut state.quest_groups.daily.quests,
                _ => &mut state.quest_groups.weekly.quests,
            };
            instances.retain(|q| {
                listed.contains(&q.id)
                    || game_config.quest(q.id).is_none_or(|t| !is_board_managed(t))
            });
        }

        // Reset the cumulative progress track for every group that rolled over
        // in this event. The individual quests reset to 0/unclaimed above, so
        // the accrued points and milestone claim-flags must reset with them —
        // otherwise yesterday's full bar and already-claimed nodes carry into
        // the new period until a reconnect. A group's quest ids appear in
        // `quest_ids` only inside its own day/week-flip branch in
        // `state_updater`, so membership in the list means that group flipped.
        for group in [QuestGroupType::Daily, QuestGroupType::Weekly] {
            let group_flipped = quest_ids.iter().any(|id| {
                game_config
                    .quest(*id)
                    .is_some_and(|t| t.quest_group_type == group)
            });
            if !group_flipped {
                continue;
            }
            let track = match group {
                QuestGroupType::Daily => &mut state.quest_groups.daily.progress_track,
                _ => &mut state.quest_groups.weekly.progress_track,
            };
            track.current_points = 0;
            for reward in &mut track.rewards {
                reward.is_claimed = false;
            }
        }

        EventHandleResult::ok(state)
    }
}

/// Zero the Core payout of each newly earned progression rung that is crossed
/// while Cores are still locked. The async monolith handler persists the
/// highest such threshold as a watermark, and state reconstruction reapplies
/// it after reconnect.
pub fn snapshot_core_progression_thresholds(
    game_config: &configs::game_config::GameConfig,
    quest_group_type: QuestGroupType,
    previous_points: u64,
    state: &mut OverlordState,
) {
    let track = match quest_group_type {
        QuestGroupType::Daily => &mut state.quest_groups.daily.progress_track,
        QuestGroupType::Weekly => &mut state.quest_groups.weekly.progress_track,
        QuestGroupType::Achievement => &mut state.quest_groups.achievements.progress_track,
        _ => return,
    };
    let current_points = track.current_points;
    let core_id = game_config.cores_settings.upgrade_currency_id;
    let core_unlocked = state.character_state.character.current_chapter_level
        >= game_config.cores_settings.unlock_chapter;

    for rung in &mut track.rewards {
        if rung.points_required <= previous_points || rung.points_required > current_points {
            continue;
        }
        if let Some(core) = rung
            .reward
            .iter_mut()
            .find(|unit| unit.currency_id == core_id)
            && !core_unlocked
        {
            core.amount = 0;
        }
    }
}