feat: better 'Vulnerable' tag for ghosts, fix movement issues

src/app.rs

@@ -1,6 +1,5 @@
 use std::time::{Duration, Instant};
 
-use glam::Vec2;
 use sdl2::render::TextureCreator;
 use sdl2::ttf::Sdl2TtfContext;
 use sdl2::video::WindowContext;
@@ -21,7 +20,6 @@ pub struct App {
     pub game: Game,
     last_tick: Instant,
     focused: bool,
-    _cursor_pos: Vec2,
 }
 
 impl App {
@@ -81,7 +79,6 @@ impl App {
             game,
             focused: true,
             last_tick: Instant::now(),
-            _cursor_pos: Vec2::ZERO,
         })
     }
 

src/game.rs

@@ -8,29 +8,23 @@ use crate::events::GameEvent;
 use crate::map::builder::Map;
 use crate::map::direction::Direction;
 use crate::systems::blinking::Blinking;
+use crate::systems::{self, ghost_collision_system};
+
 use crate::systems::movement::{BufferedDirection, Position, Velocity};
-use crate::systems::player::player_movement_system;
 use crate::systems::profiling::SystemId;
+use crate::systems::render::RenderDirty;
 use crate::systems::{
-    audio::{audio_system, AudioEvent, AudioResource},
-    blinking::blinking_system,
-    collision::collision_system,
-    components::{
-        AudioState, Collider, DeltaTime, DirectionalAnimated, EntityType, Ghost, GhostBundle, GhostCollider, GlobalState,
-        ItemBundle, ItemCollider, PacmanCollider, PlayerBundle, PlayerControlled, RenderDirty, Renderable, ScoreResource,
-    },
-    debug::{debug_render_system, DebugFontResource, DebugState, DebugTextureResource},
-    ghost::ghost_movement_system,
-    input::input_system,
-    item::item_system,
-    player::player_control_system,
-    profiling::{profile, SystemTimings},
-    render::{directional_render_system, dirty_render_system, render_system, BackbufferResource, MapTextureResource},
+    audio_system, blinking_system, collision_system, debug_render_system, directional_render_system, dirty_render_system,
+    ghost_movement_system, hud_render_system, item_system, profile, ready_visibility_system, render_system, AudioEvent,
+    AudioResource, AudioState, BackbufferResource, Collider, DebugFontResource, DebugState, DebugTextureResource, DeltaTime,
+    DirectionalAnimated, EntityType, Frozen, Ghost, GhostBundle, GhostCollider, GlobalState, ItemBundle, ItemCollider,
+    LevelTiming, MapTextureResource, PacmanCollider, PlayerBundle, PlayerControlled, PlayerStateBundle, Renderable,
+    ScoreResource, StartupSequence, SystemTimings,
 };
 use crate::texture::animated::AnimatedTexture;
 use bevy_ecs::event::EventRegistry;
 use bevy_ecs::observer::Trigger;
-use bevy_ecs::schedule::Schedule;
+use bevy_ecs::schedule::{IntoScheduleConfigs, Schedule, SystemSet};
 use bevy_ecs::system::{NonSendMut, Res, ResMut};
 use bevy_ecs::world::World;
 use sdl2::image::LoadTexture;
@@ -48,6 +42,10 @@ use crate::{
     texture::sprite::{AtlasMapper, SpriteAtlas},
 };
 
+/// System set for all rendering systems to ensure they run after gameplay logic
+#[derive(SystemSet, Debug, Hash, PartialEq, Eq, Clone)]
+pub struct RenderSet;
+
 /// Core game state manager built on the Bevy ECS architecture.
 ///
 /// Orchestrates all game systems through a centralized `World` containing entities,
@@ -205,6 +203,11 @@ impl Game {
             pacman_collider: PacmanCollider,
         };
 
+        // Spawn player and attach initial state bundle
+        let player_entity = world.spawn(player).id();
+        world.entity_mut(player_entity).insert(PlayerStateBundle::default());
+        world.entity_mut(player_entity).insert(Frozen);
+
         world.insert_non_send_resource(atlas);
         world.insert_non_send_resource(event_pump);
         world.insert_non_send_resource(canvas);
