overlord_event_system/behaviors/quests/

progress.rs

//! Native functions for the `conditional_progress` category — quest progress
//! behaviors (`QuestTemplate::progress_behavior`). Output is the new `i64`
//! progress value assigned to `QuestInstance::current`.
//!
//! Quest progress collapses to ~12 patterns; per-quest constants (level
//! thresholds, dungeon/currency/rarity ids) are const parameters of generic
//! fns, registered once per shipped constant. Content uuids baked into
//! patterns are exported as consts and validated against the config at deploy
//! time (see [`super::validate`]).

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

use crate::behaviors::{BehaviorKind, BehaviorMeta, BehaviorRegistry};
use crate::event::OverlordEvent;
use crate::game_config_helpers::GameConfigLookup;
use crate::mechanics::content_lookups::ContentLookups;

/// Inputs available to a `conditional_progress` native fn.
pub struct ConditionalProgressCtx<'a> {
    /// The trigger event.
    pub event: &'a OverlordEvent,
    pub character_state: &'a CharacterState,
    /// `None` when no fight is active.
    pub active_fight: &'a Option<ActiveFight>,
    /// The live quest instance (`quest.current` is the prior progress).
    pub quest: &'a QuestInstance,
    pub config: &'a GameConfig,
    pub lookups: &'a ContentLookups,
}

/// Signature of a `conditional_progress` native fn. Captureless `fn` so it is
/// `Copy` and storable in the registry; context arrives via
/// [`ConditionalProgressCtx`].
pub type ConditionalProgressFn = fn(&ConditionalProgressCtx) -> anyhow::Result<i64>;

// Content uuids baked into progress patterns. Exported so the deploy-time
// validator can assert each exists in the config a referencing quest ships in.
pub const DUNGEON_1: u128 = 0x019a9206_800b_781e_8998_38cdc6e9826e;
pub const DUNGEON_2: u128 = 0x019aee96_7303_7d3e_a382_d7776687d24f;
pub const DUNGEON_3: u128 = 0x019d2eca_9508_71c9_abb3_a6fc17474502;
pub const COLLECT_CURRENCY: u128 = 0x0194d64e_2162_76d3_8449_3e850f6e39e9;
pub const RARITY_A: u128 = 0x0194d64e_2179_797b_90fe_8b783f349203;
pub const RARITY_B: u128 = 0x0194d64e_2179_797b_90fe_8b799ae7a867;
pub const RARITY_C: u128 = 0x0194d64e_2179_797b_90fe_8b7ad369fd71;
pub const LOG_IN_QUEST: u128 = 0x019c2b16_a454_737b_b5b5_1123073e2fce;

const COMPLETE_ALL_LOOP_TASKS: &str = "CompleteAllLoopTasks";

/// Custom event with the given subtype.
fn is_custom_event(event: &OverlordEvent, ev: &str) -> bool {
    matches!(event, OverlordEvent::CustomEvent { event_type, .. } if event_type == ev)
}

/// Custom event of any subtype.
fn is_custom_event_any(event: &OverlordEvent) -> bool {
    matches!(event, OverlordEvent::CustomEvent { .. })
}

// === Pattern 1: unconditional increment ====================================

/// `quest.current + 1`.
pub fn increment_one(ctx: &ConditionalProgressCtx) -> anyhow::Result<i64> {
    Ok(ctx.quest.current + 1)
}

// === Pattern 2: increment by batch_size =====================================

/// `quest.current + event.batch_size`.
pub fn increment_by_batch_size(ctx: &ConditionalProgressCtx) -> anyhow::Result<i64> {
    let batch = event_batch_size(ctx.event)?;
    Ok(ctx.quest.current + batch)
}

/// `Event.batch_size` from whichever variant carries it; an event without one
/// is an error (the slot is misconfigured for that subscription).
fn event_batch_size(event: &OverlordEvent) -> anyhow::Result<i64> {
    match event {
        OverlordEvent::OpenItemCase { batch_size } => Ok(*batch_size),
        OverlordEvent::AutoChestOpenItemCase { batch_size } => Ok(*batch_size),
        OverlordEvent::UpdateAutoChestBatchSize { batch_size } => Ok(*batch_size),
        OverlordEvent::AbilityCaseOpened { batch_size } => Ok(*batch_size as i64),
        OverlordEvent::PetCaseOpened { batch_size } => Ok(*batch_size as i64),
        other => Err(anyhow::anyhow!("event {other:?} has no batch_size")),
    }
}

