overlord_event_system/logic/

auto_chest.rs

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

use essences::autochest::{AutoChestFilter, AutoChestFilterId};
use event_system::{event::EventPluginized, system::EventHandleResult};

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

        // Gate auto-chest on character LEVEL (not just chapter): a player must
        // manually open chests to reach the level threshold before auto-open
        // unlocks — rewards hands-on early play (playtester request).
        let level_gate = game_config
            .gatings
            .autochest
            .autochest_button_unlock_character_level;
        if state.character_state.character.character_level < level_gate {
            tracing::warn!(
                "EnableAutoChest rejected: character_level {} < gate {}",
                state.character_state.character.character_level,
                level_gate
            );
            return EventHandleResult::fail(state);
        }

        let events = if !state.character_state.character.auto_chest_enabled {
            state.character_state.character.auto_chest_enabled = true;

            vec![EventPluginized::delayed(
                OverlordEvent::AutoChestOpenItemCase {
                    batch_size: state.auto_chest.batch_size,
                },
                game_config.game_settings.auto_chest_pause_duration_ticks,
            )]
        } else {
            vec![]
        };

        EventHandleResult::ok_events(state, events)
    }

    pub fn handle_disable_auto_chest(
        &self,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        state.character_state.character.auto_chest_enabled = false;

        EventHandleResult::ok(state)
    }

    pub fn handle_enable_auto_chest_filter(
        &self,
        filter_id: AutoChestFilterId,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let Some(filter) = state.auto_chest.filters.iter().find(|f| f.id == filter_id) else {
            tracing::error!(
                "Tried enabling auto_chest filter with id = {}, but didnt find it in state",
                filter_id
            );
            return EventHandleResult::fail(state);
        };

        state.character_state.character.last_filter_used_id = Some(filter.id);

        state.auto_chest.active_filter = Some(filter.clone());

        EventHandleResult::ok(state)
    }

    pub fn handle_disable_auto_chest_filter(
        &self,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        state.auto_chest.active_filter = None;

        EventHandleResult::ok(state)
    }

    pub fn handle_enable_auto_chest_power_compare(
        &self,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        state.auto_chest.power_compare_enabled = true;

        EventHandleResult::ok(state)
    }

    pub fn handle_disable_auto_chest_power_compare(
        &self,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        state.auto_chest.power_compare_enabled = false;

        EventHandleResult::ok(state)
    }

    pub fn handle_update_auto_chest_batch_size(
        &self,
        batch_size: i64,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let game_config = self.game_config.get();
        let Some(item_case_settings) = game_config
            .item_case_settings_by_level(state.character_state.character.item_case_level)
        else {
            tracing::error!(
                "No item case settings for level = {}",
                state.character_state.character.item_case_level
            );
            return EventHandleResult::fail(state);
        };

        if batch_size
            > item_case_settings
                .auto_chest_settings
                .auto_only_max_batch_size
        {
            tracing::error!(
                "Batch size = {}, is bigger than auto max = {}",
                batch_size,
                item_case_settings
                    .auto_chest_settings
                    .auto_only_max_batch_size,
            );
            return EventHandleResult::fail(state);
        }
        state.auto_chest.batch_size = batch_size;

        EventHandleResult::ok(state)
    }

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

        if let Err(e) = filter.validate(
            state.character_state.character.current_chapter_level,
            state.character_state.character.character_level,
            &game_config.attributes,
            &game_config.gatings.autochest,
        ) {
            tracing::error!("Filter {:?},\n Didn't pass validation: {:?}", filter, e);
            return EventHandleResult::fail(state);
        }

        // Upsert: the client re-sends NewAutoChestFilter when its synced view
        // lags behind the round trip (its exists-in-state check races the
        // patch). Hard-failing here silently discarded the user's edit.
        if let Some(existing) = state
            .auto_chest
            .filters
            .iter_mut()
            .find(|f| f.id == filter.id)
        {
            *existing = filter.clone();
        } else {
            state.auto_chest.filters.push(filter.clone());
        }

        Self::refresh_active_filter(&mut state, &filter);

        EventHandleResult::ok(state)
    }

    /// The active filter is a denormalized clone of a `filters` entry — keep it
    /// in step whenever that entry changes, or filtering silently runs with
    /// stale settings until the next EnableAutoChestFilter.
    fn refresh_active_filter(state: &mut OverlordState, updated: &AutoChestFilter) {
        if let Some(active) = &mut state.auto_chest.active_filter
            && active.id == updated.id
        {
            *active = updated.clone();
        }
    }

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

        let Some(old_filter) = state
            .auto_chest
            .filters
            .iter_mut()
            .find(|f| f.id == updated_filter.id)
        else {
            tracing::error!(
                "Tried updating auto_chest filter with id = {}, but didn't find it in state",
                updated_filter.id
            );
            return EventHandleResult::fail(state);
        };

        if let Err(e) = updated_filter.validate(
            state.character_state.character.current_chapter_level,
            state.character_state.character.character_level,
            &game_config.attributes,
            &game_config.gatings.autochest,
        ) {
            tracing::error!(
                "Filter {:?}, didn't pass validation = {:?}",
                updated_filter,
                e
            );
            return EventHandleResult::fail(state);
        }

        *old_filter = updated_filter.clone();

        Self::refresh_active_filter(&mut state, &updated_filter);

        EventHandleResult::ok(state)
    }

    pub fn handle_remove_auto_chest_filter(
        &self,
        filter_id: AutoChestFilterId,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let Some(filter_position) = state
            .auto_chest
            .filters
            .iter()
            .position(|filter| filter.id == filter_id)
        else {
            tracing::error!(
                "Tried removing filter with id = {}, but didn't find it in state",
                filter_id
            );
            return EventHandleResult::fail(state);
        };

        if state.character_state.character.last_filter_used_id == Some(filter_id) {
            state.character_state.character.last_filter_used_id = None;
        }

        // Removing the ACTIVE filter must also stop filtering — otherwise a
        // ghost clone of the deleted preset keeps selling drops.
        if state
            .auto_chest
            .active_filter
            .as_ref()
            .is_some_and(|f| f.id == filter_id)
        {
            state.auto_chest.active_filter = None;
        }

        state.auto_chest.filters.remove(filter_position);

        EventHandleResult::ok(state)
    }
}