@@ -224,6 +227,7 @@ impl Game {
         world.insert_resource(DebugState::default());
         world.insert_resource(AudioState::default());
         world.insert_resource(CursorPosition::default());
+        world.insert_resource(LevelTiming::for_level(1));
 
         world.add_observer(
             |event: Trigger<GameEvent>, mut state: ResMut<GlobalState>, _score: ResMut<ScoreResource>| {
@@ -232,39 +236,74 @@ impl Game {
                 }
             },
         );
-        schedule.add_systems((
-            profile(SystemId::Input, input_system),
-            profile(SystemId::PlayerControls, player_control_system),
-            profile(SystemId::PlayerMovement, player_movement_system),
-            profile(SystemId::Ghost, ghost_movement_system),
-            profile(SystemId::Collision, collision_system),
-            profile(SystemId::Item, item_system),
-            profile(SystemId::Audio, audio_system),
-            profile(SystemId::Blinking, blinking_system),
-            profile(SystemId::DirectionalRender, directional_render_system),
-            profile(SystemId::DirtyRender, dirty_render_system),
-            profile(SystemId::Render, render_system),
-            profile(SystemId::DebugRender, debug_render_system),
-            profile(
-                SystemId::Present,
-                |mut canvas: NonSendMut<&mut Canvas<Window>>,
-                 backbuffer: NonSendMut<BackbufferResource>,
-                 debug_state: Res<DebugState>,
-                 mut dirty: ResMut<RenderDirty>| {
-                    if dirty.0 || debug_state.enabled {
-                        // Only copy backbuffer to main canvas if debug rendering is off
-                        // (debug rendering draws directly to main canvas)
-                        if !debug_state.enabled {
-                            canvas.present();
-                        }
-                        dirty.0 = false;
+
+        let input_system = profile(SystemId::Input, systems::input::input_system);
+        let player_control_system = profile(SystemId::PlayerControls, systems::player_control_system);
+        let player_movement_system = profile(SystemId::PlayerMovement, systems::player_movement_system);
+        let startup_stage_system = profile(SystemId::Stage, systems::startup_stage_system);
+        let player_tunnel_slowdown_system = profile(SystemId::PlayerMovement, systems::player::player_tunnel_slowdown_system);
+        let ghost_movement_system = profile(SystemId::Ghost, ghost_movement_system);
+        let collision_system = profile(SystemId::Collision, collision_system);
+        let ghost_collision_system = profile(SystemId::GhostCollision, ghost_collision_system);
+        let vulnerable_tick_system = profile(SystemId::Ghost, systems::vulnerable_tick_system);
+        let item_system = profile(SystemId::Item, item_system);
+        let audio_system = profile(SystemId::Audio, audio_system);
+        let blinking_system = profile(SystemId::Blinking, blinking_system);
+        let directional_render_system = profile(SystemId::DirectionalRender, directional_render_system);
+        let dirty_render_system = profile(SystemId::DirtyRender, dirty_render_system);
+        let hud_render_system = profile(SystemId::HudRender, hud_render_system);
+        let render_system = profile(SystemId::Render, render_system);
+        let debug_render_system = profile(SystemId::DebugRender, debug_render_system);
+
+        let present_system = profile(
+            SystemId::Present,
+            |mut canvas: NonSendMut<&mut Canvas<Window>>, debug_state: Res<DebugState>, mut dirty: ResMut<RenderDirty>| {
+                if dirty.0 || debug_state.enabled {
+                    // Only copy backbuffer to main canvas if debug rendering is off
+                    // (debug rendering draws directly to main canvas)
+                    if !debug_state.enabled {
+                        canvas.present();
                     }
-                },
-            ),
+                    dirty.0 = false;
+                }
+            },
+        );
+
+        schedule.add_systems((
+            (
+                input_system,
+                player_control_system,
+                player_movement_system,
+                startup_stage_system,
+            )
+                .chain(),
+            player_tunnel_slowdown_system,
+            ghost_movement_system,
+            vulnerable_tick_system,
+            (collision_system, ghost_collision_system, item_system).chain(),
+            audio_system,
+            blinking_system,
+            ready_visibility_system,
+            (
+                directional_render_system,
+                dirty_render_system,
+                render_system,
+                hud_render_system,
+                debug_render_system,
+                present_system,
+            )
+                .chain(),
         ));
 
-        // Spawn player
-        world.spawn(player);
+        // Initialize StartupSequence as a global resource
+        let ready_duration_ticks = {
+            let duration = world
+                .get_resource::<LevelTiming>()
+                .map(|t| t.spawn_freeze_duration)
+                .unwrap_or(1.5);
+            (duration * 60.0) as u32 // Convert to ticks at 60 FPS
+        };
+        world.insert_resource(StartupSequence::new(ready_duration_ticks, 60));
 
         // Spawn ghosts
         Self::spawn_ghosts(&mut world)?;
@@ -413,7 +452,7 @@ impl Game {
                 }
             };
 
-            world.spawn(ghost);
+            world.spawn(ghost).insert(Frozen);
         }
 
         Ok(())
@@ -448,112 +487,6 @@ impl Game {
         state.exit
     }
 
-    // fn check_collisions(&mut self) {
-    //     // Check Pac-Man vs Items
-    //     let potential_collisions = self
-    //         .state
-    //         .collision_system
-    //         .potential_collisions(&self.state.pacman.position());
-
-    //     for entity_id in potential_collisions {
-    //         if entity_id != self.state.pacman_id {
-    //             // Check if this is an item collision
-    //             if let Some(item_index) = self.find_item_by_id(entity_id) {
-    //                 let item = &mut self.state.items[item_index];
-    //                 if !item.is_collected() {
-    //                     item.collect();
-    //                     self.state.score += item.get_score();
-    //                     self.state.audio.eat();
-
-    //                     // Handle energizer effects
-    //                     if matches!(item.item_type, crate::entity::item::ItemType::Energizer) {
-    //                         // TODO: Make ghosts frightened
-    //                         tracing::info!("Energizer collected! Ghosts should become frightened.");
-    //                     }
-    //                 }
-    //             }
-
-    //             // Check if this is a ghost collision
-    //             if let Some(_ghost_index) = self.find_ghost_by_id(entity_id) {
-    //                 // TODO: Handle Pac-Man being eaten by ghost
-    //                 tracing::info!("Pac-Man collided with ghost!");
-    //             }
-    //         }
-    //     }
-    // }
-
-    // fn find_item_by_id(&self, entity_id: EntityId) -> Option<usize> {
-    //     self.state.item_ids.iter().position(|&id| id == entity_id)
-    // }
-
-    // fn find_ghost_by_id(&self, entity_id: EntityId) -> Option<usize> {
-    //     self.state.ghost_ids.iter().position(|&id| id == entity_id)
-    // }
-
-    // pub fn draw<T: sdl2::render::RenderTarget>(&mut self, canvas: &mut Canvas<T>, backbuffer: &mut Texture) -> GameResult<()> {
-    //     // Only render the map texture once and cache it
-    //     if !self.state.map_rendered {
-    //         let mut map_texture = self
-    //             .state
-    //             .texture_creator
-    //             .create_texture_target(None, constants::CANVAS_SIZE.x, constants::CANVAS_SIZE.y)
-    //             .map_err(|e| crate::error::GameError::Sdl(e.to_string()))?;
-
-    //         canvas
-    //             .with_texture_canvas(&mut map_texture, |map_canvas| {
-    //                 let mut map_tiles = Vec::with_capacity(35);
-    //                 for i in 0..35 {
-    //                     let tile_name = format!("maze/tiles/{}.png", i);
-    //                     let tile = SpriteAtlas::get_tile(&self.state.atlas, &tile_name).unwrap();
-    //                     map_tiles.push(tile);
-    //                 }
-    //                 MapRenderer::render_map(map_canvas, &mut self.state.atlas, &mut map_tiles);
-    //             })
-    //             .map_err(|e| crate::error::GameError::Sdl(e.to_string()))?;
-    //         self.state.map_texture = Some(map_texture);
-    //         self.state.map_rendered = true;
-    //     }
-
-    //     canvas.set_draw_color(Color::BLACK);
-    //     canvas.clear();
-    //     if let Some(ref map_texture) = self.state.map_texture {
-    //         canvas.copy(map_texture, None, None).unwrap();
-    //     }
-
-    //     // Render all items
-    //     for item in &self.state.items {
-    //         if let Err(e) = item.render(canvas, &mut self.state.atlas, &self.state.map.graph) {
-    //             tracing::error!("Failed to render item: {}", e);
-    //         }
-    //     }
-
-    //     // Render all ghosts
-    //     for ghost in &self.state.ghosts {
-    //         if let Err(e) = ghost.render(canvas, &mut self.state.atlas, &self.state.map.graph) {
-    //             tracing::error!("Failed to render ghost: {}", e);
-    //         }
-    //     }
-
-    //     if let Err(e) = self.state.pacman.render(canvas, &mut self.state.atlas, &self.state.map.graph) {
-    //         tracing::error!("Failed to render pacman: {}", e);
-    //     }
-
-    //     if self.state.debug_mode {
-    //         if let Err(e) =
-    //             self.state
-    //                 .map
-    //                 .debug_render_with_cursor(canvas, &mut self.state.text_texture, &mut self.state.atlas, cursor_pos)
-    //         {
-    //             tracing::error!("Failed to render debug cursor: {}", e);
-    //         }
-    //         self.render_pathfinding_debug(canvas)?;
-    //     }
-    //     self.draw_hud(canvas)?;
-    //     canvas.present();
-
-    //     Ok(())
-    // }
-
     // /// Renders pathfinding debug lines from each ghost to Pac-Man.
     // ///
     // /// Each ghost's path is drawn in its respective color with a small offset
@@ -617,42 +550,4 @@ impl Game {
 
     //     Ok(())
     // }
-
-    // fn draw_hud<T: sdl2::render::RenderTarget>(&mut self, canvas: &mut Canvas<T>) -> GameResult<()> {
-    //     let lives = 3;
-    //     let score_text = format!("{:02}", self.state.score);
-    //     let x_offset = 4;
-    //     let y_offset = 2;
-    //     let lives_offset = 3;
-    //     let score_offset = 7 - (score_text.len() as i32);
-    //     self.state.text_texture.set_scale(1.0);
-    //     if let Err(e) = self.state.text_texture.render(
-    //         canvas,
-    //         &mut self.state.atlas,
-    //         &format!("{lives}UP   HIGH SCORE   "),
-    //         glam::UVec2::new(8 * lives_offset as u32 + x_offset, y_offset),
-    //     ) {
-    //         tracing::error!("Failed to render HUD text: {}", e);
-    //     }
-    //     if let Err(e) = self.state.text_texture.render(
-    //         canvas,
-    //         &mut self.state.atlas,
-    //         &score_text,
-    //         glam::UVec2::new(8 * score_offset as u32 + x_offset, 8 + y_offset),
-    //     ) {
-    //         tracing::error!("Failed to render score text: {}", e);
-    //     }
-
-    //     // Display FPS information in top-left corner
-    //     // let fps_text = format!("FPS: {:.1} (1s) / {:.1} (10s)", self.fps_1s, self.fps_10s);
-    //     // self.render_text_on(
-    //     //     canvas,
-    //     //     &*texture_creator,
-    //     //     &fps_text,
-    //     //     IVec2::new(10, 10),
-    //     //     Color::RGB(255, 255, 0), // Yellow color for FPS display
-    //     // );
-
-    //     Ok(())
-    // }
 }

src/map/builder.rs

@@ -174,6 +174,17 @@ impl Map {
         })
     }
 
