diff --git a/server/src/npc/routine.rs b/server/src/npc/routine.rs index 4a97e8adf..cbd4ace1d 100644 --- a/server/src/npc/routine.rs +++ b/server/src/npc/routine.rs @@ -1,16 +1,43 @@ -//! Daily routine system (#88). +//! Daily routine system (#88, #101). //! //! Detects day-phase transitions (D-031) and issues PathRequests for NPCs -//! whose DailyRoutine has a location for the new phase. +//! whose DailyRoutine has a location for the new phase. Tracks NPC activity +//! state when they arrive at their routine destination (#101). +//! +//! Pipeline: phase transition → PathRequest → pathfinder → path_follow → +//! NPC arrives → enter_activity sets ActivityState. use bevy_ecs::prelude::*; +use serde::{Deserialize, Serialize}; use crate::npc::{DailyRoutine, Npc}; use crate::simulation::movement::TilePosition; -use crate::simulation::pathfinding::PathRequest; +use crate::simulation::pathfinding::{ComputedPath, PathRequest}; use crate::simulation::tier::ActiveSim; use crate::simulation::time::{DayPhase, SimulationTime}; +// --------------------------------------------------------------------------- +// ActivityState component (#101) +// --------------------------------------------------------------------------- + +/// Tracks the activity an NPC is currently performing at their routine location. +/// +/// Set by `enter_activity` when an NPC: +/// 1. Has no active `ComputedPath` or `PathRequest` (finished walking) +/// 2. Is at the location specified by their `DailyRoutine` for the current phase +/// +/// Cleared on phase transitions (replaced with new activity or removed). +/// Feeds `TellTrigger::DuringActivity` and D-028 Layer 2 situation matching. +#[derive(Component, Debug, Clone, Serialize, Deserialize)] +pub struct ActivityState { + /// Activity name from `RoutineEntry.activity` (e.g., "Work", "Bar", "Sleep"). + pub activity: String, + /// The day phase this activity belongs to. + pub phase: DayPhase, + /// Tick when the NPC arrived and started this activity. + pub started_tick: u64, +} + /// Resource tracking the previous day phase for transition detection. #[derive(Resource, Debug, Clone)] pub struct PreviousDayPhase { @@ -57,6 +84,9 @@ pub fn check_phase_transition( previous.day = current_day; for (entity, current_pos, routine) in npcs.iter() { + // Clear stale activity on phase transition — will be re-evaluated by enter_activity + commands.entity(entity).remove::(); + if let Some(expected_location) = routine.expected_location(current_phase) { if *current_pos != expected_location { commands.entity(entity).insert(PathRequest { @@ -73,6 +103,76 @@ pub fn check_phase_transition( } } +// --------------------------------------------------------------------------- +// System: enter_activity (#101) +// --------------------------------------------------------------------------- + +/// Set ActivityState when an NPC has arrived at their routine destination. +/// +/// Runs after movement validation. Checks NPCs that: +/// - Have a DailyRoutine and ActiveSim tier +/// - Are NOT currently pathfinding (no ComputedPath or PathRequest) +/// - Are at the location specified for the current day phase +/// - Don't already have the correct ActivityState for the current phase +/// +/// When conditions are met, inserts an ActivityState component. When an NPC +/// has a stale activity from a previous phase and isn't at the new phase's +/// destination, the stale activity is removed. +/// +/// System ordering: after validate_movement, before compute_observer_snapshot. +pub fn enter_activity( + mut commands: Commands, + time: Res, + npcs: Query< + ( + Entity, + &TilePosition, + &DailyRoutine, + Option<&ActivityState>, + ), + ( + With, + With, + Without, + Without, + ), + >, +) { + let current_phase = time.day_phase(); + + for (entity, pos, routine, activity_opt) in npcs.iter() { + // Already performing the correct activity for this phase + if let Some(activity) = activity_opt { + if activity.phase == current_phase { + continue; + } + } + + // Check if at routine destination for current phase + if let Some(entry) = routine.entry_for_phase(current_phase) { + if *pos == entry.location { + commands.entity(entity).insert(ActivityState { + activity: entry.activity.clone(), + phase: current_phase, + started_tick: time.tick, + }); + tracing::trace!( + "Entity {:?}: entered activity '{}' for {:?}", + entity, + entry.activity, + current_phase, + ); + } else { + // Not at destination yet — remove stale activity + commands.entity(entity).remove::(); + } + } else { + // No routine entry for this phase — remove stale activity + commands.entity(entity).remove::(); + } + } +} + #[cfg(test)] mod tests { use super::*; @@ -243,4 +343,318 @@ mod tests { let request = world.get::(entity).unwrap(); assert_eq!(request.goal, morning_loc); } + + // -- enter_activity tests (#101) ------------------------------------------ + + #[test] + fn npc_at_routine_destination_gets_activity_state() { + let mut world = setup_world(); + // Time = Afternoon + world.resource_mut::().tick = MINUTES_PER_PHASE * TICKS_PER_GAME_MINUTE; + + let loc = TilePosition::new(10, 10, 0); + let entity = world + .spawn(( + Npc, + ActiveSim, + loc, // Already at afternoon destination + DailyRoutine { + entries: vec![RoutineEntry { + phase: DayPhase::Afternoon, + location: loc, + activity: "Work".into(), + }], + description: "Test".into(), + }, + )) + .id(); + + let mut schedule = bevy_ecs::schedule::Schedule::default(); + schedule.add_systems(enter_activity); + schedule.run(&mut world); + world.flush(); + + let state = world.get::(entity).unwrap(); + assert_eq!(state.activity, "Work"); + assert_eq!(state.phase, DayPhase::Afternoon); + assert_eq!(state.started_tick, MINUTES_PER_PHASE * TICKS_PER_GAME_MINUTE); + } + + #[test] + fn npc_not_at_destination_no_activity_state() { + let mut world = setup_world(); + world.resource_mut::().tick = MINUTES_PER_PHASE * TICKS_PER_GAME_MINUTE; + + let entity = world + .spawn(( + Npc, + ActiveSim, + TilePosition::new(5, 5, 0), // NOT at afternoon location + DailyRoutine { + entries: vec![RoutineEntry { + phase: DayPhase::Afternoon, + location: TilePosition::new(10, 10, 0), + activity: "Work".into(), + }], + description: "Test".into(), + }, + )) + .id(); + + let mut schedule = bevy_ecs::schedule::Schedule::default(); + schedule.add_systems(enter_activity); + schedule.run(&mut world); + world.flush(); + + assert!(world.get::(entity).is_none()); + } + + #[test] + fn npc_with_computed_path_excluded() { + let mut world = setup_world(); + world.resource_mut::().tick = MINUTES_PER_PHASE * TICKS_PER_GAME_MINUTE; + + let loc = TilePosition::new(10, 10, 0); + let entity = world + .spawn(( + Npc, + ActiveSim, + loc, // At destination but still has a path + DailyRoutine { + entries: vec![RoutineEntry { + phase: DayPhase::Afternoon, + location: loc, + activity: "Work".into(), + }], + description: "Test".into(), + }, + ComputedPath { + steps: vec![], + current_index: 0, + }, + )) + .id(); + + let mut schedule = bevy_ecs::schedule::Schedule::default(); + schedule.add_systems(enter_activity); + schedule.run(&mut world); + world.flush(); + + assert!( + world.get::(entity).is_none(), + "NPC with ComputedPath should not get ActivityState" + ); + } + + #[test] + fn npc_with_path_request_excluded() { + let mut world = setup_world(); + world.resource_mut::().tick = MINUTES_PER_PHASE * TICKS_PER_GAME_MINUTE; + + let loc = TilePosition::new(10, 10, 0); + let entity = world + .spawn(( + Npc, + ActiveSim, + loc, + DailyRoutine { + entries: vec![RoutineEntry { + phase: DayPhase::Afternoon, + location: loc, + activity: "Work".into(), + }], + description: "Test".into(), + }, + PathRequest { goal: loc }, + )) + .id(); + + let mut schedule = bevy_ecs::schedule::Schedule::default(); + schedule.add_systems(enter_activity); + schedule.run(&mut world); + world.flush(); + + assert!( + world.get::(entity).is_none(), + "NPC with PathRequest should not get ActivityState" + ); + } + + #[test] + fn existing_activity_same_phase_not_overwritten() { + let mut world = setup_world(); + let tick = MINUTES_PER_PHASE * TICKS_PER_GAME_MINUTE; + world.resource_mut::().tick = tick + 100; + + let loc = TilePosition::new(10, 10, 0); + let entity = world + .spawn(( + Npc, + ActiveSim, + loc, + DailyRoutine { + entries: vec![RoutineEntry { + phase: DayPhase::Afternoon, + location: loc, + activity: "Work".into(), + }], + description: "Test".into(), + }, + ActivityState { + activity: "Work".into(), + phase: DayPhase::Afternoon, + started_tick: tick, // Set earlier + }, + )) + .id(); + + let mut schedule = bevy_ecs::schedule::Schedule::default(); + schedule.add_systems(enter_activity); + schedule.run(&mut world); + world.flush(); + + let state = world.get::(entity).unwrap(); + assert_eq!( + state.started_tick, tick, + "started_tick should be preserved, not updated" + ); + } + + #[test] + fn stale_activity_replaced_on_phase_change() { + let mut world = setup_world(); + // Time = Evening (after Afternoon) + let evening_tick = 2 * MINUTES_PER_PHASE * TICKS_PER_GAME_MINUTE; + world.resource_mut::().tick = evening_tick; + + let evening_loc = TilePosition::new(20, 20, 0); + let entity = world + .spawn(( + Npc, + ActiveSim, + evening_loc, // Already at evening location + DailyRoutine { + entries: vec![ + RoutineEntry { + phase: DayPhase::Afternoon, + location: TilePosition::new(10, 10, 0), + activity: "Work".into(), + }, + RoutineEntry { + phase: DayPhase::Evening, + location: evening_loc, + activity: "Bar".into(), + }, + ], + description: "Test".into(), + }, + // Stale activity from previous phase + ActivityState { + activity: "Work".into(), + phase: DayPhase::Afternoon, + started_tick: 1000, + }, + )) + .id(); + + let mut schedule = bevy_ecs::schedule::Schedule::default(); + schedule.add_systems(enter_activity); + schedule.run(&mut world); + world.flush(); + + let state = world.get::(entity).unwrap(); + assert_eq!(state.activity, "Bar"); + assert_eq!(state.phase, DayPhase::Evening); + assert_eq!(state.started_tick, evening_tick); + } + + #[test] + fn no_routine_for_phase_clears_stale_activity() { + let mut world = setup_world(); + // Time = Night + let night_tick = 3 * MINUTES_PER_PHASE * TICKS_PER_GAME_MINUTE; + world.resource_mut::().tick = night_tick; + + let entity = world + .spawn(( + Npc, + ActiveSim, + TilePosition::new(10, 10, 0), + DailyRoutine { + entries: vec![RoutineEntry { + phase: DayPhase::Evening, + location: TilePosition::new(10, 10, 0), + activity: "Bar".into(), + }], + description: "Test".into(), + }, + // Stale activity from Evening, no Night entry + ActivityState { + activity: "Bar".into(), + phase: DayPhase::Evening, + started_tick: 1000, + }, + )) + .id(); + + let mut schedule = bevy_ecs::schedule::Schedule::default(); + schedule.add_systems(enter_activity); + schedule.run(&mut world); + world.flush(); + + assert!( + world.get::(entity).is_none(), + "Stale activity should be cleared when no routine entry for current phase" + ); + } + + #[test] + fn phase_transition_clears_activity_state() { + let mut world = setup_world(); + + let loc = TilePosition::new(10, 10, 0); + let entity = world + .spawn(( + Npc, + ActiveSim, + loc, + DailyRoutine { + entries: vec![ + RoutineEntry { + phase: DayPhase::Morning, + location: loc, + activity: "Work".into(), + }, + RoutineEntry { + phase: DayPhase::Afternoon, + location: TilePosition::new(20, 20, 0), + activity: "Lunch".into(), + }, + ], + description: "Test".into(), + }, + ActivityState { + activity: "Work".into(), + phase: DayPhase::Morning, + started_tick: 0, + }, + )) + .id(); + + // Trigger phase transition to Afternoon + world.resource_mut::().tick = MINUTES_PER_PHASE * TICKS_PER_GAME_MINUTE; + + let mut schedule = bevy_ecs::schedule::Schedule::default(); + schedule.add_systems(check_phase_transition); + schedule.run(&mut world); + world.flush(); + + // ActivityState should be cleared by phase transition + assert!( + world.get::(entity).is_none(), + "Phase transition should clear ActivityState" + ); + // PathRequest should be set for the new phase location + assert!(world.get::(entity).is_some()); + } }