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;

/// A quest's progress against its target.
#[derive(Debug, Clone)]
pub struct ConditionalProgress {
    pub current: i64,
    pub target: i64,
}

impl ConditionalProgress {
    pub fn completed(&self) -> bool {
        self.current >= self.target
    }
}

/// 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 { .. })
}

/// §3 growing-enemy-waves: `EntityDeath` fires for allies too, but kill quests
/// must only count enemy kills. True when the trigger is an `EntityDeath` for
/// the party ally — the ONLY ally that emits `EntityDeath` (the player's own
/// death is `PlayerDeath`). Inert for every non-`EntityDeath` trigger, so it is
/// safe to guard the shared increment behaviors (a quest not subscribed to
/// `EntityDeath` never sees one). `party_player_id` survives the ally's removal
/// from `entities`, so it still identifies the just-dead ally here.
fn is_ally_entity_death(ctx: &ConditionalProgressCtx) -> bool {
    match ctx.event {
        OverlordEvent::EntityDeath { entity_id, .. } => ctx
            .active_fight
            .as_ref()
            .and_then(|af| af.party_player_id)
            .is_some_and(|ally_id| ally_id == *entity_id),
        _ => false,
    }
}

/// Boss-summon: kill quests must skip the deaths of boss-summoned reinforcements
/// so a boss fight's kill-quest ticks stay flat (only the boss counts). True when
/// the trigger is an `EntityDeath` for a mob recorded in `summoned_entity_ids`
/// (populated on spawn; survives the entity's removal from `entities`). Inert for
/// every non-`EntityDeath` trigger, so it is safe to guard the shared increments.
fn is_summoned_entity_death(ctx: &ConditionalProgressCtx) -> bool {
    match ctx.event {
        OverlordEvent::EntityDeath { entity_id, .. } => ctx
            .active_fight
            .as_ref()
            .is_some_and(|af| af.summoned_entity_ids.contains(entity_id)),
        _ => false,
    }
}

/// A kill-quest death that must NOT tick progress: an ally death (§3) or a
/// boss-summoned reinforcement death (boss-summon). Both are inert for
/// non-`EntityDeath` triggers.
fn is_non_counting_entity_death(ctx: &ConditionalProgressCtx) -> bool {
    is_ally_entity_death(ctx) || is_summoned_entity_death(ctx)
}

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

/// `quest.current + 1`. Kill quests (subscribed to `EntityDeath`) skip ally
/// deaths (§3).
pub fn increment_one(ctx: &ConditionalProgressCtx) -> anyhow::Result<i64> {
    if is_non_counting_entity_death(ctx) {
        return Ok(ctx.quest.current);
    }
    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);
    }
    // §3: kill loop-tasks (EntityDeath) skip ally deaths; boss-summon: and
    // boss-summoned reinforcement deaths.
    if is_non_counting_entity_death(ctx) {
        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)
}

// === Pattern 13: boss-fight win =============================================

/// Pure step for the boss-win counter (unit-testable without a GameConfig).
fn boss_win_step(is_win: bool, is_boss_fight: bool, current: i64) -> i64 {
    if is_win && is_boss_fight {
        current + 1
    } else {
        current
    }
}

/// `EndFight` the player **won** while the fight's template is
/// `CampaignBossFight` and the fight is NOT a dungeon run → +1; everything
/// else unchanged. Dungeon bosses ride the same template type, but the quest
/// is "Defeat a Campaign Boss" (BAL-035) and dungeon bosses grant no Mastery,
/// so they must not tick it either. Quest dispatch runs while the fight is
/// still present (the same contract [`raid_dungeon`]'s in-fight branch relies
/// on).
pub fn boss_win(ctx: &ConditionalProgressCtx) -> anyhow::Result<i64> {
    let OverlordEvent::EndFight { is_win, .. } = ctx.event else {
        return Ok(ctx.quest.current);
    };
    let is_boss = ctx.active_fight.as_ref().is_some_and(|f| {
        f.dungeon.is_none()
            && ctx
                .config
                .require_fight_template(f.fight_id)
                .is_ok_and(|tpl| tpl.fight_type == essences::fighting::FightType::CampaignBossFight)
    });
    Ok(boss_win_step(*is_win, is_boss, ctx.quest.current))
}

/// Loop-task-guarded boss win (`CompleteAllLoopTasks` force-completes to `N`).
pub fn loop_task_boss_win<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);
    }
    boss_win(ctx)
}

// === Pattern 14: PvP win streak =============================================

/// Pure step: a won PvP fight extends the streak, a LOST PvP fight resets it
/// to 0, non-PvP events leave it unchanged.
fn pvp_streak_step(is_win: bool, is_pvp: bool, current: i64) -> i64 {
    match (is_pvp, is_win) {
        (true, true) => current + 1,
        (true, false) => 0,
        (false, _) => current,
    }
}

