overlord_event_system/mechanics/

loop_tasks.rs

//! Native Rust implementation of the loop-task pacing logic.
//!
//! Drives the daily "loop task" pacing: arena/dungeon insertions, milestone
//! quests, and the regular quest cycle. Called by the native quest ports in
//! `behaviors::additional_quests` via `advance_loop` /
//! `prepare_loop` / `on_finish_regular_loop_task`.

use configs::game_config::GameConfig;
use essences::character_state::CharacterState;
use event_system::script::random::GameRng;
use uuid::Uuid;

use crate::event::*;
use crate::game_config_helpers::GameConfigLookup;
use crate::mechanics::content_lookups::ContentLookups;

const LEVEL_MILESTONE_FREQUENCY: i64 = 6;
// Extended past the day-7 progression wall (was 10 = cap at character level 30,
// stage 10 = chapter 11 which free players pass on day 1). Beyond the cap the
// loop has no "progress acknowledged" milestone and degenerates into a flat
// 7-task treadmill; the higher milestones (loop_task.{level,stage}.N quests)
// keep the ladder alive into the ch40 / level-50 range with scaled rewards.
const LEVEL_MILESTONE_QUANTITY: i64 = 14;
const STAGE_MILESTONE_FREQUENCY: i64 = 6;
const STAGE_MILESTONE_QUANTITY: i64 = 13;
const LOOP_TASK_QUANTITY: i64 = 7;

const GOLD_DUNGEON_ID: &str = "019aee96-7303-7d3e-a382-d7776687d24f";
const COOKIE_DUNGEON_ID: &str = "019a9206-800b-781e-8998-38cdc6e9826e";
const BLUEPRINT_DUNGEON_ID: &str = "019d2eca-9508-71c9-abb3-a6fc17474502";

/// SetCustomValue helper for the native (enum-event) path.
fn set_custom_value(key: &str, value: i64) -> OverlordEvent {
    OverlordEvent::SetCustomValue {
        key: key.to_string(),
        value,
    }
}

fn cv_i64(character_state: &CharacterState, key: &str) -> i64 {
    cv_opt(character_state, key).unwrap_or(0)
}

/// absent custom value (`()`) from a present `0`: comparisons like
/// `last_loop_task == custom_values["loop_tasks.arena_after"]` are `false`
/// when the key is missing because `int == ()` is false. Callers that need
/// that distinction must use this instead of `cv_i64`.
fn cv_opt(character_state: &CharacterState, key: &str) -> Option<i64> {
    character_state.character.custom_values.0.get(key).copied()
}

fn quest_by_code(lookups: &ContentLookups, code: &str) -> Option<Uuid> {
    lookups.quest_by_code.get(code).copied()
}

fn quest_by_type_and_number(lookups: &ContentLookups, type_: &str, number: &str) -> Option<Uuid> {
    let code = format!("loop_task.{type_}.{number}");
    quest_by_code(lookups, &code)
}

fn quest_by_type_and_int(lookups: &ContentLookups, type_: &str, number: i64) -> Option<Uuid> {
    let code = format!("loop_task.{type_}.{number}");
    quest_by_code(lookups, &code)
}

/// Difficulty BAND for the player's chapter — picks the SIZE tier of a scalable
/// core loop task so its target scales with the player (Legend-of-Mushroom model:
/// "kill 5" early → "kill ~20" late, ~constant effort because per-fight throughput
/// grows too). Band 1 = the base `loop_task.loop.<N>` quest; bands 2/3 = the
/// `loop_task.loop.<N>.<band>` size variants. Thresholds align with the
/// systems-online wave (skills ch11 / pets ch16) and the milestone cap (ch40).
fn band_for_chapter(chapter: i64) -> i64 {
    if chapter < 16 {
        1
    } else if chapter <= 40 {
        2
    } else {
        3
    }
}

/// Band-`band` size variant of core loop slot `n` (`loop_task.loop.<n>.<band>`),
/// or `None` for band 1 or a slot with no variant — the caller then falls back to
/// the base `loop_task.loop.<n>`. Only the scalable slots author band-2/3 variants;
/// the gated skill slots (3/5/7) have none and always use the base quest.
fn band_quest(lookups: &ContentLookups, n: i64, band: i64) -> Option<Uuid> {
    if band <= 1 {
        return None;
    }
    quest_by_code(lookups, &format!("loop_task.loop.{n}.{band}"))
}