// === Pattern 2b: loop-task-aware variants of patterns 1/2 ===================

/// Loop-task-aware `+1`: `CompleteAllLoopTasks` → `N` (the completion target),
/// other custom events → unchanged, else `+1`.
pub fn loop_task_increment_one<const N: i64>(ctx: &ConditionalProgressCtx) -> anyhow::Result<i64> {
    if is_custom_event_any(ctx.event) {
        if is_custom_event(ctx.event, COMPLETE_ALL_LOOP_TASKS) {
            return Ok(N);
        }
        return Ok(ctx.quest.current);
    }
    Ok(ctx.quest.current + 1)
}

/// Loop-task-aware `+batch_size` with completion value `N`.
pub fn loop_task_increment_batch<const N: i64>(
    ctx: &ConditionalProgressCtx,
) -> anyhow::Result<i64> {
    if is_custom_event_any(ctx.event) {
        if is_custom_event(ctx.event, COMPLETE_ALL_LOOP_TASKS) {
            return Ok(N);
        }
        return Ok(ctx.quest.current);
    }
    let batch = event_batch_size(ctx.event)?;
    Ok(ctx.quest.current + batch)
}

// === Pattern 3: reach character level =======================================

fn event_level(event: &OverlordEvent) -> anyhow::Result<i64> {
    match event {
        OverlordEvent::NewCharacterLevel { level } => Ok(*level),
        other => Err(anyhow::anyhow!("event {other:?} has no level")),
    }
}

/// `event.level >= T ? 1 : 0` (no loop-task guard).
pub fn reach_level<const T: i64>(ctx: &ConditionalProgressCtx) -> anyhow::Result<i64> {
    let level = event_level(ctx.event)?;
    Ok(if level >= T { 1 } else { 0 })
}

/// Loop-task-guarded reach-level: `CompleteAllLoopTasks` → 1, other custom
/// events → unchanged, else `event.level >= T ? 1 : 0`.
pub fn loop_task_reach_level<const T: i64>(ctx: &ConditionalProgressCtx) -> anyhow::Result<i64> {
    if is_custom_event_any(ctx.event) {
        if is_custom_event(ctx.event, COMPLETE_ALL_LOOP_TASKS) {
            return Ok(1);
        }
        return Ok(ctx.quest.current);
    }
    let level = event_level(ctx.event)?;
    Ok(if level >= T { 1 } else { 0 })
}

// === Pattern 4: reach chapter level ==========================================

/// `character.current_chapter_level >= T ? 1 : 0` (no guard).
pub fn reach_chapter_level<const T: i64>(ctx: &ConditionalProgressCtx) -> anyhow::Result<i64> {
    let chapter = ctx.character_state.character.current_chapter_level;
    Ok(if chapter >= T { 1 } else { 0 })
}

/// `character.current_chapter_level` (raw, monotonic). Paired with a quest whose
/// `progress_target` is the TARGET chapter, so the quest completes exactly when
/// the player reaches that chapter — one behavior gates ANY chapter without a
/// per-threshold const registration (`active_quest.current = progress`, so
/// `is_completed` is `current_chapter >= progress_target`). Used by the
/// progress-pass (trophy road) tiers, which span the whole game (chapter-level
/// 20→115; the pass button itself unlocks at chapter-level 20 per
/// `gatings.progress_pass_button_unlock_chapter`).
pub fn current_chapter_level(ctx: &ConditionalProgressCtx) -> anyhow::Result<i64> {
    Ok(ctx.character_state.character.current_chapter_level)
}

/// Loop-task-guarded reach-chapter-level.
pub fn loop_task_reach_chapter_level<const T: i64>(
    ctx: &ConditionalProgressCtx,
) -> anyhow::Result<i64> {
    if is_custom_event_any(ctx.event) {
        if is_custom_event(ctx.event, COMPLETE_ALL_LOOP_TASKS) {
            return Ok(1);
        }
        return Ok(ctx.quest.current);
    }
    let chapter = ctx.character_state.character.current_chapter_level;
    Ok(if chapter >= T { 1 } else { 0 })
}

// === Pattern 5: PvP win counter ==============================================

