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;

// Milestones come every 5 completions: at the target cadence (~4-6 clears/day
// + loop churn) a wider spacing lets whole sessions pass without an
// acknowledged milestone. Quantities bound the tier
// scan; ladders extend to level 80 / chapter 80 (missing tiers are skipped
// gracefully, so the bound is safe to raise before the content lands).
const LEVEL_MILESTONE_FREQUENCY: i64 = 5;
const LEVEL_MILESTONE_QUANTITY: i64 = 18;
const STAGE_MILESTONE_FREQUENCY: i64 = 5;
const STAGE_MILESTONE_QUANTITY: i64 = 19;

/// The regular loop-task chain draws from this POOL of micro-tasks (not a
/// fixed ring). Ids 1-7 keep
/// the legacy ring meanings (their content is live): 1 chest-opens, 2 kills,
/// 3 skill summons, 4 sells, 5 skill upgrade, 6 waves, 7 spend-gems. Catalog
/// additions: 8 boss win, 9 pet summon, 10 pet upgrade, 11 equip items,
/// 12 start a chest-ladder step. An AFK-claim task is deliberately ABSENT — in a
/// single-active-slot chain it is stall-prone (accrual takes hours) and the
/// same objective already exists as a daily.
const LOOP_POOL: &[i64] = &[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];

// Currency uuids for doability bank checks (stable content ids, same ones the
// deploy-time validator asserts quest content against).
const GEMS_CURRENCY: u128 = 0x0194d64e_2162_76d3_8449_3e850f6e39e9;
const SC_CURRENCY: u128 = 0x0195964c_61d6_7340_9748_32a3a4b1cd57;
const BEAST_TOKEN_CURRENCY: u128 = 0x019cdc54_eae4_73c2_840b_e78dfe947141;

/// A boss task is servable when the front boss is not hopeless (power within
/// this fraction of the front chapter's enemy power — well below the sigmoid
/// crossing ~0.29-0.35, so only truly unwinnable states are filtered) OR when
/// dungeons are open (dungeon bosses are re-fightable at chosen difficulty).
const BOSS_WINNABLE_RATIO: f64 = 0.2;

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 if chapter <= 80 {
        3
    } else {
        4
    }
}

/// Balance of currency `id` in the character's wallet (0 when absent).
fn currency_balance(character_state: &CharacterState, id: Uuid) -> i64 {
    character_state
        .currencies
        .iter()
        .find(|c| c.currency_id == id)
        .map_or(0, |c| c.amount)
}

/// «Запусти ступень честа» is servable only when the step can be STARTED right
/// now: no upgrade already running, the next ladder level exists, its chapter
/// requirement is met, and the wallet covers the full cost. Anything else
/// would park the single active slot on an hours-long wait.
fn case_step_startable(config: &GameConfig, character_state: &CharacterState) -> bool {
    if character_state
        .character
        .item_case_upgrade_finish_at
        .is_some()
    {
        return false;
    }
    // Players start at case level 1; a raw 0 (uninitialized) must not resolve
    // to "upgrade to level 1", whose ladder row has no cost.
    let next_level = character_state.character.item_case_level.max(1) + 1;
    let chapter = character_state.character.current_chapter_level;
    config
        .item_cases_settings
        .iter()
        .find(|s| s.level == next_level)
        .is_some_and(|s| {
            s.required_chapter_level <= chapter
                && s.upgrade_cost
                    .iter()
                    .all(|c| currency_balance(character_state, c.currency_id) >= c.amount)
        })
}