/// Consecutive arena wins («выиграй N подряд»): win → +1, loss → reset to 0.
pub fn pvp_win_streak(ctx: &ConditionalProgressCtx) -> anyhow::Result<i64> {
    let (is_win, is_pvp) = pvp_win_signal(ctx.event);
    Ok(pvp_streak_step(is_win, is_pvp, ctx.quest.current))
}

// === Pattern 15: revenge — win after a loss ==================================

/// Pure step for «Реванш» (target 2): progress 0 = nothing yet; a LOST PvP
/// fight arms it (0 → 1, «поражение зафиксировано»); a WON PvP fight when
/// armed completes it (1 → 2). A win from 0 does NOT advance — the objective
/// is specifically "come back after a defeat".
fn pvp_revenge_step(is_win: bool, is_pvp: bool, current: i64) -> i64 {
    if !is_pvp {
        return current;
    }
    match (current, is_win) {
        (0, false) => 1,
        (1, true) => 2,
        (c, _) => c,
    }
}

/// «Реванш»: проиграй бой на арене, затем выиграй. Использовать с
/// `progress_target: 2`.
pub fn pvp_revenge(ctx: &ConditionalProgressCtx) -> anyhow::Result<i64> {
    let (is_win, is_pvp) = pvp_win_signal(ctx.event);
    Ok(pvp_revenge_step(is_win, is_pvp, ctx.quest.current))
}

// === Pattern 16: dungeon raids, any type / minimum difficulty ================

/// +1 on any `RaidDungeon` regardless of type («пройди N рейдов данжей»).
/// One raid ACTION = +1 (a multi-sweep still counts once — the same semantics
/// as [`raid_dungeon`]).
pub fn raid_dungeon_any(ctx: &ConditionalProgressCtx) -> anyhow::Result<i64> {
    if matches!(ctx.event, OverlordEvent::RaidDungeon { .. }) {
        return Ok(ctx.quest.current + 1);
    }
    Ok(ctx.quest.current)
}