+    /// Returns the `MapTile` at a given node id.
+    pub fn tile_at_node(&self, node_id: NodeId) -> Option<MapTile> {
+        // reverse lookup: node -> grid
+        for (grid_pos, id) in &self.grid_to_node {
+            if *id == node_id {
+                return Some(self.tiles[grid_pos.x as usize][grid_pos.y as usize]);
+            }
+        }
+        None
+    }
+
     /// Constructs the ghost house area with restricted access and internal navigation.
     ///
     /// Creates a multi-level ghost house with entrance control, internal movement

src/systems/audio.rs

@@ -6,10 +6,20 @@
 
 use bevy_ecs::{
     event::{Event, EventReader, EventWriter},
+    resource::Resource,
     system::{NonSendMut, ResMut},
 };
 
-use crate::{audio::Audio, error::GameError, systems::components::AudioState};
+use crate::{audio::Audio, error::GameError};
+
+/// Resource for tracking audio state
+#[derive(Resource, Debug, Clone, Default)]
+pub struct AudioState {
+    /// Whether audio is currently muted
+    pub muted: bool,
+    /// Current sound index for cycling through eat sounds
+    pub sound_index: usize,
+}
 
 /// Events for triggering audio playback
 #[derive(Event, Debug, Clone, Copy, PartialEq, Eq)]

src/systems/collision.rs

@@ -1,13 +1,37 @@
+use bevy_ecs::component::Component;
 use bevy_ecs::entity::Entity;
-use bevy_ecs::event::EventWriter;
+use bevy_ecs::event::{EventReader, EventWriter};
 use bevy_ecs::query::With;
-use bevy_ecs::system::{Query, Res};
+use bevy_ecs::system::{Commands, Query, Res, ResMut};
 
 use crate::error::GameError;
 use crate::events::GameEvent;
 use crate::map::builder::Map;
-use crate::systems::components::{Collider, GhostCollider, ItemCollider, PacmanCollider};
 use crate::systems::movement::Position;
+use crate::systems::{AudioEvent, Ghost, PlayerControlled, ScoreResource, Vulnerable};
+
+#[derive(Component)]
+pub struct Collider {
+    pub size: f32,
+}
+
+impl Collider {
+    /// Checks if this collider collides with another collider at the given distance.
+    pub fn collides_with(&self, other_size: f32, distance: f32) -> bool {
+        let collision_distance = (self.size + other_size) / 2.0;
+        distance < collision_distance
+    }
+}
+
+/// Marker components for collision filtering optimization
+#[derive(Component)]
+pub struct PacmanCollider;
+
+#[derive(Component)]
+pub struct GhostCollider;
+
+#[derive(Component)]
+pub struct ItemCollider;
 
 /// Helper function to check collision between two entities with colliders.
 pub fn check_collision(
@@ -82,3 +106,46 @@ pub fn collision_system(
         }
     }
 }
+
+pub fn ghost_collision_system(
+    mut commands: Commands,
+    mut collision_events: EventReader<GameEvent>,
+    mut score: ResMut<ScoreResource>,
+    pacman_query: Query<(), With<PlayerControlled>>,
+    ghost_query: Query<(Entity, &Ghost), With<GhostCollider>>,
+    vulnerable_query: Query<Entity, With<Vulnerable>>,
+    mut events: EventWriter<AudioEvent>,
+) {
+    for event in collision_events.read() {
+        if let GameEvent::Collision(entity1, entity2) = event {
+            // Check if one is Pacman and the other is a ghost
+            let (_pacman_entity, ghost_entity) = if pacman_query.get(*entity1).is_ok() && ghost_query.get(*entity2).is_ok() {
+                (*entity1, *entity2)
+            } else if pacman_query.get(*entity2).is_ok() && ghost_query.get(*entity1).is_ok() {
+                (*entity2, *entity1)
+            } else {
+                continue;
+            };
+
+            // Check if the ghost is vulnerable
+            if let Ok((ghost_ent, _ghost_type)) = ghost_query.get(ghost_entity) {
+                // Check if ghost has Vulnerable component
+                if vulnerable_query.get(ghost_ent).is_ok() {
+                    // Pac-Man eats the ghost
+                    // Add score (200 points per ghost eaten)
+                    score.0 += 200;
+
+                    // Remove the ghost
+                    commands.entity(ghost_ent).despawn();
+
+                    // Play eat sound
+                    events.write(AudioEvent::PlayEat);
+                } else {
+                    // Pac-Man dies (this would need a death system)
+                    // For now, just log it
+                    tracing::warn!("Pac-Man collided with ghost while not vulnerable!");
+                }
+            }
+        }
+    }
+}