/// DOABILITY predicate of a pool task: can the player complete it RIGHT NOW by
/// playing? A task that fails this is skipped by the pool walk — the chain must
/// never park on an impossible objective (the OVT-2405 hang class, generalized
/// from the hardcoded skill-slot skip to every task). Tasks 1/2/6 are the
/// always-doable anchors (chest opens self-fund via kill drops; kills and
/// waves are the core activity), so the walk always terminates.
fn loop_task_doable(task: i64, config: &GameConfig, character_state: &CharacterState) -> bool {
    let chapter = character_state.character.current_chapter_level;
    let g = &config.gatings;
    let skills_open = chapter >= g.navbar_navigation.skills_button_unlock_chapter;
    let pets_open = chapter >= g.navbar_navigation.pets_button_unlock_chapter;
    let bal = |id: u128| currency_balance(character_state, Uuid::from_u128(id));
    match task {
        1 | 2 | 6 => true,
        // One ability-gacha roll costs 10 SC.
        3 => skills_open && bal(SC_CURRENCY) >= 10,
        // Selling needs something unequipped to sell.
        4 => character_state.inventory.iter().any(|i| !i.is_equipped),
        // An upgrade is possible when some owned ability has enough shards
        // (L→L+1 costs L shards).
        5 => {
            skills_open
                && character_state
                    .all_abilities
                    .iter()
                    .any(|a| a.shards_amount >= a.level)
        }
        // Gems are only spendable once skills exist (the legacy slot-7 rule).
        7 => skills_open && bal(GEMS_CURRENCY) >= 100,
        // Boss: front boss not hopeless, or dungeon bosses available.
        8 => {
            let dungeons_open = chapter >= g.navbar_navigation.dungeon_button_unlock_chapter;
            // The BAL-037 signed curve covers ch0, so no clamp to ch1 is needed
            // (the old clamp read the ch0 boss as roughly twice its power).
            let front_enemy = crate::mechanics::balance::enemy_power_for_chapter(chapter.max(0));
            dungeons_open
                || (character_state.character.power as f64) >= BOSS_WINNABLE_RATIO * front_enemy
        }
        // One pet-gacha roll costs 1 Beast token.
        9 => pets_open && bal(BEAST_TOKEN_CURRENCY) >= 1,
        // Pet upgrade proxy: owns a pet and holds at least one token.
        10 => pets_open && !character_state.all_pets.is_empty() && bal(BEAST_TOKEN_CURRENCY) >= 1,
        11 => !character_state.inventory.is_empty(),
        12 => case_step_startable(config, character_state),
        _ => false,
    }
}