/// +1 on a `RaidDungeon` with `difficulty >= N` (any dungeon type) —
/// «пройди данж на сложности N+», полосные варианты.
pub fn raid_dungeon_difficulty_at_least<const N: i64>(
    ctx: &ConditionalProgressCtx,
) -> anyhow::Result<i64> {
    if let OverlordEvent::RaidDungeon { difficulty, .. } = ctx.event
        && *difficulty >= N
    {
        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>,
        ),
        (
            "loop_task_increment_one_n7",
            "Loop-task: +1, цель 7",
            loop_task_increment_one::<7>,
        ),
        (
            "loop_task_increment_one_n17",
            "Loop-task: +1, цель 17",
            loop_task_increment_one::<17>,
        ),
        (
            "loop_task_increment_one_n28",
            "Loop-task: +1, цель 28",
            loop_task_increment_one::<28>,
        ),
        (
            "loop_task_increment_one_n42",
            "Loop-task: +1, цель 42",
            loop_task_increment_one::<42>,
        ),
    ] {
        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_55",
            "Loop-task: достичь уровня 55",
            loop_task_reach_level::<55>,
        ),
        (
            "loop_task_reach_level_60",
            "Loop-task: достичь уровня 60",
            loop_task_reach_level::<60>,
        ),
        (
            "loop_task_reach_level_70",
            "Loop-task: достичь уровня 70",
            loop_task_reach_level::<70>,
        ),
        (
            "loop_task_reach_level_80",
            "Loop-task: достичь уровня 80",
            loop_task_reach_level::<80>,
        ),
        (
            "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>,
    );
    // BAL-032: the Pets gate. One welcome grant lands here — before it, no
    // source hands out Beast Tokens at all.
    reg(
        "reach_chapter_level_35",
        "Достичь главы 35",
        "current_chapter_level >= 35 => 1, иначе 0 (без guard).",
        reach_chapter_level::<35>,
    );
    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>,
        ),
        (
            "loop_task_reach_chapter_level_45",
            "Loop-task: глава 45",
            loop_task_reach_chapter_level::<45>,
        ),
        (
            "loop_task_reach_chapter_level_50",
            "Loop-task: глава 50",
            loop_task_reach_chapter_level::<50>,
        ),
        (
            "loop_task_reach_chapter_level_55",
            "Loop-task: глава 55",
            loop_task_reach_chapter_level::<55>,
        ),
        (
            "loop_task_reach_chapter_level_60",
            "Loop-task: глава 60",
            loop_task_reach_chapter_level::<60>,
        ),
        (
            "loop_task_reach_chapter_level_70",
            "Loop-task: глава 70",
            loop_task_reach_chapter_level::<70>,
        ),
        (
            "loop_task_reach_chapter_level_80",
            "Loop-task: глава 80",
            loop_task_reach_chapter_level::<80>,
        ),
    ] {
        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,
    );

    // Разнообразие прогресс-функций (босс/стрик/реванш/данж-сложность)
    // + loop-цели для пула луп-тасок.
    reg(
        "boss_win",
        "Победи босса",
        "+1 за выигранный EndFight в бою типа CampaignBossFight (кампания и данжи).",
        boss_win,
    );
    for (name, title, f) in [
        (
            "loop_task_boss_win_n1",
            "Loop-task: победи босса",
            loop_task_boss_win::<1> as ConditionalProgressFn,
        ),
        (
            "loop_task_boss_win_n2",
            "Loop-task: победи 2 боссов",
            loop_task_boss_win::<2>,
        ),
    ] {
        reg(
            name,
            title,
            "CompleteAllLoopTasks => цель; иначе +1 за выигранный босс-бой.",
            f,
        );
    }
    reg(
        "pvp_win_streak",
        "Победы на арене подряд",
        "Победа в PvP +1, поражение сбрасывает в 0.",
        pvp_win_streak,
    );
    reg(
        "pvp_revenge",
        "Реванш после поражения",
        "target=2: поражение в PvP (0→1), затем победа (1→2); победа без поражения не двигает.",
        pvp_revenge,
    );
    reg(
        "raid_dungeon_any",
        "Рейд любого данжа",
        "+1 за любой RaidDungeon (тип не важен; свип = одно действие).",
        raid_dungeon_any,
    );
    for (name, title, f) in [
        (
            "raid_dungeon_difficulty_2",
            "Данж на сложности 2+",
            raid_dungeon_difficulty_at_least::<2> as ConditionalProgressFn,
        ),
        (
            "raid_dungeon_difficulty_4",
            "Данж на сложности 4+",
            raid_dungeon_difficulty_at_least::<4>,
        ),
        (
            "raid_dungeon_difficulty_6",
            "Данж на сложности 6+",
            raid_dungeon_difficulty_at_least::<6>,
        ),
        (
            "raid_dungeon_difficulty_8",
            "Данж на сложности 8+",
            raid_dungeon_difficulty_at_least::<8>,
        ),
    ] {
        reg(
            name,
            title,
            "+1 за RaidDungeon со сложностью не ниже порога.",
            f,
        );
    }
    for (name, title, f) in [
        (
            "loop_task_increment_one_n4",
            "Loop-task: +1, цель 4",
            loop_task_increment_one::<4> as ConditionalProgressFn,
        ),
        (
            "loop_task_increment_one_n8",
            "Loop-task: +1, цель 8",
            loop_task_increment_one::<8>,
        ),
        (
            "loop_task_increment_one_n15",
            "Loop-task: +1, цель 15",
            loop_task_increment_one::<15>,
        ),
        (
            "loop_task_increment_one_n30",
            "Loop-task: +1, цель 30",
            loop_task_increment_one::<30>,
        ),
    ] {
        reg(
            name,
            title,
            "CompleteAllLoopTasks => цель; иначе прогресс +1.",
            f,
        );
    }
    reg(
        "loop_task_increment_batch_n15",
        "Loop-task: += batch_size, цель 15",
        "CompleteAllLoopTasks => 15; иначе += Event.batch_size.",
        loop_task_increment_batch::<15>,
    );
    reg(
        "loop_task_increment_batch_n20",
        "Loop-task: += batch_size, цель 20",
        "CompleteAllLoopTasks => 20; иначе += Event.batch_size.",
        loop_task_increment_batch::<20>,
    );

    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::*;

    use essences::combat_origin::CombatEventOrigin;

    /// 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));
    }

    /// A boss objective advances only on a WON boss fight; a lost boss fight
    /// and a won wave fight both leave it unchanged.
    #[test]
    fn boss_win_requires_both_victory_and_boss_fight() {
        assert_eq!(boss_win_step(true, true, 3), 4);
        assert_eq!(boss_win_step(false, true, 3), 3);
        assert_eq!(boss_win_step(true, false, 3), 3);
    }

    /// A streak extends on wins, RESETS on a loss (not merely stalls), and
    /// ignores non-PvP outcomes entirely.
    #[test]
    fn pvp_streak_resets_on_loss() {
        assert_eq!(pvp_streak_step(true, true, 2), 3);
        assert_eq!(pvp_streak_step(false, true, 2), 0);
        assert_eq!(pvp_streak_step(true, false, 2), 2);
        assert_eq!(pvp_streak_step(false, false, 2), 2);
    }

    /// Revenge is strictly loss-then-win: a win from the initial state does
    /// NOT advance (the quest is "come back after a defeat"), a loss arms it,
    /// a win when armed completes it, and extra losses while armed don't
    /// un-arm or double-advance.
    #[test]
    fn pvp_revenge_is_loss_then_win() {
        assert_eq!(pvp_revenge_step(true, true, 0), 0);
        assert_eq!(pvp_revenge_step(false, true, 0), 1);
        assert_eq!(pvp_revenge_step(false, true, 1), 1);
        assert_eq!(pvp_revenge_step(true, true, 1), 2);
        assert_eq!(pvp_revenge_step(true, false, 1), 1);
    }

    /// §3: a kill quest (subscribed to `EntityDeath`) advances on an ENEMY death
    /// but NOT on the party ally's death — the pre-existing bug where ally
    /// deaths ticked kill quests. Uses the party ally id, which survives the
    /// ally's removal from `entities`.
    #[test]
    fn kill_quest_skips_ally_death() {
        let config = configs::tests_game_config::generate_game_config_for_tests();
        let lookups = ContentLookups::default();
        let character_state = CharacterState::default();
        let quest = QuestInstance {
            id: uuid::Uuid::from_u128(99),
            current: 5,
            reward: vec![],
            is_claimed: false,
        };
        let ally_id = uuid::Uuid::from_u128(42);
        let fight = Some(ActiveFight {
            party_player_id: Some(ally_id),
            ..Default::default()
        });
        // Enemy death → +1.
        let enemy_death = OverlordEvent::EntityDeath {
            entity_id: uuid::Uuid::from_u128(1),
            reward: vec![],
            origin: CombatEventOrigin::Core,
        };
        let enemy_ctx = ConditionalProgressCtx {
            event: &enemy_death,
            character_state: &character_state,
            active_fight: &fight,
            quest: &quest,
            config: &config,
            lookups: &lookups,
        };
        assert_eq!(increment_one(&enemy_ctx).unwrap(), 6);
        assert_eq!(loop_task_increment_one::<12>(&enemy_ctx).unwrap(), 6);

        // Party-ally death → unchanged (the §3 fix).
        let ally_death = OverlordEvent::EntityDeath {
            entity_id: ally_id,
            reward: vec![],
            origin: CombatEventOrigin::Core,
        };
        let ally_ctx = ConditionalProgressCtx {
            event: &ally_death,
            character_state: &character_state,
            active_fight: &fight,
            quest: &quest,
            config: &config,
            lookups: &lookups,
        };
        assert_eq!(increment_one(&ally_ctx).unwrap(), 5);
        assert_eq!(loop_task_increment_one::<12>(&ally_ctx).unwrap(), 5);
    }

    /// Boss-summon: a kill quest advances on the boss death but NOT on a
    /// boss-summoned reinforcement death (recorded in `summoned_entity_ids`), so
    /// a boss fight's kill-quest ticks stay flat when the summon wave is added.
    #[test]
    fn kill_quest_skips_summoned_death() {
        let config = configs::tests_game_config::generate_game_config_for_tests();
        let lookups = ContentLookups::default();
        let character_state = CharacterState::default();
        let quest = QuestInstance {
            id: uuid::Uuid::from_u128(99),
            current: 5,
            reward: vec![],
            is_claimed: false,
        };
        let summoned_id = uuid::Uuid::from_u128(77);
        let fight = Some(ActiveFight {
            summoned_entity_ids: vec![summoned_id],
            ..Default::default()
        });

        // Boss (non-summoned) enemy death → +1.
        let boss_death = OverlordEvent::EntityDeath {
            entity_id: uuid::Uuid::from_u128(1),
            reward: vec![],
            origin: CombatEventOrigin::Core,
        };
        let boss_ctx = ConditionalProgressCtx {
            event: &boss_death,
            character_state: &character_state,
            active_fight: &fight,
            quest: &quest,
            config: &config,
            lookups: &lookups,
        };
        assert_eq!(increment_one(&boss_ctx).unwrap(), 6);
        assert_eq!(loop_task_increment_one::<12>(&boss_ctx).unwrap(), 6);

        // Summoned reinforcement death → unchanged.
        let summoned_death = OverlordEvent::EntityDeath {
            entity_id: summoned_id,
            reward: vec![],
            origin: CombatEventOrigin::Core,
        };
        let summoned_ctx = ConditionalProgressCtx {
            event: &summoned_death,
            character_state: &character_state,
            active_fight: &fight,
            quest: &quest,
            config: &config,
            lookups: &lookups,
        };
        assert_eq!(increment_one(&summoned_ctx).unwrap(), 5);
        assert_eq!(loop_task_increment_one::<12>(&summoned_ctx).unwrap(), 5);
    }
}