/// Selects the PROXIMATE (in-time) milestone tier for `type_` ("level"/"stage"):
/// the tier whose target is the SMALLEST strictly above the player's current
/// level/chapter, paced once per `frequency` core completions. The old
/// `last_milestone + 1` fixed-sequence selector decoupled the served tier from
/// real progress, so it either raced ahead ("Reach Level 28" handed to a level-12
/// player → blocks the single active slot) or lagged behind ("Clear Stage 1-7" at
/// stage 6-1 → stale/trivial). Proximate selection always serves the NEXT tier
/// just ahead — never stale, never far — so the milestone is achievable soon and
/// "feels great" when hit (user: "milestones are good IF in time"). The tier's
/// target lives in its `reach_level_<N>` / `reach_chapter_level_<N>` behavior
/// suffix. Tiers cap at level 50 / chapter 40, so milestones naturally phase out
/// before the late-game soft walls — no wall-blocking. `quantity` bounds the scan.
fn next_milestone(
    config: &GameConfig,
    lookups: &ContentLookups,
    character_state: &CharacterState,
    type_: &str,
    frequency: i64,
    quantity: i64,
) -> Option<Uuid> {
    let without = cv_i64(
        character_state,
        &format!("loop_tasks.without_milestone.{type_}"),
    );
    if without < frequency {
        return None;
    }
    let current = match type_ {
        "level" => character_state.character.character_level,
        "stage" => character_state.character.current_chapter_level,
        _ => return None,
    };
    let mut best: Option<(i64, Uuid)> = None;
    for n in 1..=quantity {
        let Some(qid) = quest_by_type_and_int(lookups, type_, n) else {
            continue;
        };
        let Some(target) = config
            .quest(qid)
            .and_then(|q| q.progress_behavior.as_deref())
            .and_then(parse_behavior_target)
        else {
            continue;
        };
        let better = match best {
            None => true,
            Some((bt, _)) => target < bt,
        };
        if target > current && better {
            best = Some((target, qid));
        }
    }
    best.map(|(_, qid)| qid)
}

/// Trailing integer of a `loop_task_reach_level_<N>` /
/// `loop_task_reach_chapter_level_<N>` behavior name — the milestone tier's
/// target level/chapter. `None` for any other shape (that tier is skipped).
fn parse_behavior_target(behavior: &str) -> Option<i64> {
    behavior.rsplit('_').next()?.parse().ok()
}

fn drain_random_i64(slots: &mut Vec<i64>, random: &GameRng) -> i64 {
    if slots.is_empty() {
        return 0;
    }
    let idx = random.randint(0, slots.len() as i64) as usize;
    slots.remove(idx)
}

// ---------------------------------------------------------------------------
// Native (Vec<OverlordEvent>) loop_tasks logic.
//
// `advance_loop` / `prepare_loop` / `on_finish_regular_loop_task`
// push into a plain `Vec<OverlordEvent>` (same branch order, same RNG draw
// ---------------------------------------------------------------------------

fn tick_milestone_native(
    events: &mut Vec<OverlordEvent>,
    character_state: &CharacterState,
    type_: &str,
) {
    let key = format!("loop_tasks.without_milestone.{type_}");
    let current = cv_i64(character_state, &key);
    events.push(set_custom_value(&key, current + 1));
}