/// Pure decision for the PvP-win counter: a player-**won** (`is_win`) PvP
/// (`is_pvp`) `EndFight` advances the counter by one; a loss, a PvE fight, or a
/// non-fight event leaves it unchanged. Extracted from `pvp_win` /
/// `loop_task_pvp_win` so the win/loss gate is unit-testable without a full
/// `ConditionalProgressCtx` (which needs a `GameConfig`).
fn pvp_win_increment(is_win: bool, is_pvp: bool, current: i64) -> i64 {
    if is_win && is_pvp {
        current + 1
    } else {
        current
    }
}

/// Destructure an event into the `(is_win, is_pvp)` pair the win counter cares
/// about; any non-`EndFight` event is neither a win nor a PvP fight.
fn pvp_win_signal(event: &OverlordEvent) -> (bool, bool) {
    match event {
        OverlordEvent::EndFight {
            is_win, pvp_state, ..
        } => (*is_win, pvp_state.is_some()),
        _ => (false, false),
    }
}

/// `EndFight` that the player **won** in a PvP fight → +1, else unchanged. The
/// `is_win` gate is what distinguishes a "Win in the Arena" objective from mere
/// participation — without it a loss would (wrongly) count as a win.
pub fn pvp_win(ctx: &ConditionalProgressCtx) -> anyhow::Result<i64> {
    let (is_win, is_pvp) = pvp_win_signal(ctx.event);
    Ok(pvp_win_increment(is_win, is_pvp, ctx.quest.current))
}

/// Loop-task-guarded PvP win. A `CompleteAllLoopTasks` custom event force-
/// completes; otherwise the same player-won-PvP gate as [`pvp_win`].
pub fn loop_task_pvp_win(ctx: &ConditionalProgressCtx) -> anyhow::Result<i64> {
    if is_custom_event(ctx.event, COMPLETE_ALL_LOOP_TASKS) {
        return Ok(1);
    }
    let (is_win, is_pvp) = pvp_win_signal(ctx.event);
    Ok(pvp_win_increment(is_win, is_pvp, ctx.quest.current))
}

// === Pattern 6: raid a specific dungeon ======================================

/// +1 on a `RaidDungeon` event for dungeon `D`, or while the active fight is in
/// dungeon `D`; otherwise unchanged.
pub fn raid_dungeon<const D: u128>(ctx: &ConditionalProgressCtx) -> anyhow::Result<i64> {
    let dungeon = Uuid::from_u128(D);
    if let OverlordEvent::RaidDungeon { dungeon_id, .. } = ctx.event {
        if *dungeon_id == dungeon {
            return Ok(ctx.quest.current + 1);
        }
        return Ok(ctx.quest.current);
    }
    let Some(fight) = ctx.active_fight else {
        return Ok(ctx.quest.current);
    };
    if fight.dungeon.as_ref().map(|d| d.id) == Some(dungeon) {
        return Ok(ctx.quest.current + 1);
    }
    Ok(ctx.quest.current)
}

/// Loop-task-guarded dungeon raid.
pub fn loop_task_raid_dungeon<const D: u128>(ctx: &ConditionalProgressCtx) -> anyhow::Result<i64> {
    if is_custom_event_any(ctx.event) {
        if is_custom_event(ctx.event, COMPLETE_ALL_LOOP_TASKS) {
            return Ok(1);
        }
        return Ok(ctx.quest.current);
    }
    raid_dungeon::<D>(ctx)
}

// === Pattern 7: complete a quest of a given group type ======================

/// `Event.quest_id` — resolves for any event variant carrying a `quest_id`.
fn event_quest_id(event: &OverlordEvent) -> anyhow::Result<Uuid> {
    match event {
        OverlordEvent::ClaimQuest { quest_id, .. }
        | OverlordEvent::PatronQuestCompleted { quest_id, .. }
        | OverlordEvent::HiddenQuestCompleted { quest_id, .. }
        | OverlordEvent::QuestCompleted { quest_id, .. }
        | OverlordEvent::UpdateActiveLoopTaskId { quest_id, .. } => Ok(*quest_id),
        other => Err(anyhow::anyhow!("event {other:?} has no quest_id")),
    }
}

