feat(simulation): sprint 10 — hub teleport, confrontation response, walk-away phase 2, gauntlet rooms 4-7, blocked_entities debug field

#491: PlayerAction::TeleportToHub — moves player to hub spawn, clears dialogue/monologue/interaction buffer, Gauntlet-only with log warning. #520: ConfrontationDelivered event — Tier 2 animation shift, relationship state decrement (D-033), monologue spike emission. #519: Walk-away Phase 2 — NPC animation shift + routine deviation on dialogue exit (D-064). #498: Four new Gauntlet rooms — Interaction Gallery, Fog Theater, Crowd Plaza, Dialogue Room with constants and wiring. #514: blocked_entities Vec<u64> on ObserverSnapshot, protocol v9. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-18 12:58:14 +01:00
parent b4a3784218
commit 273d29f26f
18 changed files with 1219 additions and 50 deletions
@@ -18,12 +18,13 @@
 use bevy_ecs::prelude::*;
 use rand::Rng;

-use crate::bridge::types::{DialogueResponseEvent, RelationshipState};
+use crate::bridge::types::{DialogueResponseEvent, MonologueEvent, RelationshipState};
 use crate::content::line_pool::{
    AccessTier, IndexedDialogueLine, Mood, Situation, Topic, TrustTier,
 };
 use crate::content::LinePoolIndexResource;
 use crate::knowledge::{EntityRegistry, KnowledgeGraph};
+use crate::simulation::monologue::{MonologueBuffer, MonologueState};
 use crate::simulation::movement::PlayerCharacter;
 use crate::simulation::rng::SimRng;
 use crate::simulation::time::SimulationTime;
