overlord_event_system/mechanics/

quest_board.rs

//! Daily-board / weekly-set selection.
//!
//! The daily board is a rotated subset of the authored daily pool: 8 quests
//! per day picked by category quotas, ONLY from objectives whose feature is
//! unlocked for this player (gate rule: never serve a quest the player cannot
//! complete — the served board is fully doable at any chapter), in the size
//! variant matching the player's chapter band. Selection is a pure,
//! deterministic function of (config, player, day index): the monolith calls
//! it at state load and at the lazy daily reset; there is no stored board.
//!
//! Code conventions (mirrored by the content generator):
//!   `daily.<category>.<objective>[.<band>]`   category ∈ combat|eco|prog|misc|meta
//!   `weekly.<objective>[.<band>]`
//! Band-1 quests have no band suffix (same rule as `loop_task.loop.<n>`).

use std::collections::HashMap;

use configs::game_config::GameConfig;
use essences::character_state::CharacterState;
use essences::quest::{QuestGroupType, QuestTemplate};
use uuid::Uuid;

/// Category quotas: 2 combat + 2 economy + 2 progression + 1 misc + 1 meta = 8.
const BOARD_QUOTAS: &[(&str, usize)] = &[
    ("combat", 2),
    ("eco", 2),
    ("prog", 2),
    ("misc", 1),
    ("meta", 1),
];
pub const BOARD_SIZE: usize = 8;

/// Chapter at which a quest's OBJECTIVE becomes completable, derived from what
/// the quest listens to — the objective's events imply the feature it needs.
/// Derivation (not a per-quest config field) keeps the map self-maintaining:
/// a new quest on the same events inherits the right gate automatically.
pub fn objective_gate_chapter(config: &GameConfig, tpl: &QuestTemplate) -> i64 {
    let g = &config.gatings;
    let behavior = tpl.progress_behavior.as_deref().unwrap_or("");
    if behavior.starts_with("raid_dungeon") {
        return g.navbar_navigation.dungeon_button_unlock_chapter;
    }
    if behavior.starts_with("pvp_") {
        return g.sidebar_navigation.arena_button_unlock_chapter;
    }
    let mut gate = 0i64;
    for ev in &tpl.events_subscribe {
        let ev_gate = match ev.as_str() {
            "RaidDungeon" => g.navbar_navigation.dungeon_button_unlock_chapter,
            "OpenAbilityCase" | "AbilityCaseOpened" | "UpgradedAbilities" | "UpgradeAbility"
            | "NewAbilities" => g.navbar_navigation.skills_button_unlock_chapter,
            "OpenPetCase" | "PetCaseOpened" | "UpgradedPets" | "UpgradePet" | "NewPets"
            | "EquipPet" => g.navbar_navigation.pets_button_unlock_chapter,
            "AfkRewardClaimed" | "ClaimAfkReward" => g.afk_rewards_button_unlock_chapter,
            "WatchAd" | "ShowBird" | "BirdShown" => g.daily_boost_button_unlock_chapter,
            _ => 0,
        };
        gate = gate.max(ev_gate);
    }
    gate
}

/// Same band grid as the loop pool (`loop_tasks::band_for_chapter`).
fn band_for_chapter(chapter: i64) -> i64 {
    if chapter < 16 {
        1
    } else if chapter <= 40 {
        2
    } else if chapter <= 80 {
        3
    } else {
        4
    }
}

/// Splits `daily.<cat>.<obj>[.<band>]` → (category, objective base code, band).
/// `weekly.<obj>[.<band>]` → (category="", base, band).
fn parse_code(code: &str) -> Option<(String, String, i64)> {
    let (prefix, rest) = code.split_once('.')?;
    let (cat, obj_part) = match prefix {
        "daily" => {
            let (cat, obj) = rest.split_once('.')?;
            (cat.to_string(), obj)
        }
        "weekly" => (String::new(), rest),
        _ => return None,
    };
    // A trailing numeric segment is the band; otherwise band 1. The objective
    // key keeps the category prefix (`combat.kill`) so objectives with the
    // same name in different categories can't collide in the variant map.
    let (obj, band) = match obj_part.rsplit_once('.') {
        Some((base, last)) if last.parse::<i64>().is_ok() => {
            (base.to_string(), last.parse::<i64>().unwrap())
        }
        _ => (obj_part.to_string(), 1),
    };
    let key = if cat.is_empty() {
        obj
    } else {
        format!("{cat}.{obj}")
    };
    Some((cat, key, band))
}

struct Candidate<'a> {
    tpl: &'a QuestTemplate,
    category: String,
    base: String,
    band: i64,
}