/// `+1` when the event's referenced quest is of `group` group type.
fn complete_quest_of_group(
    ctx: &ConditionalProgressCtx,
    group: QuestGroupType,
) -> anyhow::Result<i64> {
    let quest_id = event_quest_id(ctx.event)?;
    let tpl = ctx
        .config
        .quest(quest_id)
        .ok_or_else(|| anyhow::anyhow!("quest {quest_id} not found"))?;
    if tpl.quest_group_type == group {
        return Ok(ctx.quest.current + 1);
    }
    Ok(ctx.quest.current)
}

pub fn complete_daily_quest(ctx: &ConditionalProgressCtx) -> anyhow::Result<i64> {
    complete_quest_of_group(ctx, QuestGroupType::Daily)
}
pub fn complete_weekly_quest(ctx: &ConditionalProgressCtx) -> anyhow::Result<i64> {
    complete_quest_of_group(ctx, QuestGroupType::Weekly)
}
pub fn complete_loop_task_quest(ctx: &ConditionalProgressCtx) -> anyhow::Result<i64> {
    complete_quest_of_group(ctx, QuestGroupType::LoopTask)
}

// === Pattern 8: collect a currency amount ===================================

/// `CompleteAllLoopTasks` → 100; other custom events → unchanged; otherwise
/// `quest.current + amount` of the target currency in the event's currency
/// list, or 0 when the currency isn't present (preserved from the shipped
/// behavior — note: 0, not `quest.current`).
pub fn loop_task_collect_currency(ctx: &ConditionalProgressCtx) -> anyhow::Result<i64> {
    if is_custom_event_any(ctx.event) {
        if is_custom_event(ctx.event, COMPLETE_ALL_LOOP_TASKS) {
            return Ok(100);
        }
        return Ok(ctx.quest.current);
    }
    let target = Uuid::from_u128(COLLECT_CURRENCY);
    let currencies: &[essences::currency::CurrencyUnit] = match ctx.event {
        OverlordEvent::CurrencyIncrease { currencies, .. } => currencies,
        OverlordEvent::CurrencyDecrease { currencies, .. } => currencies,
        other => return Err(anyhow::anyhow!("event {other:?} has no currencies")),
    };
    for unit in currencies {
        if unit.currency_id == target {
            return Ok(ctx.quest.current + unit.amount);
        }
    }
    Ok(0)
}

// === Pattern 9: upgraded-abilities delta sum ================================

/// `quest.current + Σ (final - current)` over `event.upgraded_abilities`.
pub fn upgraded_abilities_delta(ctx: &ConditionalProgressCtx) -> anyhow::Result<i64> {
    let OverlordEvent::UpgradedAbilities { upgraded_abilities } = ctx.event else {
        return Err(anyhow::anyhow!(
            "event {:?} has no upgraded_abilities",
            ctx.event
        ));
    };
    let mut result: i64 = 0;
    for (_ability_id, (current, final_)) in upgraded_abilities.0.iter() {
        result += final_ - current;
    }
    Ok(ctx.quest.current + result)
}

// === Pattern 10: count equipped items at/above a target rarity ==============

/// On `PlayerEquipItem`: the number of equipped inventory items whose rarity
/// `q` is at least the target rarity `R`'s `q`; other events leave progress
/// unchanged.
pub fn count_equipped_at_rarity<const R: u128>(
    ctx: &ConditionalProgressCtx,
) -> anyhow::Result<i64> {
    let target_id = Uuid::from_u128(R);
    let target_q = ctx
        .lookups
        .item_rarity_q
        .get(&target_id)
        .copied()
        .ok_or_else(|| anyhow::anyhow!("no q for rarity {target_id}"))?;

    if !matches!(ctx.event, OverlordEvent::PlayerEquipItem { .. }) {
        return Ok(ctx.quest.current);
    }

    let mut res = 0i64;
    for item in &ctx.character_state.inventory {
        if !item.is_equipped {
            continue;
        }
        let rarity_q = ctx
            .lookups
            .item_rarity_q
            .get(&item.rarity.id)
            .copied()
            .ok_or_else(|| anyhow::anyhow!("no q for item rarity {}", item.rarity.id))?;
        if rarity_q >= target_q {
            res += 1;
        }
    }
    Ok(res)
}

// === Pattern 11: constant ===================================================

/// Always 1.
pub fn always_one(_ctx: &ConditionalProgressCtx) -> anyhow::Result<i64> {
    Ok(1)
}