@@ -117,6 +118,18 @@ pub struct ActiveDialogue {
 #[derive(Component, Debug)]
 pub struct WalkAwayRequest;

+/// Marker: player delivered a confrontation this tick (#520, D-063).
+///
+/// Set by process_player_input when Interact{verb: "Confront"} is received.
+/// Consumed by process_confrontation_response each tick. Triggers:
+///   1. Target NPC shifts to AnimationTier::Tier2 (D-047)
+///   2. Observer KG relationship state decremented (D-033 color fade)
+///   3. Monologue spike event emitted
+#[derive(Component, Debug)]
+pub struct ConfrontationDelivered {
+    pub target: Entity,
+}
+
 /// Buffer holding the dialogue response for snapshot inclusion.
 ///
 /// Consumed once per snapshot via `take()`. Cleared at snapshot build time.
@@ -299,7 +312,7 @@ pub fn select_dialogue_line<'a>(
 /// line to DialogueResponseBuffer.
 ///
 /// System ordering: after process_player_input, before compute_observer_snapshot.
-#[allow(clippy::type_complexity)]
+#[allow(clippy::type_complexity, clippy::too_many_arguments)]
 pub fn process_talk_interaction(
    mut commands: Commands,
    time: Res<SimulationTime>,
@@ -478,11 +491,13 @@ pub fn process_talk_interaction(
 // System: process_walk_away (D-064)
 // ---------------------------------------------------------------------------

-/// Process walk-away requests during active dialogue.
+/// Process walk-away requests during active dialogue (D-064 Phases 2+3).
 ///
 /// When the player moves (WASD) during an active dialogue, the client sends
 /// PlayerAction::WalkAway which sets WalkAwayRequest. This system:
-/// 1. Emits IncompleteInteraction knowledge event (recorded in KG)
+/// 1. Target NPC shifts to AnimationTier::Tier2 (D-047 ambiguous animation)
+/// 2. NPC routine deviation recorded (storyteller hook)
+/// 3. Emits IncompleteInteraction knowledge event (recorded in KG)
 /// 2. Clears ActiveDialogue state
 /// 3. Removes the WalkAwayRequest marker
 ///
@@ -500,21 +515,38 @@ pub fn process_walk_away(
    };

    if let Some(active_dialogue) = active_dialogue_opt {
-        // Emit IncompleteInteraction knowledge event
+        let target = active_dialogue.target;
+
+        // Phase 2, Effect 1: Shift target NPC to Tier 2 animation (D-047)
+        commands
+            .entity(target)
+            .insert(crate::npc::AnimationTier::Tier2);
+
+        // Phase 2, Effect 2: Record routine deviation on target NPC
+        commands
+            .entity(target)
+            .insert(crate::npc::RoutineDeviation {
+                trigger: crate::npc::DeviationTrigger::WalkAway,
+                tick: time.tick,
+            });
+
+        // Phase 3: Emit IncompleteInteraction knowledge event
        event_queue.push(crate::knowledge::KnowledgeEvent {
            observer: player_entity,
            tick: time.tick,
            event_type: crate::knowledge::KnowledgeEventType::IncompleteInteraction {
-                target: active_dialogue.target,
+                target,
                interaction_type: active_dialogue.interaction_type,
            },
        });

        tracing::debug!(
-            "Walk-away during {:?} dialogue at tick {} (started tick {})",
+            "Walk-away during {:?} dialogue at tick {} (started tick {}): \
+             target {:?} → Tier2 animation + routine deviation",
            active_dialogue.interaction_type,
            time.tick,
            active_dialogue.started_tick,
+            target,
        );

        commands.entity(player_entity).remove::<ActiveDialogue>();
@@ -525,6 +557,104 @@ pub fn process_walk_away(
    commands.entity(player_entity).remove::<WalkAwayRequest>();
 }

+/// Hardcoded confrontation monologue lines (D-063).
+/// Fired as a monologue spike when the player delivers a confrontation.
+/// Future: move to content pools with trigger="confrontation_delivered".
+const CONFRONTATION_LINES: &[(&str, &str)] = &[
+    (
+        "confront_01",
+        "That changed everything between us. No going back.",
+    ),
+    (
+        "confront_02",
+        "The look on their face... they know I know.",
+    ),
+    (
+        "confront_03",
+        "Cards on the table. Let's see what happens next.",
+    ),
+];
+
+/// Process confrontation world response (#520, D-063).
+///
+/// Reads ConfrontationDelivered marker (set by input system), applies three
+/// server-authoritative effects:
+///   1. Target NPC shifts to AnimationTier::Tier2 (D-047)
+///   2. Observer's KG relationship state decremented (D-033 color fade)
+///   3. Monologue spike: immediate monologue line bypassing cooldown
+///
+/// System ordering: after process_player_input, before compute_observer_snapshot.
+pub fn process_confrontation_response(
+    mut commands: Commands,
+    time: Res<SimulationTime>,
+    registry: Res<EntityRegistry>,
+    mut rng: ResMut<crate::simulation::rng::SimRng>,
+    mut query: Query<
+        (
+            Entity,
+            &ConfrontationDelivered,
+            &mut KnowledgeGraph,
+            &mut MonologueBuffer,
+            &mut MonologueState,
+        ),
+        With<PlayerCharacter>,
+    >,
+) {
+    let Ok((
+        player_entity,
+        confrontation,
+        mut observer_kg,
+        mut monologue_buf,
+        mut monologue_state,
+    )) = query.single_mut()
+    else {
+        return;
+    };
+
+    let target = confrontation.target;
+
+    // Effect 1: Shift target NPC to Tier 2 animation (D-047)
+    commands
+        .entity(target)
+        .insert(crate::npc::AnimationTier::Tier2);
+
+    // Effect 2: Decrement observer's relationship with the target (D-033 color fade)
+    if let Some(target_sid) = registry.to_stable(target) {
+        let old_rel = observer_kg.relationship_with(&target_sid);
+        let new_rel = old_rel.decrement();
+        if new_rel != old_rel {
+            observer_kg.set_relationship(&target_sid, new_rel);
+            tracing::info!(
+                target_id = target_sid.0,
+                ?old_rel,
+                ?new_rel,
+                "Confrontation: relationship decremented"
+            );
+        }
+    }
+
+    // Effect 3: Monologue spike — bypass cooldown, fire immediately
+    let idx = rng.rng.random_range(0..CONFRONTATION_LINES.len());
+    let (id, text) = CONFRONTATION_LINES[idx];
+    monologue_buf.set(MonologueEvent {
+        id: id.to_string(),
+        text: text.to_string(),
+        duration_seconds: 5.0,
+    });
+    monologue_state.last_fired_tick = time.tick;
+
+    tracing::info!(
+        tick = time.tick,
+        monologue_id = id,
+        "Confrontation delivered: Tier 2 anim + relationship decrement + monologue spike"
+    );
+
+    // Clean up marker
+    commands
+        .entity(player_entity)
+        .remove::<ConfrontationDelivered>();
+}
+
 // ---------------------------------------------------------------------------
 // Tests
 // ---------------------------------------------------------------------------
@@ -1362,5 +1492,279 @@ mod tests {
        );
    }

+    // -- Walk-away Phase 2 tests (D-064, #519) ---------------------------------
+
+    #[test]
+    fn walk_away_shifts_npc_to_tier2_animation() {
+        use crate::knowledge::KnowledgeEventQueue;
+        use crate::npc::AnimationTier;
+
+        let mut world = setup_dialogue_world();
+        world.init_resource::<KnowledgeEventQueue>();
+
+        let npc = world.spawn_empty().id();
+        world.resource_mut::<EntityRegistry>().register(npc);
+
+        let player = world
+            .spawn((
+                PlayerCharacter,
+                TilePosition::new(5, 6, 0),
+                KnowledgeGraph::new(),
+                ActiveDialogue {
+                    target: npc,
+                    interaction_type: crate::knowledge::events::InteractionType::Talk,
+                    started_tick: 10,
+                },
+                WalkAwayRequest,
+            ))
+            .id();
+        world.resource_mut::<EntityRegistry>().register(player);
+
+        let mut schedule = bevy_ecs::schedule::Schedule::default();
+        schedule.add_systems(process_walk_away);
+        schedule.run(&mut world);
+        world.flush();
+
+        let tier = world.get::<AnimationTier>(npc).unwrap();
+        assert_eq!(
+            *tier,
+            AnimationTier::Tier2,
+            "Walk-away should shift NPC to Tier 2 animation"
+        );
+    }
+
+    #[test]
+    fn walk_away_records_routine_deviation() {
+        use crate::knowledge::KnowledgeEventQueue;
+        use crate::npc::{DeviationTrigger, RoutineDeviation};
+
+        let mut world = setup_dialogue_world();
+        world.init_resource::<KnowledgeEventQueue>();
+        world.resource_mut::<SimulationTime>().tick = 42;
+
+        let npc = world.spawn_empty().id();
+        world.resource_mut::<EntityRegistry>().register(npc);
+
+        let player = world
+            .spawn((
+                PlayerCharacter,
+                TilePosition::new(5, 6, 0),
+                KnowledgeGraph::new(),
+                ActiveDialogue {
+                    target: npc,
+                    interaction_type: crate::knowledge::events::InteractionType::Talk,
+                    started_tick: 10,
+                },
+                WalkAwayRequest,
+            ))
+            .id();
+        world.resource_mut::<EntityRegistry>().register(player);
+
+        let mut schedule = bevy_ecs::schedule::Schedule::default();
+        schedule.add_systems(process_walk_away);
+        schedule.run(&mut world);
+        world.flush();
+
+        let deviation = world.get::<RoutineDeviation>(npc).unwrap();
+        assert_eq!(
+            deviation.trigger,
+            DeviationTrigger::WalkAway,
+            "Deviation trigger should be WalkAway"
+        );
+        assert_eq!(deviation.tick, 42, "Deviation should record the walk-away tick");
+    }
+
+    #[test]
+    fn walk_away_without_dialogue_does_not_affect_npcs() {
+        use crate::knowledge::KnowledgeEventQueue;
+        use crate::npc::{AnimationTier, RoutineDeviation};
+
+        let mut world = setup_dialogue_world();
+        world.init_resource::<KnowledgeEventQueue>();
+
+        let npc = world.spawn_empty().id();
+        world.resource_mut::<EntityRegistry>().register(npc);
+
+        // Player with WalkAwayRequest but NO ActiveDialogue
+        let player = world
+            .spawn((
+                PlayerCharacter,
+                TilePosition::new(5, 6, 0),
+                KnowledgeGraph::new(),
+                WalkAwayRequest,
+            ))
+            .id();
+        world.resource_mut::<EntityRegistry>().register(player);
+
+        let mut schedule = bevy_ecs::schedule::Schedule::default();
+        schedule.add_systems(process_walk_away);
+        schedule.run(&mut world);
+        world.flush();
+
+        assert!(
+            world.get::<AnimationTier>(npc).is_none(),
+            "NPC should not get AnimationTier when no dialogue was active"
+        );
+        assert!(
+            world.get::<RoutineDeviation>(npc).is_none(),
+            "NPC should not get RoutineDeviation when no dialogue was active"
+        );
+    }
+
    use rand::SeedableRng;
+
+    // === Confrontation Response Tests (#520, D-063) ===
+
+    #[test]
+    fn confrontation_shifts_npc_to_tier2() {
+        let mut world = bevy_ecs::world::World::new();
+        world.insert_resource(SimulationTime::default());
+        world.init_resource::<EntityRegistry>();
+        world.insert_resource(SimRng::new(42));
+
+        let npc = world
+            .spawn((crate::npc::Npc, TilePosition::new(5, 6, 0)))
+            .id();
+        let npc_sid = world.resource_mut::<EntityRegistry>().register(npc);
+
+        let mut kg = KnowledgeGraph::new();
+        kg.observe_entity(npc_sid, TilePosition::new(5, 6, 0), 0);
+        kg.set_relationship(&npc_sid, RelationshipState::Known);
+
+        world.spawn((
+            PlayerCharacter,
+            TilePosition::new(5, 5, 0),
+            kg,
+            ConfrontationDelivered { target: npc },
+            MonologueBuffer::default(),
+            MonologueState::default(),
+        ));
+
+        let mut schedule = bevy_ecs::schedule::Schedule::default();
+        schedule.add_systems(process_confrontation_response);
+        schedule.run(&mut world);
+        world.flush();
+
+        let tier = world.get::<crate::npc::AnimationTier>(npc);
+        assert_eq!(
+            tier,
+            Some(&crate::npc::AnimationTier::Tier2),
+            "NPC should shift to Tier2 after confrontation"
+        );
+    }
+
+    #[test]
+    fn confrontation_decrements_relationship() {
+        let mut world = bevy_ecs::world::World::new();
+        world.insert_resource(SimulationTime::default());
+        world.init_resource::<EntityRegistry>();
+        world.insert_resource(SimRng::new(42));
+
+        let npc = world
+            .spawn((crate::npc::Npc, TilePosition::new(5, 6, 0)))
+            .id();
+        let npc_sid = world.resource_mut::<EntityRegistry>().register(npc);
+
+        let mut kg = KnowledgeGraph::new();
+        kg.observe_entity(npc_sid, TilePosition::new(5, 6, 0), 0);
+        kg.set_relationship(&npc_sid, RelationshipState::Known);
+
+        let player = world
+            .spawn((
+                PlayerCharacter,
+                TilePosition::new(5, 5, 0),
+                kg,
+                ConfrontationDelivered { target: npc },
+                MonologueBuffer::default(),
+                MonologueState::default(),
+            ))
+            .id();
+
+        let mut schedule = bevy_ecs::schedule::Schedule::default();
+        schedule.add_systems(process_confrontation_response);
+        schedule.run(&mut world);
+
+        let player_kg = world.get::<KnowledgeGraph>(player).unwrap();
+        assert_eq!(
+            player_kg.relationship_with(&npc_sid),
+            RelationshipState::PersonOfInterest,
+            "Known → PersonOfInterest after confrontation"
+        );
+    }
+
+    #[test]
+    fn confrontation_emits_monologue_spike() {
+        let mut world = bevy_ecs::world::World::new();
+        world.insert_resource(SimulationTime::default());
+        world.init_resource::<EntityRegistry>();
+        world.insert_resource(SimRng::new(42));
+
+        let npc = world
+            .spawn((crate::npc::Npc, TilePosition::new(5, 6, 0)))
+            .id();
+        let npc_sid = world.resource_mut::<EntityRegistry>().register(npc);
+
+        let mut kg = KnowledgeGraph::new();
+        kg.observe_entity(npc_sid, TilePosition::new(5, 6, 0), 0);
+
+        let player = world
+            .spawn((
+                PlayerCharacter,
+                TilePosition::new(5, 5, 0),
+                kg,
+                ConfrontationDelivered { target: npc },
+                MonologueBuffer::default(),
+                MonologueState::default(),
+            ))
+            .id();
+
+        let mut schedule = bevy_ecs::schedule::Schedule::default();
+        schedule.add_systems(process_confrontation_response);
+        schedule.run(&mut world);
+
+        let mut buffer = world.get_mut::<MonologueBuffer>(player).unwrap();
+        let event = buffer.take();
+        assert!(event.is_some(), "Monologue spike should be emitted");
+        assert!(
+            event.unwrap().id.starts_with("confront_"),
+            "Should be a confrontation monologue line"
+        );
+    }
+
+    #[test]
+    fn confrontation_clears_marker() {
+        let mut world = bevy_ecs::world::World::new();
+        world.insert_resource(SimulationTime::default());
+        world.init_resource::<EntityRegistry>();
+        world.insert_resource(SimRng::new(42));
+
+        let npc = world
+            .spawn((crate::npc::Npc, TilePosition::new(5, 6, 0)))
+            .id();
+        let npc_sid = world.resource_mut::<EntityRegistry>().register(npc);
+
+        let mut kg = KnowledgeGraph::new();
+        kg.observe_entity(npc_sid, TilePosition::new(5, 6, 0), 0);
+
+        let player = world
+            .spawn((
+                PlayerCharacter,
+                TilePosition::new(5, 5, 0),
+                kg,
+                ConfrontationDelivered { target: npc },
+                MonologueBuffer::default(),
+                MonologueState::default(),
+            ))
+            .id();
+
+        let mut schedule = bevy_ecs::schedule::Schedule::default();
+        schedule.add_systems(process_confrontation_response);
+        schedule.run(&mut world);
+        world.flush();
+
+        assert!(
+            world.get::<ConfrontationDelivered>(player).is_none(),
+            "Marker should be removed after processing"
+        );
+    }
 }