src/systems/components.rs

@@ -3,7 +3,10 @@ use bitflags::bitflags;
 
 use crate::{
     map::graph::TraversalFlags,
-    systems::movement::{BufferedDirection, Position, Velocity},
+    systems::{
+        movement::{BufferedDirection, Position, Velocity},
+        Collider, GhostCollider, ItemCollider, PacmanCollider, PlayerLifecycle,
+    },
     texture::{animated::AnimatedTexture, sprite::AtlasTile},
 };
 
@@ -109,28 +112,73 @@ bitflags! {
     }
 }
 
-#[derive(Component)]
-pub struct Collider {
-    pub size: f32,
+#[derive(Resource)]
+pub struct GlobalState {
+    pub exit: bool,
 }
 
-impl Collider {
-    /// Checks if this collider collides with another collider at the given distance.
-    pub fn collides_with(&self, other_size: f32, distance: f32) -> bool {
-        let collision_distance = (self.size + other_size) / 2.0;
-        distance < collision_distance
+#[derive(Resource)]
+pub struct ScoreResource(pub u32);
+
+#[derive(Resource)]
+pub struct DeltaTime(pub f32);
+
+/// Movement modifiers that can affect Pac-Man's speed or handling.
+#[derive(Component, Debug, Clone, Copy)]
+pub struct MovementModifiers {
+    /// Multiplier applied to base speed (e.g., tunnels)
+    pub speed_multiplier: f32,
+    /// True when currently in a tunnel slowdown region
+    pub tunnel_slowdown_active: bool,
+}
+
+impl Default for MovementModifiers {
+    fn default() -> Self {
+        Self {
+            speed_multiplier: 1.0,
+            tunnel_slowdown_active: false,
+        }
     }
 }
 
-/// Marker components for collision filtering optimization
-#[derive(Component)]
-pub struct PacmanCollider;
+/// Level-dependent timing configuration
+#[derive(Resource, Debug, Clone, Copy)]
+pub struct LevelTiming {
+    /// Duration of energizer effect in seconds
+    pub energizer_duration: f32,
+    /// Freeze duration at spawn/ready in seconds
+    pub spawn_freeze_duration: f32,
+    /// When to start flashing relative to energizer end (seconds)
+    pub energizer_flash_threshold: f32,
+}
 
-#[derive(Component)]
-pub struct GhostCollider;
+impl Default for LevelTiming {
+    fn default() -> Self {
+        Self {
+            energizer_duration: 6.0,
+            spawn_freeze_duration: 1.5,
+            energizer_flash_threshold: 2.0,
+        }
+    }
+}
 
-#[derive(Component)]
-pub struct ItemCollider;
+impl LevelTiming {
+    /// Returns timing configuration for a given level.
+    pub fn for_level(_level: u32) -> Self {
+        // Placeholder: tune per the Pac-Man Dossier tables
+        Self::default()
+    }
+}
+
+/// Tag component for entities that should be frozen during startup
+#[derive(Component, Debug, Clone, Copy)]
+pub struct Frozen;
+
+/// Component for ghosts that are vulnerable to Pac-Man
+#[derive(Component, Debug, Clone, Copy)]
+pub struct Vulnerable {
+    pub remaining_ticks: u32,
+}
 
 #[derive(Bundle)]
 pub struct PlayerBundle {
@@ -145,6 +193,13 @@ pub struct PlayerBundle {
     pub pacman_collider: PacmanCollider,
 }
 
+/// Convenience bundle for attaching the hybrid FSM to the player entity
+#[derive(Bundle, Default)]
+pub struct PlayerStateBundle {
+    pub lifecycle: PlayerLifecycle,
+    pub movement_modifiers: MovementModifiers,
+}
+
 #[derive(Bundle)]
 pub struct ItemBundle {
     pub position: Position,
@@ -165,26 +220,3 @@ pub struct GhostBundle {
     pub collider: Collider,
     pub ghost_collider: GhostCollider,
 }
-
-#[derive(Resource)]
-pub struct GlobalState {
-    pub exit: bool,
-}
-
-#[derive(Resource)]
-pub struct ScoreResource(pub u32);
-
-#[derive(Resource)]
-pub struct DeltaTime(pub f32);
-
-#[derive(Resource, Default)]
-pub struct RenderDirty(pub bool);
-
-/// Resource for tracking audio state
-#[derive(Resource, Debug, Clone, Default)]
-pub struct AudioState {
-    /// Whether audio is currently muted
-    pub muted: bool,
-    /// Current sound index for cycling through eat sounds
-    pub sound_index: usize,
-}

src/systems/debug.rs

@@ -3,12 +3,9 @@ use std::cmp::Ordering;
 
 use crate::constants::BOARD_PIXEL_OFFSET;
 use crate::map::builder::Map;
-use crate::systems::components::Collider;
-use crate::systems::input::CursorPosition;
-use crate::systems::movement::Position;
-use crate::systems::profiling::SystemTimings;
-use crate::systems::render::BackbufferResource;
-use bevy_ecs::prelude::*;
+use crate::systems::{BackbufferResource, Collider, CursorPosition, Position, SystemTimings};
+use bevy_ecs::resource::Resource;
+use bevy_ecs::system::{NonSendMut, Query, Res};
 use glam::{IVec2, UVec2, Vec2};
 use sdl2::pixels::Color;
 use sdl2::rect::{Point, Rect};

src/systems/ghost.rs

@@ -1,7 +1,4 @@
-use bevy_ecs::system::{Query, Res};
-use rand::prelude::*;
-use smallvec::SmallVec;
-
+use crate::systems::components::Frozen;
 use crate::{
     map::{
         builder::Map,
@@ -13,12 +10,18 @@ use crate::{
         movement::{Position, Velocity},
     },
 };
+use bevy_ecs::query::Without;
+use bevy_ecs::system::{Query, Res};
+use rand::rngs::SmallRng;
+use rand::seq::IndexedRandom;
+use rand::SeedableRng;
+use smallvec::SmallVec;
 
 /// Autonomous ghost AI system implementing randomized movement with backtracking avoidance.
 pub fn ghost_movement_system(
     map: Res<Map>,
     delta_time: Res<DeltaTime>,
-    mut ghosts: Query<(&Ghost, &mut Velocity, &mut Position)>,
+    mut ghosts: Query<(&Ghost, &mut Velocity, &mut Position), Without<Frozen>>,
 ) {
     for (_ghost, mut velocity, mut position) in ghosts.iter_mut() {
         let mut distance = velocity.speed * 60.0 * delta_time.0;

src/systems/item.rs

@@ -1,11 +1,13 @@
-use bevy_ecs::{event::EventReader, prelude::*, query::With, system::Query};
+use bevy_ecs::{
+    entity::Entity,
+    event::{EventReader, EventWriter},
+    query::With,
+    system::{Commands, Query, Res, ResMut},
+};
 
 use crate::{
     events::GameEvent,
-    systems::{
-        audio::AudioEvent,
-        components::{EntityType, ItemCollider, PacmanCollider, ScoreResource},
-    },
+    systems::{AudioEvent, EntityType, GhostCollider, ItemCollider, LevelTiming, PacmanCollider, ScoreResource, Vulnerable},
 };
 
 /// Determines if a collision between two entity types should be handled by the item system.
@@ -25,7 +27,9 @@ pub fn item_system(
     mut score: ResMut<ScoreResource>,
     pacman_query: Query<Entity, With<PacmanCollider>>,
     item_query: Query<(Entity, &EntityType), With<ItemCollider>>,
+    ghost_query: Query<Entity, With<GhostCollider>>,
     mut events: EventWriter<AudioEvent>,
+    level_timing: Res<LevelTiming>,
 ) {
     for event in collision_events.read() {
         if let GameEvent::Collision(entity1, entity2) = event {
@@ -50,6 +54,19 @@ pub fn item_system(
                     if entity_type.is_collectible() {
                         events.write(AudioEvent::PlayEat);
                     }
+
+                    // Make ghosts vulnerable when power pellet is collected
+                    if *entity_type == EntityType::PowerPellet {
+                        // Convert seconds to frames (assumes 60 FPS)
+                        let total_ticks = (level_timing.energizer_duration * 60.0).round().clamp(0.0, u32::MAX as f32) as u32;
+
+                        // Add Vulnerable component to all ghosts
+                        for ghost_entity in ghost_query.iter() {
+                            commands.entity(ghost_entity).insert(Vulnerable {
+                                remaining_ticks: total_ticks,
+                            });
+                        }
+                    }
                 }
             }
         }

src/systems/mod.rs

@@ -16,3 +16,20 @@ pub mod movement;
 pub mod player;
 pub mod profiling;
 pub mod render;
+pub mod stage;
+pub mod vulnerable;
+
+pub use self::audio::*;
+pub use self::blinking::*;
+pub use self::collision::*;
+pub use self::components::*;
+pub use self::debug::*;
+pub use self::ghost::*;
+pub use self::input::*;
+pub use self::item::*;
+pub use self::movement::*;
+pub use self::player::*;
+pub use self::profiling::*;
+pub use self::render::*;
+pub use self::stage::*;
+pub use self::vulnerable::*;

src/systems/player.rs

@@ -1,22 +1,44 @@
 use bevy_ecs::{
+    component::Component,
     event::{EventReader, EventWriter},
-    prelude::ResMut,
-    query::With,
-    system::{Query, Res},
+    query::{With, Without},
+    system::{Query, Res, ResMut},
 };
 
 use crate::{
     error::GameError,
     events::{GameCommand, GameEvent},
-    map::builder::Map,
-    map::graph::Edge,
+    map::{builder::Map, graph::Edge},
     systems::{
-        components::{AudioState, DeltaTime, EntityType, GlobalState, PlayerControlled},
+        components::{DeltaTime, EntityType, Frozen, GlobalState, MovementModifiers, PlayerControlled},
         debug::DebugState,
         movement::{BufferedDirection, Position, Velocity},
+        AudioState,
     },
 };
 
+/// Lifecycle state for the player entity.
+#[derive(Component, Debug, Clone, Copy, PartialEq, Eq)]
+pub enum PlayerLifecycle {
+    Spawning,
+    Alive,
+    Dying,
+    Respawning,
+}
+
+impl PlayerLifecycle {
+    /// Returns true when gameplay input and movement should be active
+    pub fn is_interactive(self) -> bool {
+        matches!(self, PlayerLifecycle::Alive)
+    }
+}
+
+impl Default for PlayerLifecycle {
+    fn default() -> Self {
+        PlayerLifecycle::Spawning
+    }
+}
+
 /// Processes player input commands and updates game state accordingly.
 ///
 /// Handles keyboard-driven commands like movement direction changes, debug mode
@@ -28,12 +50,12 @@ pub fn player_control_system(
     mut state: ResMut<GlobalState>,
     mut debug_state: ResMut<DebugState>,
     mut audio_state: ResMut<AudioState>,
-    mut players: Query<&mut BufferedDirection, With<PlayerControlled>>,
+    mut players: Query<(&PlayerLifecycle, &mut BufferedDirection), (With<PlayerControlled>, Without<Frozen>)>,
     mut errors: EventWriter<GameError>,
 ) {
     // Get the player's movable component (ensuring there is only one player)
-    let mut buffered_direction = match players.single_mut() {
-        Ok(buffered_direction) => buffered_direction,
+    let (lifecycle, mut buffered_direction) = match players.single_mut() {
+        Ok(tuple) => tuple,
         Err(e) => {
             errors.write(GameError::InvalidState(format!(
                 "No/multiple entities queried for player system: {}",
@@ -43,6 +65,9 @@ pub fn player_control_system(
         }
     };
 
+    // If the player is not interactive or input is locked, ignore movement commands
+    // let allow_input = lifecycle.is_interactive();
+
     // Handle events
     for event in events.read() {
         if let GameEvent::Command(command) = event {
@@ -82,10 +107,19 @@ pub fn can_traverse(entity_type: EntityType, edge: Edge) -> bool {
 pub fn player_movement_system(
     map: Res<Map>,
     delta_time: Res<DeltaTime>,
-    mut entities: Query<(&mut Position, &mut Velocity, &mut BufferedDirection), With<PlayerControlled>>,
+    mut entities: Query<
+        (
+            &PlayerLifecycle,
+            &MovementModifiers,
+            &mut Position,
+            &mut Velocity,
+            &mut BufferedDirection,
+        ),
+        (With<PlayerControlled>, Without<Frozen>),
+    >,
     // mut errors: EventWriter<GameError>,
 ) {
-    for (mut position, mut velocity, mut buffered_direction) in entities.iter_mut() {
+    for (lifecycle, modifiers, mut position, mut velocity, mut buffered_direction) in entities.iter_mut() {
         // Decrement the buffered direction remaining time
         if let BufferedDirection::Some {
             direction,
@@ -102,7 +136,7 @@ pub fn player_movement_system(
             }
         }
 
-        let mut distance = velocity.speed * 60.0 * delta_time.0;
+        let mut distance = velocity.speed * modifiers.speed_multiplier * 60.0 * delta_time.0;
 
         loop {
             match *position {
@@ -151,3 +185,16 @@ pub fn player_movement_system(
         }
     }
 }
+
+/// Applies tunnel slowdown based on the current node tile
+pub fn player_tunnel_slowdown_system(map: Res<Map>, mut q: Query<(&Position, &mut MovementModifiers), With<PlayerControlled>>) {
+    if let Ok((position, mut modifiers)) = q.single_mut() {
+        let node = position.current_node();
+        let in_tunnel = map
+            .tile_at_node(node)
+            .map(|t| t == crate::constants::MapTile::Tunnel)
+            .unwrap_or(false);
+        modifiers.tunnel_slowdown_active = in_tunnel;
+        modifiers.speed_multiplier = if in_tunnel { 0.6 } else { 1.0 };
+    }
+}

src/systems/profiling.rs

@@ -1,5 +1,5 @@
-use bevy_ecs::prelude::Resource;
-use bevy_ecs::system::{IntoSystem, System};
+use bevy_ecs::system::IntoSystem;
+use bevy_ecs::{resource::Resource, system::System};
 use circular_buffer::CircularBuffer;
 use micromap::Map;
 use parking_lot::{Mutex, RwLock};
@@ -27,12 +27,15 @@ pub enum SystemId {
     Blinking,
     DirectionalRender,
     DirtyRender,
+    HudRender,
     Render,
     DebugRender,
     Present,
     Collision,
     Item,
     PlayerMovement,
+    GhostCollision,
+    Stage,
 }
 
 impl Display for SystemId {

src/systems/render.rs

@@ -1,16 +1,26 @@
+use crate::constants::CANVAS_SIZE;
 use crate::error::{GameError, TextureError};
 use crate::map::builder::Map;
-use crate::systems::components::{DeltaTime, DirectionalAnimated, RenderDirty, Renderable};
-use crate::systems::movement::{Position, Velocity};
+use crate::systems::{
+    Blinking, DeltaTime, DirectionalAnimated, EntityType, GhostCollider, PlayerControlled, Position, Renderable, ScoreResource,
+    StartupSequence, Velocity,
+};
 use crate::texture::sprite::SpriteAtlas;
+use crate::texture::text::TextTexture;
 use bevy_ecs::entity::Entity;
 use bevy_ecs::event::EventWriter;
-use bevy_ecs::prelude::{Changed, Or, RemovedComponents};
+use bevy_ecs::query::{Changed, Or, With, Without};
+use bevy_ecs::removal_detection::RemovedComponents;
+use bevy_ecs::resource::Resource;
 use bevy_ecs::system::{NonSendMut, Query, Res, ResMut};
+use sdl2::pixels::Color;
 use sdl2::rect::{Point, Rect};
 use sdl2::render::{Canvas, Texture};
 use sdl2::video::Window;
 
+#[derive(Resource, Default)]
+pub struct RenderDirty(pub bool);
+
 #[allow(clippy::type_complexity)]
 pub fn dirty_render_system(
     mut dirty: ResMut<RenderDirty>,
@@ -61,6 +71,110 @@ pub struct MapTextureResource(pub Texture<'static>);
 /// A non-send resource for the backbuffer texture. This just wraps the texture with a type so it can be differentiated when exposed as a resource.
 pub struct BackbufferResource(pub Texture<'static>);
 
+/// Updates entity visibility based on StartupSequence stages
+pub fn ready_visibility_system(
+    startup: Res<StartupSequence>,
+    mut player_query: Query<&mut Renderable, (With<PlayerControlled>, Without<GhostCollider>)>,
+    mut ghost_query: Query<&mut Renderable, (With<GhostCollider>, Without<PlayerControlled>)>,
+    mut energizer_query: Query<(&mut Blinking, &EntityType)>,
+) {
+    match *startup {
+        StartupSequence::TextOnly { .. } => {
+            // Hide player and ghosts, disable energizer blinking
+            if let Ok(mut renderable) = player_query.single_mut() {
+                renderable.visible = false;
+            }
+
+            for mut renderable in ghost_query.iter_mut() {
+                renderable.visible = false;
+            }
+
+            // Disable energizer blinking in text-only stage
+            for (mut blinking, entity_type) in energizer_query.iter_mut() {
+                if matches!(entity_type, EntityType::PowerPellet) {
+                    blinking.timer = 0.0; // Reset timer to prevent blinking
+                }
+            }
+        }
+        StartupSequence::CharactersVisible { .. } => {
+            // Show player and ghosts, enable energizer blinking
+            if let Ok(mut renderable) = player_query.single_mut() {
+                renderable.visible = true;
+            }
+
+            for mut renderable in ghost_query.iter_mut() {
+                renderable.visible = true;
+            }
+
+            // Energizer blinking is handled by the blinking system
+        }
+        StartupSequence::GameActive => {
+            // All entities are visible and blinking is normal
+            if let Ok(mut renderable) = player_query.single_mut() {
+                renderable.visible = true;
+            }
+
+            for mut renderable in ghost_query.iter_mut() {
+                renderable.visible = true;
+            }
+        }
+    }
+}
+
+/// Renders the HUD (score, lives, etc.) on top of the game.
+pub fn hud_render_system(
+    mut canvas: NonSendMut<&mut Canvas<Window>>,
+    mut atlas: NonSendMut<SpriteAtlas>,
+    score: Res<ScoreResource>,
+    startup: Res<StartupSequence>,
+    mut errors: EventWriter<GameError>,
+) {
+    let mut text_renderer = TextTexture::new(1.0);
+
+    // Render lives and high score text in white
+    let lives = 3; // TODO: Get from actual lives resource
+    let lives_text = format!("{lives}UP   HIGH SCORE   ");
+    let lives_position = glam::UVec2::new(4 + 8 * 3, 2); // x_offset + lives_offset * 8, y_offset
+
+    if let Err(e) = text_renderer.render(&mut canvas, &mut atlas, &lives_text, lives_position) {
+        errors.write(TextureError::RenderFailed(format!("Failed to render lives text: {}", e)).into());
+    }
+
+    // Render score text in yellow (Pac-Man's color)
+    let score_text = format!("{:02}", score.0);
+    let score_offset = 7 - (score_text.len() as i32);
+    let score_position = glam::UVec2::new(4 + 8 * score_offset as u32, 10); // x_offset + score_offset * 8, 8 + y_offset
+
+    if let Err(e) = text_renderer.render(&mut canvas, &mut atlas, &score_text, score_position) {
+        errors.write(TextureError::RenderFailed(format!("Failed to render score text: {}", e)).into());
+    }
+
+    // Render text based on StartupSequence stage
+    if matches!(
+        *startup,
+        StartupSequence::TextOnly { .. } | StartupSequence::CharactersVisible { .. }
+    ) {
+        let ready_text = "READY!";
+        let ready_width = text_renderer.text_width(ready_text);
+        let ready_position = glam::UVec2::new((CANVAS_SIZE.x - ready_width) / 2, 160);
+        if let Err(e) = text_renderer.render_with_color(&mut canvas, &mut atlas, ready_text, ready_position, Color::YELLOW) {
+            errors.write(TextureError::RenderFailed(format!("Failed to render READY text: {}", e)).into());
+        }
+
+        if matches!(*startup, StartupSequence::TextOnly { .. }) {
+            let player_one_text = "PLAYER ONE";
+            let player_one_width = text_renderer.text_width(player_one_text);
+            let player_one_position = glam::UVec2::new((CANVAS_SIZE.x - player_one_width) / 2, 113);
+
+            if let Err(e) =
+                text_renderer.render_with_color(&mut canvas, &mut atlas, player_one_text, player_one_position, Color::CYAN)
+            {
+                errors.write(TextureError::RenderFailed(format!("Failed to render PLAYER ONE text: {}", e)).into());
+            }
+        }
+    }
+}
+
 #[allow(clippy::too_many_arguments)]
 pub fn render_system(
     mut canvas: NonSendMut<&mut Canvas<Window>>,

src/systems/stage.rs

@@ -0,0 +1,97 @@
+use bevy_ecs::{
+    entity::Entity,
+    query::With,
+    resource::Resource,
+    system::{Commands, Query, ResMut},
+};
+
+use crate::systems::{Frozen, GhostCollider, PlayerControlled};
+
+#[derive(Resource, Debug, Clone, Copy)]
+pub enum StartupSequence {
+    /// Stage 1: Text-only stage
+    /// - Player & ghosts are hidden
+    /// - READY! and PLAYER ONE text are shown
+    /// - Energizers do not blink
+    TextOnly {
+        /// Remaining ticks in this stage
+        remaining_ticks: u32,
+    },
+    /// Stage 2: Characters visible stage
+    /// - PLAYER ONE text is hidden, READY! text remains
+    /// - Ghosts and Pac-Man are now shown
+    CharactersVisible {
+        /// Remaining ticks in this stage
+        remaining_ticks: u32,
+    },
+    /// Stage 3: Game begins
+    /// - Final state, game is fully active
+    GameActive,
+}
+
+impl StartupSequence {
+    /// Creates a new StartupSequence with the specified duration in ticks
+    pub fn new(text_only_ticks: u32, _characters_visible_ticks: u32) -> Self {
+        Self::TextOnly {
+            remaining_ticks: text_only_ticks,
+        }
+    }
+
+    /// Ticks the timer by one frame, returning transition information if state changes
+    pub fn tick(&mut self) -> Option<(StartupSequence, StartupSequence)> {
+        match self {
+            StartupSequence::TextOnly { remaining_ticks } => {
+                if *remaining_ticks > 0 {
+                    *remaining_ticks -= 1;
+                    None
+                } else {
+                    let from = *self;
+                    *self = StartupSequence::CharactersVisible {
+                        remaining_ticks: 60, // 1 second at 60 FPS
+                    };
+                    Some((from, *self))
+                }
+            }
+            StartupSequence::CharactersVisible { remaining_ticks } => {
+                if *remaining_ticks > 0 {
+                    *remaining_ticks -= 1;
+                    None
+                } else {
+                    let from = *self;
+                    *self = StartupSequence::GameActive;
+                    Some((from, *self))
+                }
+            }
+            StartupSequence::GameActive => None,
+        }
+    }
+}
+
+/// Handles startup sequence transitions and component management
+pub fn startup_stage_system(
+    mut startup: ResMut<StartupSequence>,
+    mut commands: Commands,
+    mut player_query: Query<Entity, With<PlayerControlled>>,
+    mut ghost_query: Query<Entity, With<GhostCollider>>,
+) {
+    if let Some((from, to)) = startup.tick() {
+        match (from, to) {
+            (StartupSequence::TextOnly { .. }, StartupSequence::CharactersVisible { .. }) => {
+                // TODO: Add TextOnly tag component to hide entities
+                // TODO: Add CharactersVisible tag component to show entities
+                // TODO: Remove TextOnly tag component
+            }
+            (StartupSequence::CharactersVisible { .. }, StartupSequence::GameActive) => {
+                // Remove Frozen tag from all entities and enable player input
+                for entity in player_query.iter_mut().chain(ghost_query.iter_mut()) {
+                    tracing::info!("Removing Frozen component from entity {}", entity);
+                    commands.entity(entity).remove::<Frozen>();
+                }
+
+                // TODO: Add GameActive tag component
+                // TODO: Remove CharactersVisible tag component
+            }
+            _ => {}
+        }
+    }
+}

src/systems/vulnerable.rs

@@ -0,0 +1,20 @@
+use bevy_ecs::query::With;
+use bevy_ecs::system::{Commands, Query};
+
+use crate::systems::{GhostCollider, Vulnerable};
+
+/// System that decrements the remaining_ticks on Vulnerable components and removes them when they reach zero
+pub fn vulnerable_tick_system(
+    mut commands: Commands,
+    mut vulnerable_query: Query<(bevy_ecs::entity::Entity, &mut Vulnerable), With<GhostCollider>>,
+) {
+    for (entity, mut vulnerable) in vulnerable_query.iter_mut() {
+        if vulnerable.remaining_ticks > 0 {
+            vulnerable.remaining_ticks -= 1;
+        }
+
+        if vulnerable.remaining_ticks == 0 {
+            commands.entity(entity).remove::<Vulnerable>();
+        }
+    }
+}

src/texture/text.rs

@@ -10,10 +10,20 @@
 //!
 //! ```rust
 //! use pacman::texture::text::TextTexture;
+//! use sdl2::pixels::Color;
 //!
 //! // Create a text texture with 1.0 scale (8x8 pixels per character)
 //! let mut text_renderer = TextTexture::new(1.0);
 //!
+//! // Set default color for all text
+//! text_renderer.set_color(Color::WHITE);
+//!
+//! // Render text with default color
+//! text_renderer.render(&mut canvas, &mut atlas, "Hello", position)?;
+//!
+//! // Render text with specific color
+//! text_renderer.render_with_color(&mut canvas, &mut atlas, "World", position, Color::YELLOW)?;
+//!
 //! // Set scale for larger text
 //! text_renderer.set_scale(2.0);
 //!
@@ -46,6 +56,7 @@
 use anyhow::Result;
 use glam::UVec2;
 
+use sdl2::pixels::Color;
 use sdl2::render::{Canvas, RenderTarget};
 use std::collections::HashMap;
 
@@ -79,6 +90,7 @@ fn char_to_tile_name(c: char) -> Option<String> {
 pub struct TextTexture {
     char_map: HashMap<char, AtlasTile>,
     scale: f32,
+    default_color: Option<Color>,
 }
 
 impl Default for TextTexture {
@@ -86,6 +98,7 @@ impl Default for TextTexture {
         Self {
             scale: 1.0,
             char_map: Default::default(),
+            default_color: None,
         }
     }
 }
@@ -119,13 +132,26 @@ impl TextTexture {
         }
     }
 
-    /// Renders a string of text at the given position.
+    /// Renders a string of text at the given position using the default color.
     pub fn render<C: RenderTarget>(
         &mut self,
         canvas: &mut Canvas<C>,
         atlas: &mut SpriteAtlas,
         text: &str,
         position: UVec2,
+    ) -> Result<()> {
+        let color = self.default_color.unwrap_or(Color::WHITE);
+        self.render_with_color(canvas, atlas, text, position, color)
+    }
+
+    /// Renders a string of text at the given position with a specific color.
+    pub fn render_with_color<C: RenderTarget>(
+        &mut self,
+        canvas: &mut Canvas<C>,
+        atlas: &mut SpriteAtlas,
+        text: &str,
+        position: UVec2,
+        color: Color,
     ) -> Result<()> {
         let mut x_offset = 0;
         let char_width = (8.0 * self.scale) as u32;
@@ -134,9 +160,9 @@ impl TextTexture {
         for c in text.chars() {
             // Get the tile from the char_map, or insert it if it doesn't exist
             if let Some(tile) = self.get_tile(c, atlas)? {
-                // Render the tile if it exists
+                // Render the tile with the specified color
                 let dest = sdl2::rect::Rect::new((position.x + x_offset) as i32, position.y as i32, char_width, char_height);
-                tile.render(canvas, atlas, dest)?;
+                tile.render_with_color(canvas, atlas, dest, color)?;
             }
 
             // Always advance x_offset for all characters (including spaces)
@@ -146,6 +172,16 @@ impl TextTexture {
         Ok(())
     }
 
+    /// Sets the default color for text rendering.
+    pub fn set_color(&mut self, color: Color) {
+        self.default_color = Some(color);
+    }
+
+    /// Gets the current default color.
+    pub fn color(&self) -> Option<Color> {
+        self.default_color
+    }
+
     /// Sets the scale for text rendering.
     pub fn set_scale(&mut self, scale: f32) {
         self.scale = scale;

tests/collision.rs

@@ -1,13 +1,11 @@
-use bevy_ecs::{event::Events, prelude::*, system::RunSystemOnce, world::World};
+use bevy_ecs::{entity::Entity, event::Events, system::RunSystemOnce, world::World};
 
 use pacman::{
     error::GameError,
     events::GameEvent,
     map::builder::Map,
     systems::{
-        collision::{check_collision, collision_system},
-        components::{Collider, EntityType, Ghost, GhostCollider, ItemCollider, PacmanCollider},
-        movement::Position,
+        check_collision, collision_system, Collider, EntityType, Ghost, GhostCollider, ItemCollider, PacmanCollider, Position,
     },
 };
 

tests/hud.rs

@@ -0,0 +1,26 @@
+use bevy_ecs::{event::Events, world::World};
+
+use pacman::{error::GameError, systems::components::ScoreResource};
+
+fn create_test_world() -> World {
+    let mut world = World::new();
+
+    // Add required resources
+    world.insert_resource(Events::<GameError>::default());
+    world.insert_resource(ScoreResource(1230)); // Test score
+
+    world
+}
+
+#[test]
+fn test_hud_render_system_runs_without_error() {
+    let world = create_test_world();
+
+    // The HUD render system requires SDL2 resources that aren't available in tests,
+    // but we can at least verify it doesn't panic when called
+    // In a real test environment, we'd need to mock the SDL2 canvas and atlas
+
+    // For now, just verify the score resource is accessible
+    let score = world.resource::<ScoreResource>();
+    assert_eq!(score.0, 1230);
+}

tests/item.rs

@@ -1,13 +1,11 @@
-use bevy_ecs::{event::Events, prelude::*, system::RunSystemOnce, world::World};
+use bevy_ecs::{entity::Entity, event::Events, system::RunSystemOnce, world::World};
 
 use pacman::{
     events::GameEvent,
     map::builder::Map,
     systems::{
-        audio::AudioEvent,
-        components::{AudioState, EntityType, ItemCollider, PacmanCollider, ScoreResource},
-        item::{is_valid_item_collision, item_system},
-        movement::Position,
+        is_valid_item_collision, item_system, AudioEvent, AudioState, EntityType, ItemCollider, PacmanCollider, Position,
+        ScoreResource,
     },
 };
 

tests/player.rs

@@ -1,4 +1,4 @@
-use bevy_ecs::{event::Events, prelude::*, system::RunSystemOnce, world::World};
+use bevy_ecs::{entity::Entity, event::Events, system::RunSystemOnce, world::World};
 
 use pacman::{
     events::{GameCommand, GameEvent},
@@ -8,10 +8,8 @@ use pacman::{
         graph::{Edge, TraversalFlags},
     },
     systems::{
-        components::{AudioState, DeltaTime, EntityType, GlobalState, PlayerControlled},
-        debug::DebugState,
-        movement::{BufferedDirection, Position, Velocity},
-        player::{can_traverse, player_control_system, player_movement_system},
+        can_traverse, player_control_system, player_movement_system, AudioState, BufferedDirection, DebugState, DeltaTime,
+        EntityType, GlobalState, PlayerControlled, Position, Velocity,
     },
 };
 
@@ -222,7 +220,7 @@ fn test_player_control_system_toggle_debug() {
 
     // Check that debug state changed
     let debug_state = world.resource::<DebugState>();
-    assert_eq!(debug_state.enabled, true);
+    assert!(debug_state.enabled);
 }
 
 #[test]
@@ -565,7 +563,7 @@ fn test_player_state_persistence_across_systems() {
     let position = *query.single(&world).expect("Player should exist");
 
     // Check that the state changes persisted individually
-    assert_eq!(debug_state_after_toggle.enabled, true, "Debug state should have toggled");
+    assert!(debug_state_after_toggle.enabled, "Debug state should have toggled");
     assert!(audio_muted_after_toggle, "Audio should be muted");
 
     // Player position depends on actual map connectivity

tests/text.rs

@@ -107,3 +107,23 @@ fn test_text_scale() -> Result<(), String> {
 
     Ok(())
 }
+
+#[test]
+fn test_text_color() -> Result<(), String> {
+    let mut text_texture = TextTexture::new(1.0);
+
+    // Test default color (should be None initially)
+    assert_eq!(text_texture.color(), None);
+
+    // Test setting color
+    let test_color = sdl2::pixels::Color::YELLOW;
+    text_texture.set_color(test_color);
+    assert_eq!(text_texture.color(), Some(test_color));
+
+    // Test changing color
+    let new_color = sdl2::pixels::Color::RED;
+    text_texture.set_color(new_color);
+    assert_eq!(text_texture.color(), Some(new_color));
+
+    Ok(())
+}