/// 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 blueprint_after = cv_opt(character_state, "loop_tasks.blueprint_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 if blueprint_after == Some(last_loop_task) {
        // Pre-existing bug (fixed with pool v2): `prepare_loop` scheduled the
        // blueprint-dungeon insert but `advance_loop` never consumed it — the
        // Hidden Cove loop task could not be served at all.
        events.push(set_custom_value("loop_tasks.blueprint_dungeon_after", 0));
        quest_by_type_and_number(lookups, "loop", "blueprint_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");

    // Pool v2 walk: start after the last served task's pool position and take
    // the first task whose gate AND doability checks pass. Deterministic (no
    // RNG), inherently no-repeat (the walk moves forward through the pool),
    // and hang-free: the always-doable anchors (1/2/6) guarantee termination
    // for ANY wallet/inventory state — the generalized OVT-2405 guarantee.
    let start = LOOP_POOL
        .iter()
        .position(|&t| t == last_loop_task)
        .map(|p| p + 1)
        .unwrap_or(0);
    let mut next_loop_task = None;
    for offset in 0..LOOP_POOL.len() {
        let task = LOOP_POOL[(start + offset) % LOOP_POOL.len()];
        // A task is a candidate only if its content actually exists (deploy
        // order safety: this Rust can ship before the new pool quests land —
        // the pool then degrades to the authored subset instead of serving a
        // code that resolves to no quest and hanging the chain).
        let authored = quest_by_type_and_int(lookups, "loop", task).is_some();
        if authored && loop_task_doable(task, config, character_state) {
            next_loop_task = Some(task);
            break;
        }
    }
    let Some(next_loop_task) = next_loop_task else {
        return; // unreachable with the anchor tasks; defensive
    };

    // Every pool task serves the size variant for the player's band
    // (`loop_task.loop.<n>.<band>`), falling back to the base quest when the
    // variant isn't authored (band 1 and not-yet-banded content).
    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;
    use essences::currency::CurrencyUnit;

    /// Test config with all pool-relevant gates at explicit chapters.
    fn pool_config(skills: i64, pets: i64, dungeon: i64) -> GameConfig {
        let mut config = generate_game_config_for_tests();
        config
            .gatings
            .navbar_navigation
            .skills_button_unlock_chapter = skills;
        config.gatings.navbar_navigation.pets_button_unlock_chapter = pets;
        config
            .gatings
            .navbar_navigation
            .dungeon_button_unlock_chapter = dungeon;
        config
    }

    fn state_at(chapter: i64, last_loop_task: i64) -> CharacterState {
        let mut character_state = CharacterState::default();
        character_state.character.current_chapter_level = chapter;
        character_state
            .character
            .custom_values
            .0
            .insert("loop_tasks.last".to_string(), last_loop_task);
        character_state
    }

    fn give_currency(character_state: &mut CharacterState, id: u128, amount: i64) {
        character_state.currencies.push(CurrencyUnit {
            currency_id: Uuid::from_u128(id),
            amount,
        });
    }

    /// Drives `advance_loop` and returns the pool task written to
    /// `loop_tasks.last` — i.e. the task actually assigned. Registers a quest
    /// code for every pool task so any landing task resolves to a quest.
    fn assigned_task(config: &GameConfig, character_state: &CharacterState) -> i64 {
        let mut lookups = ContentLookups::default();
        for &task in LOOP_POOL {
            lookups.quest_by_code.insert(
                format!("loop_task.loop.{task}"),
                Uuid::from_u128(task as u128),
            );
        }
        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 empty_state_skips_bank_gated_tasks_to_anchor() {
        // Skills locked, empty wallet/inventory: after task 2 the walk skips
        // 3 (skills), 4 (nothing to sell), 5 (skills) and lands on anchor 6.
        let config = pool_config(11, 16, 20);
        assert_eq!(assigned_task(&config, &state_at(1, 2)), 6);
    }

    #[test]
    fn bank_funded_skill_summon_is_served_at_unlock() {
        // Skills open and the wallet covers one gacha roll → task 3 stays.
        let config = pool_config(11, 16, 20);
        let mut state = state_at(11, 2);
        give_currency(&mut state, SC_CURRENCY, 10);
        assert_eq!(assigned_task(&config, &state), 3);
    }

    #[test]
    fn skill_summon_skipped_without_bank_even_at_unlock() {
        // Skills open but 0 SC: serving «Призови скиллы» would hang the chain
        // — the doability check must skip it exactly like a closed gate.
        let config = pool_config(11, 16, 20);
        assert_eq!(assigned_task(&config, &state_at(11, 2)), 6);
    }

    #[test]
    fn gems_task_served_only_with_balance() {
        let config = pool_config(11, 16, 20);
        // After 6: task 7 needs skills open AND ≥100 gems.
        let mut rich = state_at(11, 6);
        give_currency(&mut rich, GEMS_CURRENCY, 150);
        assert_eq!(assigned_task(&config, &rich), 7);
        // Without gems the walk skips 7; 8 (boss) is doable here because
        // dungeons are open at ch20+... at ch11 they are not, and power 0 is
        // hopeless vs the front curve → skips to 9/10 (no pets/tokens), 11
        // (no items), 13 (no ladder in test config) → wraps to anchor 1.
        assert_eq!(assigned_task(&config, &state_at(11, 6)), 1);
    }

    #[test]
    fn boss_task_served_when_dungeons_open() {
        // Dungeon bosses are re-fightable → the boss task is always doable
        // once dungeons unlock, regardless of front-boss odds.
        let config = pool_config(11, 16, 20);
        assert_eq!(assigned_task(&config, &state_at(25, 7)), 8);
    }

    #[test]
    fn pool_never_hangs_from_any_position_with_empty_state() {
        // The generalized OVT-2405 guarantee: for ANY previous task and a
        // fully empty state, the walk terminates on an always-doable anchor.
        let config = pool_config(11, 16, 20);
        for &last in LOOP_POOL {
            let task = assigned_task(&config, &state_at(1, last));
            assert!(
                matches!(task, 1 | 2 | 6),
                "from last={last} landed on {task}, expected an anchor"
            );
        }
    }

    #[test]
    fn pool_wraps_after_the_last_task() {
        let config = pool_config(11, 16, 20);
        assert_eq!(assigned_task(&config, &state_at(1, 12)), 1);
    }

    #[test]
    fn unauthored_pool_tasks_are_skipped() {
        // Deploy-order safety: with ONLY the legacy 1-7 content authored, the
        // walk must never select 8-13 (their codes resolve to no quest) —
        // e.g. after 7 it lands on an authored, doable task instead.
        let config = pool_config(11, 16, 20);
        let mut lookups = ContentLookups::default();
        for task in 1..=7i64 {
            lookups.quest_by_code.insert(
                format!("loop_task.loop.{task}"),
                Uuid::from_u128(task as u128),
            );
        }
        let mut events = Vec::new();
        advance_loop(&mut events, &config, &lookups, &state_at(25, 7));
        let assigned = 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");
        assert!(
            (1..=7).contains(&assigned),
            "landed on unauthored task {assigned}"
        );
    }

    #[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 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(80), 3);
        assert_eq!(band_for_chapter(81), 4);
        assert_eq!(band_for_chapter(120), 4);
        // Band 1 has no `.band` variant (uses the base quest).
        let lookups = ContentLookups::default();
        assert_eq!(band_quest(&lookups, 2, 1), None);
        assert_eq!(band_quest(&lookups, 2, 2), None); // absent → caller falls back
    }
}