/// Gate-open candidates of `group`, one per objective: the best authored band
/// variant ≤ the player's band (falls back down when a higher band isn't
/// authored — same fallback rule as the loop pool's `band_quest`).
fn open_candidates<'a>(
    config: &'a GameConfig,
    character_state: &CharacterState,
    group: QuestGroupType,
    prefix: &str,
) -> Vec<Candidate<'a>> {
    let chapter = character_state.character.current_chapter_level;
    let player_band = band_for_chapter(chapter);
    let mut best: HashMap<String, Candidate<'a>> = HashMap::new();
    for tpl in config.quests.iter() {
        if tpl.quest_group_type != group {
            continue;
        }
        let Some(code) = tpl.code.as_deref() else {
            continue;
        };
        if !code.starts_with(prefix) {
            continue;
        }
        let Some((category, base, band)) = parse_code(code) else {
            continue;
        };
        if band > player_band || objective_gate_chapter(config, tpl) > chapter {
            continue;
        }
        match best.get(&base) {
            Some(cur) if cur.band >= band => {}
            _ => {
                best.insert(
                    base.clone(),
                    Candidate {
                        tpl,
                        category,
                        base,
                        band,
                    },
                );
            }
        }
    }
    let mut out: Vec<Candidate<'a>> = best.into_values().collect();
    // Deterministic order for rotation: by objective base code.
    out.sort_by(|a, b| a.base.cmp(&b.base));
    out
}

/// Today's daily board: quota-per-category rotation over the open pool,
/// deterministic in (player band/gates, `day_seed`). Shortfall in one
/// category is filled from the remaining open pool so the board reaches
/// [`BOARD_SIZE`] whenever enough objectives are open.
pub fn daily_board(
    config: &GameConfig,
    character_state: &CharacterState,
    day_seed: i64,
) -> Vec<Uuid> {
    let pool = open_candidates(config, character_state, QuestGroupType::Daily, "daily.");
    let mut picked: Vec<&Candidate> = Vec::with_capacity(BOARD_SIZE);
    for (cat, quota) in BOARD_QUOTAS {
        let members: Vec<&Candidate> = pool.iter().filter(|c| c.category == *cat).collect();
        if members.is_empty() {
            continue;
        }
        // Rotate the category window by the day: different objectives on
        // different days, all of them over a full cycle.
        let start = (day_seed.rem_euclid(members.len() as i64)) as usize;
        for k in 0..members.len().min(*quota) {
            picked.push(members[(start + k) % members.len()]);
        }
    }
    // Fill up to BOARD_SIZE from open objectives not yet on the board.
    for c in &pool {
        if picked.len() >= BOARD_SIZE {
            break;
        }
        if !picked.iter().any(|p| p.base == c.base) {
            picked.push(c);
        }
    }
    picked.truncate(BOARD_SIZE);
    picked.into_iter().map(|c| c.tpl.id).collect()
}

/// This week's weekly set: every gate-open objective in the band-matched
/// variant (no rotation — the weekly pool IS the set).
pub fn weekly_set(config: &GameConfig, character_state: &CharacterState) -> Vec<Uuid> {
    open_candidates(config, character_state, QuestGroupType::Weekly, "weekly.")
        .into_iter()
        .map(|c| c.tpl.id)
        .collect()
}