/// Native port of the loop-task `advance_loop` logic.
pub fn advance_loop(
    events: &mut Vec<OverlordEvent>,
    config: &GameConfig,
    lookups: &ContentLookups,
    character_state: &CharacterState,
) {
    let last_loop_task = cv_i64(character_state, "loop_tasks.last");

    let arena_after = cv_opt(character_state, "loop_tasks.arena_after");
    let gold_after = cv_opt(character_state, "loop_tasks.gold_dungeon_after");
    let cookie_after = cv_opt(character_state, "loop_tasks.cookie_dungeon_after");

    let quest = if arena_after == Some(last_loop_task) {
        events.push(set_custom_value("loop_tasks.arena_after", 0));
        quest_by_type_and_number(lookups, "loop", "arena")
    } else if gold_after == Some(last_loop_task) {
        events.push(set_custom_value("loop_tasks.gold_dungeon_after", 0));
        quest_by_type_and_number(lookups, "loop", "gold_dungeon")
    } else if cookie_after == Some(last_loop_task) {
        events.push(set_custom_value("loop_tasks.cookie_dungeon_after", 0));
        quest_by_type_and_number(lookups, "loop", "cookie_dungeon")
    } else {
        None
    };

    if let Some(qid) = quest {
        events.push(OverlordEvent::NewQuests {
            quest_ids: vec![qid],
        });
        events.push(OverlordEvent::UpdateActiveLoopTaskId { quest_id: qid });
        tick_milestone_native(events, character_state, "stage");
        tick_milestone_native(events, character_state, "level");
        return;
    }

    if let Some(qid) = next_milestone(
        config,
        lookups,
        character_state,
        "level",
        LEVEL_MILESTONE_FREQUENCY,
        LEVEL_MILESTONE_QUANTITY,
    ) {
        events.push(OverlordEvent::NewQuests {
            quest_ids: vec![qid],
        });
        events.push(OverlordEvent::UpdateActiveLoopTaskId { quest_id: qid });
        events.push(set_custom_value("loop_tasks.without_milestone.level", 0));
        return;
    }
    if let Some(qid) = next_milestone(
        config,
        lookups,
        character_state,
        "stage",
        STAGE_MILESTONE_FREQUENCY,
        STAGE_MILESTONE_QUANTITY,
    ) {
        events.push(OverlordEvent::NewQuests {
            quest_ids: vec![qid],
        });
        events.push(OverlordEvent::UpdateActiveLoopTaskId { quest_id: qid });
        events.push(set_custom_value("loop_tasks.without_milestone.stage", 0));
        return;
    }

    let last_loop_task = cv_i64(character_state, "loop_tasks.last");
    let mut next_loop_task = last_loop_task + 1;

    // OVT-2405: skip the skill-gated loop slots (3 "Summon 10 Skills",
    // 5 "Upgrade a Skill", 7 "Spend 100 Gems" — gems are only spendable on
    // skills) until the player reaches
    // `navbar_navigation.skills_button_unlock_chapter`. Without this a player is
    // handed a skill task before skills exist and the loop hangs forever
    // (advance_loop only runs when the active task completes).
    //
    // Re-check after each bump, bounded by LOOP_TASK_QUANTITY, instead of a
    // single `+1` that assumed slots 1/4/6 are never gated and gated slots are
    // non-adjacent. That invariant is implicit, and a slot reorder (or two
    // adjacent gated slots) would let a single bump land on another gated slot
    // and re-introduce the hang — exactly the OVT-2405 failure class. The
    // bounded loop lands on a reachable slot for any layout.
    let skills_unlock_chapter = config
        .gatings
        .navbar_navigation
        .skills_button_unlock_chapter;
    let skills_locked = character_state.character.current_chapter_level < skills_unlock_chapter;
    for _ in 0..LOOP_TASK_QUANTITY {
        if next_loop_task > LOOP_TASK_QUANTITY {
            next_loop_task = 1;
        }
        if skills_locked && matches!(next_loop_task, 3 | 5 | 7) {
            next_loop_task += 1;
        } else {
            break;
        }
    }

    if next_loop_task > LOOP_TASK_QUANTITY {
        next_loop_task = 1;
    }

    // Scalable slots serve a size variant for the player's band (kill/chest/sell/
    // waves grow with progress); gated skill slots have no variant → base quest.
    let band = band_for_chapter(character_state.character.current_chapter_level);
    let qid = band_quest(lookups, next_loop_task, band)
        .or_else(|| quest_by_type_and_int(lookups, "loop", next_loop_task));
    if let Some(qid) = qid {
        events.push(set_custom_value("loop_tasks.last", next_loop_task));
        events.push(OverlordEvent::NewQuests {
            quest_ids: vec![qid],
        });
        events.push(OverlordEvent::UpdateActiveLoopTaskId { quest_id: qid });
        tick_milestone_native(events, character_state, "stage");
        tick_milestone_native(events, character_state, "level");
    }
}

/// Native port of the loop-task `prepare_loop` logic.
/// Consumes RNG in the IDENTICAL order (gold → cookie → blueprint slot draws).
pub fn prepare_loop(
    events: &mut Vec<OverlordEvent>,
    config: &GameConfig,
    character_state: &CharacterState,
    random: &GameRng,
) {
    let mut slots = vec![3i64, 5, 7];
    let chapter = character_state.character.current_chapter_level;

    let gold_chapter = config
        .dungeon_template(Uuid::parse_str(GOLD_DUNGEON_ID).unwrap())
        .map(|d| d.chapter_level_unlock)
        .unwrap_or(i64::MAX);
    let cookie_chapter = config
        .dungeon_template(Uuid::parse_str(COOKIE_DUNGEON_ID).unwrap())
        .map(|d| d.chapter_level_unlock)
        .unwrap_or(i64::MAX);
    let blueprint_chapter = config
        .dungeon_template(Uuid::parse_str(BLUEPRINT_DUNGEON_ID).unwrap())
        .map(|d| d.chapter_level_unlock)
        .unwrap_or(i64::MAX);

    if chapter >= gold_chapter {
        events.push(set_custom_value(
            "loop_tasks.gold_dungeon_after",
            drain_random_i64(&mut slots, random),
        ));
    }
    if chapter >= cookie_chapter {
        events.push(set_custom_value(
            "loop_tasks.cookie_dungeon_after",
            drain_random_i64(&mut slots, random),
        ));
    }
    if chapter >= blueprint_chapter {
        events.push(set_custom_value(
            "loop_tasks.blueprint_dungeon_after",
            drain_random_i64(&mut slots, random),
        ));
    }

    let arena_chapter = config
        .gatings
        .sidebar_navigation
        .arena_button_unlock_chapter;
    let arena_previous_task_index = 4;
    if chapter >= arena_chapter {
        events.push(set_custom_value(
            "loop_tasks.arena_after",
            arena_previous_task_index,
        ));
    }
}