// === Pattern 12: log-in-today daily =========================================

/// +1 when the event references the log-in daily quest.
pub fn log_in_today(ctx: &ConditionalProgressCtx) -> anyhow::Result<i64> {
    let quest_id = event_quest_id(ctx.event)?;
    if quest_id == Uuid::from_u128(LOG_IN_QUEST) {
        return Ok(ctx.quest.current + 1);
    }
    Ok(ctx.quest.current)
}

// === Test fixtures (tests_game_config.rs) ===================================

/// level 1 → 1, level 2 → 2, otherwise 0.
pub fn quest_event_level_1_then_2(ctx: &ConditionalProgressCtx) -> anyhow::Result<i64> {
    let level = event_level(ctx.event)?;
    Ok(match level {
        1 => 1,
        2 => 2,
        _ => 0,
    })
}

/// current 0 → 1, otherwise 2.
pub fn quest_current_0_then_1_else_2(ctx: &ConditionalProgressCtx) -> anyhow::Result<i64> {
    Ok(if ctx.quest.current == 0 { 1 } else { 2 })
}

/// Register this category's native fns into the registry.
pub fn register(registry: &mut BehaviorRegistry) {
    let mut reg = |name: &str, title: &str, desc: &str, f: ConditionalProgressFn| {
        registry.register_conditional_progress(
            BehaviorMeta {
                name: name.to_string(),
                category: BehaviorKind::ConditionalProgress,
                title: title.to_string(),
                description: desc.to_string(),
            },
            f,
        );
    };

    reg(
        "increment_one",
        "Прогресс +1",
        "Безусловно увеличивает прогресс квеста на 1.",
        increment_one,
    );
    reg(
        "increment_by_batch_size",
        "Прогресс += batch_size",
        "Увеличивает прогресс на Event.batch_size.",
        increment_by_batch_size,
    );

    for (name, title, f) in [
        (
            "loop_task_increment_one_n1",
            "Loop-task: +1, цель 1",
            loop_task_increment_one::<1> as ConditionalProgressFn,
        ),
        (
            "loop_task_increment_one_n2",
            "Loop-task: +1, цель 2",
            loop_task_increment_one::<2>,
        ),
        (
            "loop_task_increment_one_n3",
            "Loop-task: +1, цель 3",
            loop_task_increment_one::<3>,
        ),
        (
            "loop_task_increment_one_n5",
            "Loop-task: +1, цель 5",
            loop_task_increment_one::<5>,
        ),
        (
            "loop_task_increment_one_n6",
            "Loop-task: +1, цель 6",
            loop_task_increment_one::<6>,
        ),
        (
            "loop_task_increment_one_n10",
            "Loop-task: +1, цель 10",
            loop_task_increment_one::<10>,
        ),
        (
            "loop_task_increment_one_n12",
            "Loop-task: +1, цель 12",
            loop_task_increment_one::<12>,
        ),
        (
            "loop_task_increment_one_n20",
            "Loop-task: +1, цель 20",
            loop_task_increment_one::<20>,
        ),
    ] {
        reg(
            name,
            title,
            "CompleteAllLoopTasks => цель; иначе прогресс +1.",
            f,
        );
    }
    reg(
        "loop_task_increment_batch_n1",
        "Loop-task: += batch_size, цель 1",
        "CompleteAllLoopTasks => 1; иначе += Event.batch_size (1 pull completes даже при batch).",
        loop_task_increment_batch::<1>,
    );
    reg(
        "loop_task_increment_batch_n10",
        "Loop-task: += batch_size, цель 10",
        "CompleteAllLoopTasks => 10; иначе += Event.batch_size.",
        loop_task_increment_batch::<10>,
    );

    reg(
        "reach_level_2",
        "Достичь уровня 2",
        "Event.level >= 2 => 1, иначе 0 (без loop-task guard).",
        reach_level::<2>,
    );
    for (name, title, f) in [
        (
            "loop_task_reach_level_3",
            "Loop-task: достичь уровня 3",
            loop_task_reach_level::<3> as ConditionalProgressFn,
        ),
        (
            "loop_task_reach_level_5",
            "Loop-task: достичь уровня 5",
            loop_task_reach_level::<5>,
        ),
        (
            "loop_task_reach_level_10",
            "Loop-task: достичь уровня 10",
            loop_task_reach_level::<10>,
        ),
        (
            "loop_task_reach_level_15",
            "Loop-task: достичь уровня 15",
            loop_task_reach_level::<15>,
        ),
        (
            "loop_task_reach_level_20",
            "Loop-task: достичь уровня 20",
            loop_task_reach_level::<20>,
        ),
        (
            "loop_task_reach_level_25",
            "Loop-task: достичь уровня 25",
            loop_task_reach_level::<25>,
        ),
        (
            "loop_task_reach_level_26",
            "Loop-task: достичь уровня 26",
            loop_task_reach_level::<26>,
        ),
        (
            "loop_task_reach_level_27",
            "Loop-task: достичь уровня 27",
            loop_task_reach_level::<27>,
        ),
        (
            "loop_task_reach_level_28",
            "Loop-task: достичь уровня 28",
            loop_task_reach_level::<28>,
        ),
        (
            "loop_task_reach_level_29",
            "Loop-task: достичь уровня 29",
            loop_task_reach_level::<29>,
        ),
        (
            "loop_task_reach_level_30",
            "Loop-task: достичь уровня 30",
            loop_task_reach_level::<30>,
        ),
        (
            "loop_task_reach_level_35",
            "Loop-task: достичь уровня 35",
            loop_task_reach_level::<35>,
        ),
        (
            "loop_task_reach_level_40",
            "Loop-task: достичь уровня 40",
            loop_task_reach_level::<40>,
        ),
        (
            "loop_task_reach_level_45",
            "Loop-task: достичь уровня 45",
            loop_task_reach_level::<45>,
        ),
        (
            "loop_task_reach_level_50",
            "Loop-task: достичь уровня 50",
            loop_task_reach_level::<50>,
        ),
        (
            "loop_task_reach_level_60",
            "Loop-task: достичь уровня 60",
            loop_task_reach_level::<60>,
        ),
        (
            "loop_task_reach_level_100",
            "Loop-task: достичь уровня 100",
            loop_task_reach_level::<100>,
        ),
    ] {
        reg(
            name,
            title,
            "CompleteAllLoopTasks => 1; иначе Event.level >= порог ? 1 : 0.",
            f,
        );
    }

    // Register reach_chapter_level_1..20 in one loop. The ch28 grant (outside
    // this range) is re-added right after the loop.
    for (name, title, f) in [
        (
            "reach_chapter_level_1",
            "Достичь главы 1",
            reach_chapter_level::<1> as ConditionalProgressFn,
        ),
        (
            "reach_chapter_level_2",
            "Достичь главы 2",
            reach_chapter_level::<2>,
        ),
        (
            "reach_chapter_level_3",
            "Достичь главы 3",
            reach_chapter_level::<3>,
        ),
        (
            "reach_chapter_level_4",
            "Достичь главы 4",
            reach_chapter_level::<4>,
        ),
        (
            "reach_chapter_level_5",
            "Достичь главы 5",
            reach_chapter_level::<5>,
        ),
        (
            "reach_chapter_level_6",
            "Достичь главы 6",
            reach_chapter_level::<6>,
        ),
        (
            "reach_chapter_level_7",
            "Достичь главы 7",
            reach_chapter_level::<7>,
        ),
        (
            "reach_chapter_level_8",
            "Достичь главы 8",
            reach_chapter_level::<8>,
        ),
        (
            "reach_chapter_level_9",
            "Достичь главы 9",
            reach_chapter_level::<9>,
        ),
        (
            "reach_chapter_level_10",
            "Достичь главы 10",
            reach_chapter_level::<10>,
        ),
        (
            "reach_chapter_level_11",
            "Достичь главы 11",
            reach_chapter_level::<11>,
        ),
        (
            "reach_chapter_level_12",
            "Достичь главы 12",
            reach_chapter_level::<12>,
        ),
        (
            "reach_chapter_level_13",
            "Достичь главы 13",
            reach_chapter_level::<13>,
        ),
        (
            "reach_chapter_level_14",
            "Достичь главы 14",
            reach_chapter_level::<14>,
        ),
        (
            "reach_chapter_level_15",
            "Достичь главы 15",
            reach_chapter_level::<15>,
        ),
        (
            "reach_chapter_level_16",
            "Достичь главы 16",
            reach_chapter_level::<16>,
        ),
        (
            "reach_chapter_level_17",
            "Достичь главы 17",
            reach_chapter_level::<17>,
        ),
        (
            "reach_chapter_level_18",
            "Достичь главы 18",
            reach_chapter_level::<18>,
        ),
        (
            "reach_chapter_level_19",
            "Достичь главы 19",
            reach_chapter_level::<19>,
        ),
        (
            "reach_chapter_level_20",
            "Достичь главы 20",
            reach_chapter_level::<20>,
        ),
    ] {
        reg(
            name,
            title,
            "current_chapter_level >= N => 1, иначе 0 (без guard).",
            f,
        );
    }
    // JIT onboarding: the ch28 grant (outside the 1-20 loop above), used by the
    // AFK currency-unlock quest.
    reg(
        "reach_chapter_level_28",
        "Достичь главы 28",
        "current_chapter_level >= 28 => 1, иначе 0 (без guard).",
        reach_chapter_level::<28>,
    );
    for (name, title, f) in [
        (
            "loop_task_reach_chapter_level_5",
            "Loop-task: глава 5",
            loop_task_reach_chapter_level::<5> as ConditionalProgressFn,
        ),
        (
            "loop_task_reach_chapter_level_6",
            "Loop-task: глава 6",
            loop_task_reach_chapter_level::<6>,
        ),
        (
            "loop_task_reach_chapter_level_7",
            "Loop-task: глава 7",
            loop_task_reach_chapter_level::<7>,
        ),
        (
            "loop_task_reach_chapter_level_8",
            "Loop-task: глава 8",
            loop_task_reach_chapter_level::<8>,
        ),
        (
            "loop_task_reach_chapter_level_9",
            "Loop-task: глава 9",
            loop_task_reach_chapter_level::<9>,
        ),
        (
            "loop_task_reach_chapter_level_10",
            "Loop-task: глава 10",
            loop_task_reach_chapter_level::<10>,
        ),
        (
            "loop_task_reach_chapter_level_11",
            "Loop-task: глава 11",
            loop_task_reach_chapter_level::<11>,
        ),
        (
            "loop_task_reach_chapter_level_15",
            "Loop-task: глава 15",
            loop_task_reach_chapter_level::<15>,
        ),
        (
            "loop_task_reach_chapter_level_20",
            "Loop-task: глава 20",
            loop_task_reach_chapter_level::<20>,
        ),
        (
            "loop_task_reach_chapter_level_25",
            "Loop-task: глава 25",
            loop_task_reach_chapter_level::<25>,
        ),
        (
            "loop_task_reach_chapter_level_30",
            "Loop-task: глава 30",
            loop_task_reach_chapter_level::<30>,
        ),
        (
            "loop_task_reach_chapter_level_35",
            "Loop-task: глава 35",
            loop_task_reach_chapter_level::<35>,
        ),
        (
            "loop_task_reach_chapter_level_40",
            "Loop-task: глава 40",
            loop_task_reach_chapter_level::<40>,
        ),
    ] {
        reg(
            name,
            title,
            "CompleteAllLoopTasks => 1; иначе current_chapter_level >= порог ? 1 : 0.",
            f,
        );
    }

    reg(
        "current_chapter_level",
        "Текущая глава (порог = progress_target)",
        "Возвращает current_chapter_level; квест завершён при достижении главы progress_target. Используется тирами прогресс-пасса (ch35→130).",
        current_chapter_level,
    );

    reg(
        "pvp_win",
        "Победа в PvP",
        "EndFight с pvp_state => +1, иначе без изменений.",
        pvp_win,
    );
    reg(
        "loop_task_pvp_win",
        "Loop-task: победа в PvP",
        "CompleteAllLoopTasks => 1; иначе EndFight с pvp_state => +1.",
        loop_task_pvp_win,
    );

    for (name, title, f) in [
        (
            "raid_dungeon_1",
            "Рейд подземелья D1",
            raid_dungeon::<DUNGEON_1> as ConditionalProgressFn,
        ),
        (
            "raid_dungeon_2",
            "Рейд подземелья D2",
            raid_dungeon::<DUNGEON_2>,
        ),
        (
            "raid_dungeon_3",
            "Рейд подземелья D3",
            raid_dungeon::<DUNGEON_3>,
        ),
        (
            "loop_task_raid_dungeon_1",
            "Loop-task: рейд D1",
            loop_task_raid_dungeon::<DUNGEON_1>,
        ),
        (
            "loop_task_raid_dungeon_2",
            "Loop-task: рейд D2",
            loop_task_raid_dungeon::<DUNGEON_2>,
        ),
        (
            "loop_task_raid_dungeon_3",
            "Loop-task: рейд D3",
            loop_task_raid_dungeon::<DUNGEON_3>,
        ),
    ] {
        reg(
            name,
            title,
            "RaidDungeon/ActiveFight по целевому dungeon => +1 (loop-task варианты с guard).",
            f,
        );
    }

    reg(
        "complete_daily_quest",
        "Завершить дневной квест",
        "+1 если завершённый квест имеет group_type Daily.",
        complete_daily_quest,
    );
    reg(
        "complete_weekly_quest",
        "Завершить недельный квест",
        "+1 если завершённый квест имеет group_type Weekly.",
        complete_weekly_quest,
    );
    reg(
        "complete_loop_task_quest",
        "Завершить loop-task квест",
        "+1 если завершённый квест имеет group_type LoopTask.",
        complete_loop_task_quest,
    );

    reg(
        "loop_task_collect_currency",
        "Loop-task: собрать валюту",
        "CompleteAllLoopTasks => 100; иначе += amount нужной валюты, иначе 0.",
        loop_task_collect_currency,
    );
    reg(
        "upgraded_abilities_delta",
        "Сумма апгрейдов способностей",
        "+= сумма (final - current) по Event.upgraded_abilities.",
        upgraded_abilities_delta,
    );

    for (name, title, f) in [
        (
            "count_equipped_rarity_a",
            "Счётчик экип. предметов редкости A",
            count_equipped_at_rarity::<RARITY_A> as ConditionalProgressFn,
        ),
        (
            "count_equipped_rarity_b",
            "Счётчик экип. предметов редкости B",
            count_equipped_at_rarity::<RARITY_B>,
        ),
        (
            "count_equipped_rarity_c",
            "Счётчик экип. предметов редкости C",
            count_equipped_at_rarity::<RARITY_C>,
        ),
    ] {
        reg(
            name,
            title,
            "Кол-во экипированных предметов с q >= q целевой редкости (PlayerEquipItem).",
            f,
        );
    }

    reg(
        "always_one",
        "Всегда 1",
        "Безусловно возвращает 1.",
        always_one,
    );
    reg(
        "log_in_today",
        "Вход сегодня",
        "+1 если Event.quest_id совпадает с дневным квестом входа.",
        log_in_today,
    );

    reg(
        "quest_event_level_1_then_2",
        "Тест: level 1 => 1, level 2 => 2",
        "Тестовый прогресс: level 1 => 1, level 2 => 2, иначе 0.",
        quest_event_level_1_then_2,
    );
    reg(
        "quest_current_0_then_1_else_2",
        "Тест: current 0 => 1, иначе 2",
        "Тестовый прогресс: current 0 => 1, иначе 2.",
        quest_current_0_then_1_else_2,
    );
}

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

    /// A "Win in the Arena" objective must count only *player victories* — the
    /// regression here is that a loss used to advance it (the gate was
    /// `pvp_state.is_some()` with no `is_win` check, so you could complete
    /// "Win 200 times" by losing 200 times).
    #[test]
    fn pvp_win_counts_only_player_victories() {
        // Won a PvP fight → +1.
        assert_eq!(pvp_win_increment(true, true, 5), 6);
        // Regression: lost a PvP fight → unchanged (a loss is not a win).
        assert_eq!(pvp_win_increment(false, true, 5), 5);
        // PvE win (no pvp_state) → unchanged: arena objectives ignore campaign wins.
        assert_eq!(pvp_win_increment(true, false, 5), 5);
        // Neither a win nor a PvP fight → unchanged.
        assert_eq!(pvp_win_increment(false, false, 5), 5);
    }

    /// The event→signal extraction yields the win flag only for PvP `EndFight`;
    /// any other event is neither a win nor PvP.
    #[test]
    fn pvp_win_signal_reads_only_endfight() {
        let non_fight = OverlordEvent::PetCaseOpened { batch_size: 1 };
        assert_eq!(pvp_win_signal(&non_fight), (false, false));
    }
}