/// Whether `tpl` participates in board/set selection at all. Templates
/// WITHOUT a `daily.`/`weekly.` code keep the legacy always-served behavior —
/// deploy-order safety: until the coded content lands, boards fall back to
/// the current static sets.
pub fn is_board_managed(tpl: &QuestTemplate) -> bool {
    matches!(
        (&tpl.quest_group_type, tpl.code.as_deref()),
        (QuestGroupType::Daily, Some(c)) if c.starts_with("daily.")
    ) || matches!(
        (&tpl.quest_group_type, tpl.code.as_deref()),
        (QuestGroupType::Weekly, Some(c)) if c.starts_with("weekly.")
    )
}

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

    fn tpl(group: QuestGroupType, code: &str, events: &[&str], behavior: &str) -> QuestTemplate {
        QuestTemplate {
            id: Uuid::new_v4(),
            title: Default::default(),
            description: Default::default(),
            progress_behavior: Some(behavior.to_string()),
            progress_target: 1,
            quest_group_type: group,
            bundle_id: None,
            progression_points: 10,
            starting: false,
            next_quest_ids: vec![],
            events_subscribe: events.iter().map(|s| s.to_string()).collect(),
            additional_quests_behavior: None,
            progress_if_inactive: true,
            screen_reference: None,
            code: Some(code.to_string()),
        }
    }

    fn config_with_dailies() -> GameConfig {
        let mut config = generate_game_config_for_tests();
        config
            .gatings
            .navbar_navigation
            .skills_button_unlock_chapter = 11;
        config.gatings.navbar_navigation.pets_button_unlock_chapter = 16;
        config
            .gatings
            .navbar_navigation
            .dungeon_button_unlock_chapter = 20;
        config
            .gatings
            .sidebar_navigation
            .arena_button_unlock_chapter = 23;
        config.gatings.afk_rewards_button_unlock_chapter = 8;
        let d = QuestGroupType::Daily;
        config.quests = vec![
            tpl(d, "daily.combat.kill", &["EntityDeath"], "increment_one"),
            tpl(d, "daily.combat.kill.2", &["EntityDeath"], "increment_one"),
            tpl(d, "daily.combat.waves", &["WaveCleared"], "increment_one"),
            tpl(d, "daily.combat.boss", &["EndFight"], "boss_win"),
            tpl(d, "daily.combat.arena", &["EndFight"], "pvp_win"),
            tpl(
                d,
                "daily.combat.dungeon1",
                &["EndFight", "RaidDungeon"],
                "raid_dungeon_1",
            ),
            tpl(d, "daily.eco.open", &["OpenItemCase"], "increment_one"),
            tpl(d, "daily.eco.sell", &["SellItem"], "increment_one"),
            tpl(
                d,
                "daily.eco.summon_skills",
                &["AbilityCaseOpened"],
                "increment_by_batch_size",
            ),
            tpl(
                d,
                "daily.prog.level",
                &["NewCharacterLevel"],
                "increment_one",
            ),
            tpl(d, "daily.prog.equip", &["PlayerEquipItem"], "increment_one"),
            tpl(
                d,
                "daily.prog.case_step",
                &["ItemCaseUpgraded"],
                "increment_one",
            ),
            tpl(d, "daily.misc.login", &["PrepareFight"], "increment_one"),
            tpl(d, "daily.misc.afk", &["AfkRewardClaimed"], "increment_one"),
            tpl(
                d,
                "daily.meta.complete7",
                &["QuestCompleted"],
                "complete_daily_quest",
            ),
        ];
        config
    }

    fn state_at(chapter: i64) -> CharacterState {
        let mut s = CharacterState::default();
        s.character.current_chapter_level = chapter;
        s
    }

    #[test]
    fn early_board_contains_only_gate_open_objectives() {
        // ch3: dungeons(20)/arena(23)/skills(11)/afk(8) are locked — the board
        // must consist solely of gate-free objectives and still fill quotas
        // from them (this is the live-bug fix: today's static board hands a
        // ch3 player dungeon/arena/pet quests it cannot complete).
        let config = config_with_dailies();
        let state = state_at(3);
        let board = daily_board(&config, &state, 0);
        let locked: Vec<&str> = board
            .iter()
            .filter_map(|id| config.quests.iter().find(|q| q.id == *id))
            .filter(|q| objective_gate_chapter(&config, q) > 3)
            .filter_map(|q| q.code.as_deref())
            .collect();
        assert!(locked.is_empty(), "locked objectives on board: {locked:?}");
        assert!(!board.is_empty());
    }

    #[test]
    fn band_variant_matches_player_band() {
        let config = config_with_dailies();
        // ch25 = band 2 → the `kill` objective must resolve to its `.2`
        // variant in the candidate pool (whatever the day's rotation later
        // picks); a band-1 player resolves the same objective to the base.
        let cand_b2 = open_candidates(&config, &state_at(25), QuestGroupType::Daily, "daily.");
        let kill_b2 = cand_b2.iter().find(|c| c.base == "combat.kill").unwrap();
        assert_eq!(kill_b2.band, 2);
        assert_eq!(kill_b2.tpl.code.as_deref(), Some("daily.combat.kill.2"));

        let cand_b1 = open_candidates(&config, &state_at(3), QuestGroupType::Daily, "daily.");
        let kill_b1 = cand_b1.iter().find(|c| c.base == "combat.kill").unwrap();
        assert_eq!(kill_b1.band, 1);
    }

    #[test]
    fn rotation_changes_the_board_between_days() {
        let config = config_with_dailies();
        let state = state_at(25);
        let day0 = daily_board(&config, &state, 0);
        let day1 = daily_board(&config, &state, 1);
        assert_ne!(day0, day1, "rotation must vary the board across days");
        // Deterministic: same day → same board.
        assert_eq!(day0, daily_board(&config, &state, 0));
    }

    #[test]
    fn board_is_capped_and_meta_is_always_served() {
        let config = config_with_dailies();
        let board = daily_board(&config, &state_at(25), 3);
        assert!(board.len() <= BOARD_SIZE);
        let meta = config
            .quests
            .iter()
            .find(|q| q.code.as_deref() == Some("daily.meta.complete7"))
            .unwrap()
            .id;
        assert!(board.contains(&meta), "meta quest must be on every board");
    }

    #[test]
    fn uncoded_templates_stay_legacy_served() {
        // Deploy-order safety: a Daily template without a `daily.` code is not
        // board-managed (the static legacy set keeps serving it).
        let legacy = tpl(
            QuestGroupType::Daily,
            "something_else",
            &[],
            "increment_one",
        );
        assert!(!is_board_managed(&legacy));
        let coded = tpl(
            QuestGroupType::Daily,
            "daily.misc.login",
            &[],
            "increment_one",
        );
        assert!(is_board_managed(&coded));
    }
}