pub fn on_finish_regular_loop_task(
    _events: &mut [OverlordEvent],
    _character_state: &CharacterState,
) {
}

#[cfg(test)]
mod tests {
    use super::*;
    use configs::tests_game_config::generate_game_config_for_tests;

    /// Drives `advance_loop` for a character whose previous loop task was
    /// `last_loop_task`, and returns the slot the run wrote to `loop_tasks.last`
    /// — i.e. the slot that was actually assigned. Registers a quest code for
    /// every slot 1..=7 so any landing slot (including the slot-7 -> wrap-to-1
    /// case) resolves to a quest.
    fn assigned_slot(
        skills_unlock_chapter: i64,
        current_chapter_level: i64,
        last_loop_task: i64,
    ) -> i64 {
        let mut config = generate_game_config_for_tests();
        config
            .gatings
            .navbar_navigation
            .skills_button_unlock_chapter = skills_unlock_chapter;

        let mut lookups = ContentLookups::default();
        for slot in 1..=LOOP_TASK_QUANTITY {
            // Distinct, deterministic UUID per slot.
            let id = Uuid::from_u128(slot as u128);
            lookups
                .quest_by_code
                .insert(format!("loop_task.loop.{slot}"), id);
        }

        let mut character_state = CharacterState::default();
        character_state.character.current_chapter_level = current_chapter_level;
        character_state
            .character
            .custom_values
            .0
            .insert("loop_tasks.last".to_string(), last_loop_task);

        let mut events = Vec::new();
        advance_loop(&mut events, &config, &lookups, &character_state);

        events
            .into_iter()
            .find_map(|e| match e {
                OverlordEvent::SetCustomValue { key, value } if key == "loop_tasks.last" => {
                    Some(value)
                }
                _ => None,
            })
            .expect("advance_loop should set loop_tasks.last")
    }

    #[test]
    fn skill_loop_task_skipped_below_unlock_chapter() {
        // Skills unlock at chapter 5; player is at chapter 1. Slot 3 (Summon
        // Skills) must be skipped to slot 4 so the loop never hangs.
        assert_eq!(assigned_slot(5, 1, 2), 4);
        // Slot 5 (Upgrade a Skill) likewise skips to slot 6.
        assert_eq!(assigned_slot(5, 1, 4), 6);
    }

    #[test]
    fn skill_loop_task_kept_at_unlock_chapter() {
        // At/above the unlock chapter the skill tasks are reachable, so they stay.
        assert_eq!(assigned_slot(5, 5, 2), 3);
        assert_eq!(assigned_slot(5, 5, 4), 5);
    }

    #[test]
    fn spend_gems_loop_task_skipped_below_unlock_chapter() {
        // Slot 7 (Spend 100 Gems) has no gem sink without skill access, so it is
        // skipped: 7 -> 8 -> wraps to slot 1.
        assert_eq!(assigned_slot(5, 1, 6), 1);
    }

    #[test]
    fn spend_gems_loop_task_kept_at_unlock_chapter() {
        // Once skills are unlocked, gems can be spent, so slot 7 stays.
        assert_eq!(assigned_slot(5, 5, 6), 7);
    }

    #[test]
    fn parse_behavior_target_reads_reach_thresholds() {
        // The proximate-milestone selector reads each tier's target from its
        // reach-level / reach-chapter behavior suffix.
        assert_eq!(parse_behavior_target("loop_task_reach_level_28"), Some(28));
        assert_eq!(
            parse_behavior_target("loop_task_reach_chapter_level_7"),
            Some(7)
        );
        assert_eq!(parse_behavior_target("loop_task_reach_level_50"), Some(50));
        // Non-reach behaviors have no numeric target → that tier is skipped.
        assert_eq!(parse_behavior_target("loop_task_pvp_win"), None);
        assert_eq!(parse_behavior_target("increment_one"), None);
    }

    #[test]
    fn band_scales_with_chapter() {
        // Scalable core tasks pick a larger size tier as the player advances.
        assert_eq!(band_for_chapter(1), 1);
        assert_eq!(band_for_chapter(15), 1);
        assert_eq!(band_for_chapter(16), 2);
        assert_eq!(band_for_chapter(40), 2);
        assert_eq!(band_for_chapter(41), 3);
        assert_eq!(band_for_chapter(90), 3);
        // Band 1 has no `.band` variant (uses the base quest); 2/3 do.
        let lookups = ContentLookups::default();
        assert_eq!(band_quest(&lookups, 2, 1), None);
        assert_eq!(band_quest(&lookups, 2, 2), None); // absent in empty lookups → caller falls back
    }
}