fix: correct broken timing format tests

Cargo.lock

@@ -598,11 +598,9 @@ dependencies = [
  "bitflags 2.9.1",
  "circular-buffer",
  "glam 0.30.5",
- "lazy_static",
  "libc",
  "micromap",
  "num-width",
- "once_cell",
  "parking_lot",
  "pathfinding",
  "phf",

Cargo.toml

@@ -9,16 +9,13 @@ edition = "2021"
 tracing = { version = "0.1.41", features = ["max_level_debug", "release_max_level_debug"]}
 tracing-error = "0.2.0"
 tracing-subscriber = {version = "0.3.17", features = ["env-filter"]}
-lazy_static = "1.5.0"
 sdl2 = { version = "0.38.0", features = ["image", "ttf"] }
 spin_sleep = "1.3.2"
 rand = { version = "0.9.2", default-features = false, features = ["small_rng", "os_rng"] }
 pathfinding = "4.14"
-once_cell = "1.21.3"
 thiserror = "2.0.14"
 anyhow = "1.0"
 glam = "0.30.5"
-serde = { version = "1.0.219", features = ["derive"] }
 serde_json = "1.0.142"
 smallvec = "1.15.1"
 strum = "0.27.2"
@@ -71,3 +68,6 @@ libc = "0.2.175"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 phf = { version = "0.12.1", features = ["macros"] }
+
+[package.metadata.cargo-machete]
+ignored = ["phf"]

build.rs

@@ -19,6 +19,15 @@ struct MapperFrame {
     height: u16,
 }
 
+impl MapperFrame {
+    fn to_u16vec2_format(self) -> String {
+        format!(
+            "MapperFrame {{ pos: glam::U16Vec2::new({}, {}), size: glam::U16Vec2::new({}, {}) }}",
+            self.x, self.y, self.width, self.height
+        )
+    }
+}
+
 fn main() {
     let path = Path::new(&env::var("OUT_DIR").unwrap()).join("atlas_data.rs");
     let mut file = BufWriter::new(File::create(&path).unwrap());
@@ -37,12 +46,7 @@ fn main() {
     .unwrap();
 
     for (name, frame) in atlas_mapper.frames {
-        writeln!(
-            &mut file,
-            "    \"{}\" => MapperFrame {{ x: {}, y: {}, width: {}, height: {} }},",
-            name, frame.x, frame.y, frame.width, frame.height
-        )
-        .unwrap();
+        writeln!(&mut file, "    \"{}\" => {},", name, frame.to_u16vec2_format()).unwrap();
     }
 
     writeln!(&mut file, "}};").unwrap();

src/constants.rs

@@ -30,6 +30,21 @@ pub const BOARD_CELL_OFFSET: UVec2 = UVec2::new(0, 3);
 /// Automatically calculated from the cell offset to maintain consistency
 /// when the cell size changes. Used for positioning sprites and debug overlays.
 pub const BOARD_PIXEL_OFFSET: UVec2 = UVec2::new(BOARD_CELL_OFFSET.x * CELL_SIZE, BOARD_CELL_OFFSET.y * CELL_SIZE);
+
+/// Animation timing constants for ghost state management
+pub mod animation {
+    /// Normal ghost movement animation speed (frames per second)
+    pub const GHOST_NORMAL_SPEED: f32 = 0.2;
+    /// Eaten ghost (eyes) animation speed (frames per second)
+    pub const GHOST_EATEN_SPEED: f32 = 0.1;
+    /// Frightened ghost animation speed (frames per second)
+    pub const GHOST_FRIGHTENED_SPEED: f32 = 0.2;
+    /// Frightened ghost flashing animation speed (frames per second)
+    pub const GHOST_FLASHING_SPEED: f32 = 0.15;
+
+    /// Time in ticks when frightened ghosts start flashing (2 seconds at 60 FPS)
+    pub const FRIGHTENED_FLASH_START_TICKS: u32 = 120;
+}
 /// The size of the canvas, in pixels.
 pub const CANVAS_SIZE: UVec2 = UVec2::new(
     (BOARD_CELL_SIZE.x + BOARD_CELL_OFFSET.x) * CELL_SIZE,

src/game.rs

@@ -2,36 +2,38 @@
 
 include!(concat!(env!("OUT_DIR"), "/atlas_data.rs"));
 
-use crate::constants::CANVAS_SIZE;
+use crate::constants::{animation, MapTile, CANVAS_SIZE};
 use crate::error::{GameError, GameResult, TextureError};
 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::profiling::SystemId;
 use crate::systems::render::RenderDirty;
+use crate::systems::{self, ghost_collision_system, present_system, Hidden, MovementModifiers, NodeId};
 use crate::systems::{
     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,
+    eaten_ghost_system, ghost_movement_system, ghost_state_animation_system, hud_render_system, item_system, profile,
+    render_system, AudioEvent, AudioResource, AudioState, BackbufferResource, Collider, DebugFontResource, DebugState,
+    DebugTextureResource, DeltaTime, DirectionalAnimated, EntityType, Frozen, Ghost, GhostAnimationSet, GhostAnimations,
+    GhostBundle, GhostCollider, GlobalState, ItemBundle, ItemCollider, MapTextureResource, PacmanCollider, PlayerBundle,
+    PlayerControlled, Renderable, ScoreResource, StartupSequence, SystemTimings,
 };
 use crate::texture::animated::AnimatedTexture;
+use crate::texture::sprite::AtlasTile;
 use bevy_ecs::event::EventRegistry;
 use bevy_ecs::observer::Trigger;
-use bevy_ecs::schedule::{IntoScheduleConfigs, Schedule, SystemSet};
-use bevy_ecs::system::{NonSendMut, Res, ResMut};
+use bevy_ecs::schedule::common_conditions::resource_changed;
+use bevy_ecs::schedule::{Condition, IntoScheduleConfigs, Schedule, SystemSet};
+use bevy_ecs::system::ResMut;
 use bevy_ecs::world::World;
 use sdl2::image::LoadTexture;
-use sdl2::render::{Canvas, ScaleMode, TextureCreator};
+use sdl2::render::{BlendMode, Canvas, ScaleMode, TextureCreator};
 use sdl2::rwops::RWops;
 use sdl2::video::{Window, WindowContext};
 use sdl2::EventPump;
+use smallvec::smallvec;
 
 use crate::{
     asset::{get_asset_bytes, Asset},
@@ -82,14 +84,7 @@ impl Game {
         texture_creator: &'static mut TextureCreator<WindowContext>,
         event_pump: &'static mut EventPump,
     ) -> GameResult<Game> {
-        let mut world = World::default();
-        let mut schedule = Schedule::default();
         let ttf_context = Box::leak(Box::new(sdl2::ttf::init().map_err(|e| GameError::Sdl(e.to_string()))?));
-
-        EventRegistry::register_event::<GameError>(&mut world);
-        EventRegistry::register_event::<GameEvent>(&mut world);
-        EventRegistry::register_event::<AudioEvent>(&mut world);
-
         let mut backbuffer = texture_creator
             .create_texture_target(None, CANVAS_SIZE.x, CANVAS_SIZE.y)
             .map_err(|e| GameError::Sdl(e.to_string()))?;
@@ -105,6 +100,9 @@ impl Game {
         let mut debug_texture = texture_creator
             .create_texture_target(None, output_size.0, output_size.1)
             .map_err(|e| GameError::Sdl(e.to_string()))?;
+
+        // Debug texture is copied over the backbuffer, it requires transparency abilities
+        debug_texture.set_blend_mode(BlendMode::Blend);
         debug_texture.set_scale_mode(ScaleMode::Nearest);
 
         let font_data = get_asset_bytes(Asset::Font)?;
@@ -150,11 +148,10 @@ impl Game {
             .map_err(|e| GameError::Sdl(e.to_string()))?;
 
         let map = Map::new(constants::RAW_BOARD)?;
-        let pacman_start_node = map.start_positions.pacman;
 
+        // Create directional animated textures for Pac-Man
         let mut textures = [None, None, None, None];
         let mut stopped_textures = [None, None, None, None];
-
         for direction in Direction::DIRECTIONS {
             let moving_prefix = match direction {
                 Direction::Up => "pacman/up",
@@ -162,7 +159,7 @@ impl Game {
                 Direction::Left => "pacman/left",
                 Direction::Right => "pacman/right",
             };
-            let moving_tiles = vec![
+            let moving_tiles = smallvec![
                 SpriteAtlas::get_tile(&atlas, &format!("{moving_prefix}_a.png"))
                     .ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound(format!("{moving_prefix}_a.png"))))?,
                 SpriteAtlas::get_tile(&atlas, &format!("{moving_prefix}_b.png"))
@@ -171,7 +168,7 @@ impl Game {
                     .ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/full.png".to_string())))?,
             ];
 
-            let stopped_tiles = vec![SpriteAtlas::get_tile(&atlas, &format!("{moving_prefix}_b.png"))
+            let stopped_tiles = smallvec![SpriteAtlas::get_tile(&atlas, &format!("{moving_prefix}_b.png"))
                 .ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound(format!("{moving_prefix}_b.png"))))?];
 
             textures[direction.as_usize()] = Some(AnimatedTexture::new(moving_tiles, 0.08)?);
@@ -180,17 +177,19 @@ impl Game {
 
         let player = PlayerBundle {
             player: PlayerControlled,
-            position: Position::Stopped { node: pacman_start_node },
+            position: Position::Stopped {
+                node: map.start_positions.pacman,
+            },
             velocity: Velocity {
                 speed: 1.15,
                 direction: Direction::Left,
             },
+            movement_modifiers: MovementModifiers::default(),
             buffered_direction: BufferedDirection::None,
             sprite: Renderable {
                 sprite: SpriteAtlas::get_tile(&atlas, "pacman/full.png")
                     .ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/full.png".to_string())))?,
                 layer: 0,
-                visible: true,
             },
             directional_animated: DirectionalAnimated {
                 textures,
@@ -203,20 +202,14 @@ 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);
+        let mut world = World::default();
+        let mut schedule = Schedule::default();
 
-        world.insert_non_send_resource(atlas);
-        world.insert_non_send_resource(event_pump);
-        world.insert_non_send_resource(canvas);
-        world.insert_non_send_resource(BackbufferResource(backbuffer));
-        world.insert_non_send_resource(MapTextureResource(map_texture));
-        world.insert_non_send_resource(DebugTextureResource(debug_texture));
-        world.insert_non_send_resource(DebugFontResource(debug_font));
-        world.insert_non_send_resource(AudioResource(audio));
+        EventRegistry::register_event::<GameError>(&mut world);
+        EventRegistry::register_event::<GameEvent>(&mut world);
+        EventRegistry::register_event::<AudioEvent>(&mut world);
 
+        world.insert_resource(Self::create_ghost_animations(&atlas)?);
         world.insert_resource(map);
         world.insert_resource(GlobalState { exit: false });
         world.insert_resource(ScoreResource(0));
@@ -227,7 +220,16 @@ 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.insert_resource(StartupSequence::new(60 * 3, 60));
+
+        world.insert_non_send_resource(atlas);
+        world.insert_non_send_resource(event_pump);
+        world.insert_non_send_resource(canvas);
+        world.insert_non_send_resource(BackbufferResource(backbuffer));
+        world.insert_non_send_resource(MapTextureResource(map_texture));
+        world.insert_non_send_resource(DebugTextureResource(debug_texture));
+        world.insert_non_send_resource(DebugFontResource(debug_font));
+        world.insert_non_send_resource(AudioResource(audio));
 
         world.add_observer(
             |event: Trigger<GameEvent>, mut state: ResMut<GlobalState>, _score: ResMut<ScoreResource>| {
@@ -251,25 +253,18 @@ impl Game {
         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 hud_render_system = profile(SystemId::HudRender, hud_render_system);
         let debug_render_system = profile(SystemId::DebugRender, debug_render_system);
+        let present_system = profile(SystemId::Present, present_system);
+        let ghost_state_animation_system = profile(SystemId::GhostStateAnimation, ghost_state_animation_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;
-                }
-            },
-        );
+        let forced_dirty_system = |mut dirty: ResMut<RenderDirty>| {
+            dirty.0 = true;
+        };
 
         schedule.add_systems((
+            forced_dirty_system.run_if(resource_changed::<ScoreResource>.or(resource_changed::<StartupSequence>)),
             (
                 input_system,
                 player_control_system,
@@ -279,11 +274,12 @@ impl Game {
                 .chain(),
             player_tunnel_slowdown_system,
             ghost_movement_system,
+            profile(SystemId::EatenGhost, eaten_ghost_system),
             vulnerable_tick_system,
+            ghost_state_animation_system,
             (collision_system, ghost_collision_system, item_system).chain(),
             audio_system,
             blinking_system,
-            ready_visibility_system,
             (
                 directional_render_system,
                 dirty_render_system,
@@ -295,53 +291,46 @@ impl Game {
                 .chain(),
         ));
 
-        // 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 player and attach initial state bundle
+        world.spawn(player).insert((Frozen, Hidden));
 
         // Spawn ghosts
         Self::spawn_ghosts(&mut world)?;
 
-        // Spawn items
         let pellet_sprite = SpriteAtlas::get_tile(world.non_send_resource::<SpriteAtlas>(), "maze/pellet.png")
             .ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("maze/pellet.png".to_string())))?;
         let energizer_sprite = SpriteAtlas::get_tile(world.non_send_resource::<SpriteAtlas>(), "maze/energizer.png")
             .ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("maze/energizer.png".to_string())))?;
 
-        let nodes: Vec<_> = world.resource::<Map>().iter_nodes().map(|(id, tile)| (*id, *tile)).collect();
-
-        for (node_id, tile) in nodes {
-            let (item_type, sprite, size) = match tile {
-                crate::constants::MapTile::Pellet => (EntityType::Pellet, pellet_sprite, constants::CELL_SIZE as f32 * 0.4),
-                crate::constants::MapTile::PowerPellet => {
-                    (EntityType::PowerPellet, energizer_sprite, constants::CELL_SIZE as f32 * 0.95)
-                }
-                _ => continue,
-            };
+        // Build a list of item entities to spawn from the map
+        let nodes: Vec<(NodeId, EntityType, AtlasTile, f32)> = world
+            .resource::<Map>()
+            .iter_nodes()
+            .filter_map(|(id, tile)| match tile {
+                MapTile::Pellet => Some((*id, EntityType::Pellet, pellet_sprite, constants::CELL_SIZE as f32 * 0.4)),
+                MapTile::PowerPellet => Some((
+                    *id,
+                    EntityType::PowerPellet,
+                    energizer_sprite,
+                    constants::CELL_SIZE as f32 * 0.95,
+                )),
+                _ => None,
+            })
+            .collect();
 
+        // Construct and spawn the item entities
+        for (id, item_type, sprite, size) in nodes {
             let mut item = world.spawn(ItemBundle {
-                position: Position::Stopped { node: node_id },
-                sprite: Renderable {
-                    sprite,
-                    layer: 1,
-                    visible: true,
-                },
+                position: Position::Stopped { node: id },
+                sprite: Renderable { sprite, layer: 1 },
                 entity_type: item_type,
                 collider: Collider { size },
                 item_collider: ItemCollider,
             });
 
+            // Make power pellets blink
             if item_type == EntityType::PowerPellet {
-                item.insert(Blinking {
-                    timer: 0.0,
-                    interval: 0.2,
-                });
+                item.insert((Frozen, Blinking::new(0.2)));
             }
         }
 
@@ -369,58 +358,9 @@ impl Game {
         for (ghost_type, start_node) in ghost_start_positions {
             // Create the ghost bundle in a separate scope to manage borrows
             let ghost = {
+                let animations = world.resource::<GhostAnimations>().0.get(&ghost_type).unwrap().clone();
                 let atlas = world.non_send_resource::<SpriteAtlas>();
 
-                // Create directional animated textures for the ghost
-                let mut textures = [None, None, None, None];
-                let mut stopped_textures = [None, None, None, None];
-
-                for direction in Direction::DIRECTIONS {
-                    let moving_prefix = match direction {
-                        Direction::Up => "up",
-                        Direction::Down => "down",
-                        Direction::Left => "left",
-                        Direction::Right => "right",
-                    };
-
-                    let moving_tiles = vec![
-                        SpriteAtlas::get_tile(atlas, &format!("ghost/{}/{}_{}.png", ghost_type.as_str(), moving_prefix, "a"))
-                            .ok_or_else(|| {
-                                GameError::Texture(TextureError::AtlasTileNotFound(format!(
-                                    "ghost/{}/{}_{}.png",
-                                    ghost_type.as_str(),
-                                    moving_prefix,
-                                    "a"
-                                )))
-                            })?,
-                        SpriteAtlas::get_tile(atlas, &format!("ghost/{}/{}_{}.png", ghost_type.as_str(), moving_prefix, "b"))
-                            .ok_or_else(|| {
-                                GameError::Texture(TextureError::AtlasTileNotFound(format!(
-                                    "ghost/{}/{}_{}.png",
-                                    ghost_type.as_str(),
-                                    moving_prefix,
-                                    "b"
-                                )))
-                            })?,
-                    ];
-
-                    let stopped_tiles = vec![SpriteAtlas::get_tile(
-                        atlas,
-                        &format!("ghost/{}/{}_{}.png", ghost_type.as_str(), moving_prefix, "a"),
-                    )
-                    .ok_or_else(|| {
-                        GameError::Texture(TextureError::AtlasTileNotFound(format!(
-                            "ghost/{}/{}_{}.png",
-                            ghost_type.as_str(),
-                            moving_prefix,
-                            "a"
-                        )))
-                    })?];
-
-                    textures[direction.as_usize()] = Some(AnimatedTexture::new(moving_tiles, 0.2)?);
-                    stopped_textures[direction.as_usize()] = Some(AnimatedTexture::new(stopped_tiles, 0.1)?);
-                }
-
                 GhostBundle {
                     ghost: ghost_type,
                     position: Position::Stopped { node: start_node },
@@ -438,12 +378,8 @@ impl Game {
                             },
                         )?,
                         layer: 0,
-                        visible: true,
-                    },
-                    directional_animated: DirectionalAnimated {
-                        textures,
-                        stopped_textures,
                     },
+                    directional_animated: animations.normal().unwrap().clone(),
                     entity_type: EntityType::Ghost,
                     collider: Collider {
                         size: crate::constants::CELL_SIZE as f32 * 1.375,
@@ -452,12 +388,112 @@ impl Game {
                 }
             };
 
-            world.spawn(ghost).insert(Frozen);
+            world.spawn(ghost).insert((Frozen, Hidden));
         }
 
         Ok(())
     }
 
+    fn create_ghost_animations(atlas: &SpriteAtlas) -> GameResult<GhostAnimations> {
+        let mut animations = std::collections::HashMap::new();
+
+        for ghost_type in [Ghost::Blinky, Ghost::Pinky, Ghost::Inky, Ghost::Clyde] {
+            // Normal animations
+            let mut normal_textures = [None, None, None, None];
+            for direction in Direction::DIRECTIONS {
+                let dir_str = direction.as_ref();
+                let tile_a = atlas
+                    .get_tile(&format!("ghost/{}/{}_a.png", ghost_type.as_str(), dir_str))
+                    .ok_or_else(|| {
+                        GameError::Texture(TextureError::AtlasTileNotFound(format!(
+                            "ghost/{}/{}_a.png",
+                            ghost_type.as_str(),
+                            dir_str
+                        )))
+                    })?;
+                let tile_b = atlas
+                    .get_tile(&format!("ghost/{}/{}_b.png", ghost_type.as_str(), dir_str))
+                    .ok_or_else(|| {
+                        GameError::Texture(TextureError::AtlasTileNotFound(format!(
+                            "ghost/{}/{}_b.png",
+                            ghost_type.as_str(),
+                            dir_str
+                        )))
+                    })?;
+                let tiles = smallvec![tile_a, tile_b];
+                normal_textures[direction.as_usize()] = Some(AnimatedTexture::new(tiles, animation::GHOST_NORMAL_SPEED)?);
+            }
+            let normal = DirectionalAnimated {
+                textures: normal_textures.clone(),
+                stopped_textures: normal_textures,
+            };
+
+            // Eaten (eyes) animations
+            let mut eaten_textures = [None, None, None, None];
+            for direction in Direction::DIRECTIONS {
+                let dir_str = direction.as_ref();
+                let tile = atlas
+                    .get_tile(&format!("ghost/eyes/{}.png", dir_str))
+                    .ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound(format!("ghost/eyes/{}.png", dir_str))))?;
+                eaten_textures[direction.as_usize()] = Some(AnimatedTexture::new(smallvec![tile], animation::GHOST_EATEN_SPEED)?);
+            }
+            let eaten = DirectionalAnimated {
+                textures: eaten_textures.clone(),
+                stopped_textures: eaten_textures,
+            };
+
+            animations.insert(
+                ghost_type,
+                GhostAnimationSet::new(
+                    normal,
+                    DirectionalAnimated::default(), // Placeholder for frightened
+                    DirectionalAnimated::default(), // Placeholder for frightened_flashing
+                    eaten,
+                ),
+            );
+        }
+
+        // Frightened animations (same for all ghosts)
+        let frightened_blue_a = atlas
+            .get_tile("ghost/frightened/blue_a.png")
+            .ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("ghost/frightened/blue_a.png".to_string())))?;
+        let frightened_blue_b = atlas
+            .get_tile("ghost/frightened/blue_b.png")
+            .ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("ghost/frightened/blue_b.png".to_string())))?;
+        let frightened_white_a = atlas
+            .get_tile("ghost/frightened/white_a.png")
+            .ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("ghost/frightened/white_a.png".to_string())))?;
+        let frightened_white_b = atlas
+            .get_tile("ghost/frightened/white_b.png")
+            .ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("ghost/frightened/white_b.png".to_string())))?;
+
+        let frightened_anim = AnimatedTexture::new(
+            smallvec![frightened_blue_a, frightened_blue_b],
+            animation::GHOST_FRIGHTENED_SPEED,
+        )?;
+        let flashing_anim = AnimatedTexture::new(
+            smallvec![frightened_blue_a, frightened_white_a, frightened_blue_b, frightened_white_b],
+            animation::GHOST_FLASHING_SPEED,
+        )?;
+
+        let frightened_da = DirectionalAnimated::from_animation(frightened_anim);
+        let frightened_flashing_da = DirectionalAnimated::from_animation(flashing_anim);
+
+        for ghost_type in [Ghost::Blinky, Ghost::Pinky, Ghost::Inky, Ghost::Clyde] {
+            let entry = animations.get_mut(&ghost_type).unwrap();
+            entry.animations.insert(
+                crate::systems::GhostAnimation::Frightened { flash: false },
+                frightened_da.clone(),
+            );
+            entry.animations.insert(
+                crate::systems::GhostAnimation::Frightened { flash: true },
+                frightened_flashing_da.clone(),
+            );
+        }
+
+        Ok(GhostAnimations(animations))
+    }
+
     /// Executes one frame of game logic by running all scheduled ECS systems.
     ///
     /// Updates the world's delta time resource and runs the complete system pipeline:

src/map/builder.rs

@@ -5,7 +5,7 @@ use crate::map::graph::{Graph, Node, TraversalFlags};
 use crate::map::parser::MapTileParser;
 use crate::systems::movement::NodeId;
 use bevy_ecs::resource::Resource;
-use glam::{IVec2, Vec2};
+use glam::{I8Vec2, IVec2, Vec2};
 use std::collections::{HashMap, VecDeque};
 use tracing::debug;
 
@@ -38,7 +38,7 @@ pub struct Map {
     /// Connected graph of navigable positions.
     pub graph: Graph,
     /// Bidirectional mapping between 2D grid coordinates and graph node indices.
-    pub grid_to_node: HashMap<IVec2, NodeId>,
+    pub grid_to_node: HashMap<I8Vec2, NodeId>,
     /// Predetermined spawn locations for all game entities
     pub start_positions: NodePositions,
     /// 2D array of tile types for collision detection and rendering
@@ -76,8 +76,8 @@ impl Map {
         let mut queue = VecDeque::new();
         queue.push_back(start_pos);
         let pos = Vec2::new(
-            (start_pos.x * CELL_SIZE as i32) as f32,
-            (start_pos.y * CELL_SIZE as i32) as f32,
+            (start_pos.x as i32 * CELL_SIZE as i32) as f32,
+            (start_pos.y as i32 * CELL_SIZE as i32) as f32,
         ) + cell_offset;
         let node_id = graph.add_node(Node { position: pos });
         grid_to_node.insert(start_pos, node_id);
@@ -89,9 +89,9 @@ impl Map {
 
                 // Skip if the new position is out of bounds
                 if new_position.x < 0
-                    || new_position.x >= BOARD_CELL_SIZE.x as i32
+                    || new_position.x as i32 >= BOARD_CELL_SIZE.x as i32
                     || new_position.y < 0
-                    || new_position.y >= BOARD_CELL_SIZE.y as i32
+                    || new_position.y as i32 >= BOARD_CELL_SIZE.y as i32
                 {
                     continue;
                 }
@@ -108,8 +108,8 @@ impl Map {
                 ) {
                     // Add the new position to the graph/queue
                     let pos = Vec2::new(
-                        (new_position.x * CELL_SIZE as i32) as f32,
-                        (new_position.y * CELL_SIZE as i32) as f32,
+                        (new_position.x as i32 * CELL_SIZE as i32) as f32,
+                        (new_position.y as i32 * CELL_SIZE as i32) as f32,
                     ) + cell_offset;
                     let new_node_id = graph.add_node(Node { position: pos });
                     grid_to_node.insert(new_position, new_node_id);
@@ -132,7 +132,7 @@ impl Map {
         for (grid_pos, &node_id) in &grid_to_node {
             for dir in Direction::DIRECTIONS {
                 // If the node doesn't have an edge in this direction, look for a neighbor in that direction
-                if graph.adjacency_list[node_id].get(dir).is_none() {
+                if graph.adjacency_list[node_id as usize].get(dir).is_none() {
                     let neighbor = grid_pos + dir.as_ivec2();
                     // If the neighbor exists, connect the node to it
                     if let Some(&neighbor_id) = grid_to_node.get(&neighbor) {
@@ -199,9 +199,9 @@ impl Map {
     /// representing the four key positions within the ghost house structure.
     fn build_house(
         graph: &mut Graph,
-        grid_to_node: &HashMap<IVec2, NodeId>,
-        house_door: &[Option<IVec2>; 2],
-    ) -> GameResult<(usize, usize, usize, usize)> {
+        grid_to_node: &HashMap<I8Vec2, NodeId>,
+        house_door: &[Option<I8Vec2>; 2],
+    ) -> GameResult<(NodeId, NodeId, NodeId, NodeId)> {
         // Calculate the position of the house entrance node
         let (house_entrance_node_id, house_entrance_node_position) = {
             // Translate the grid positions to the actual node ids
@@ -222,10 +222,13 @@ impl Map {
 
             // Calculate the position of the house node
             let (node_id, node_position) = {
-                let left_pos = graph.get_node(*left_node).ok_or(MapError::NodeNotFound(*left_node))?.position;
+                let left_pos = graph
+                    .get_node(*left_node)
+                    .ok_or(MapError::NodeNotFound(*left_node as usize))?
+                    .position;
                 let right_pos = graph
                     .get_node(*right_node)
-                    .ok_or(MapError::NodeNotFound(*right_node))?
+                    .ok_or(MapError::NodeNotFound(*right_node as usize))?
                     .position;
                 let house_node = graph.add_node(Node {
                     position: left_pos.lerp(right_pos, 0.5),
@@ -249,10 +252,10 @@ impl Map {
             // Place the nodes at, above, and below the center position
             let center_node_id = graph.add_node(Node { position: center_pos });
             let top_node_id = graph.add_node(Node {
-                position: center_pos + (Direction::Up.as_ivec2() * (CELL_SIZE as i32 / 2)).as_vec2(),
+                position: center_pos + IVec2::from(Direction::Up.as_ivec2()).as_vec2() * (CELL_SIZE as f32 / 2.0),
             });
             let bottom_node_id = graph.add_node(Node {
-                position: center_pos + (Direction::Down.as_ivec2() * (CELL_SIZE as i32 / 2)).as_vec2(),
+                position: center_pos + IVec2::from(Direction::Down.as_ivec2()).as_vec2() * (CELL_SIZE as f32 / 2.0),
             });
 
             // Connect the center node to the top and bottom nodes
@@ -268,7 +271,7 @@ impl Map {
 
         // Calculate the position of the center line's center node
         let center_line_center_position =
-            house_entrance_node_position + (Direction::Down.as_ivec2() * (3 * CELL_SIZE as i32)).as_vec2();
+            house_entrance_node_position + IVec2::from(Direction::Down.as_ivec2()).as_vec2() * (3.0 * CELL_SIZE as f32);
 
         // Create the center line
         let (center_center_node_id, center_top_node_id) = create_house_line(graph, center_line_center_position)?;
@@ -300,13 +303,13 @@ impl Map {
         // Create the left line
         let (left_center_node_id, _) = create_house_line(
             graph,
-            center_line_center_position + (Direction::Left.as_ivec2() * (CELL_SIZE as i32 * 2)).as_vec2(),
+            center_line_center_position + IVec2::from(Direction::Left.as_ivec2()).as_vec2() * (CELL_SIZE as f32 * 2.0),
         )?;
 
         // Create the right line
         let (right_center_node_id, _) = create_house_line(
             graph,
-            center_line_center_position + (Direction::Right.as_ivec2() * (CELL_SIZE as i32 * 2)).as_vec2(),
+            center_line_center_position + IVec2::from(Direction::Right.as_ivec2()).as_vec2() * (CELL_SIZE as f32 * 2.0),
         )?;
 
         debug!("Left center node id: {left_center_node_id}");
@@ -336,8 +339,8 @@ impl Map {
     /// Creates hidden intermediate nodes beyond the visible tunnel entrances and connects them with zero-distance edges for instantaneous traversal.
     fn build_tunnels(
         graph: &mut Graph,
-        grid_to_node: &HashMap<IVec2, NodeId>,
-        tunnel_ends: &[Option<IVec2>; 2],
+        grid_to_node: &HashMap<I8Vec2, NodeId>,
+        tunnel_ends: &[Option<I8Vec2>; 2],
     ) -> GameResult<()> {
         // Create the hidden tunnel nodes
         let left_tunnel_hidden_node_id = {
@@ -353,7 +356,7 @@ impl Map {
                     Direction::Left,
                     Node {
                         position: left_tunnel_entrance_node.position
-                            + (Direction::Left.as_ivec2() * (CELL_SIZE as i32 * 2)).as_vec2(),
+                            + IVec2::from(Direction::Left.as_ivec2()).as_vec2() * (CELL_SIZE as f32 * 2.0),
                     },
                 )
                 .map_err(|e| {
@@ -378,7 +381,7 @@ impl Map {
                     Direction::Right,
                     Node {
                         position: right_tunnel_entrance_node.position
-                            + (Direction::Right.as_ivec2() * (CELL_SIZE as i32 * 2)).as_vec2(),
+                            + IVec2::from(Direction::Right.as_ivec2()).as_vec2() * (CELL_SIZE as f32 * 2.0),
                     },
                 )
                 .map_err(|e| {

src/map/direction.rs

@@ -1,8 +1,10 @@
-use glam::IVec2;
+use glam::I8Vec2;
+use strum_macros::AsRefStr;
 
 /// The four cardinal directions.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default, AsRefStr)]
 #[repr(usize)]
+#[strum(serialize_all = "lowercase")]
 pub enum Direction {
     Up,
     Down,
@@ -26,8 +28,8 @@ impl Direction {
         }
     }
 
-    /// Returns the direction as an IVec2.
-    pub fn as_ivec2(self) -> IVec2 {
+    /// Returns the direction as an I8Vec2.
+    pub fn as_ivec2(self) -> I8Vec2 {
         self.into()
     }
 
@@ -43,13 +45,13 @@ impl Direction {
     }
 }
 
-impl From<Direction> for IVec2 {
+impl From<Direction> for I8Vec2 {
     fn from(dir: Direction) -> Self {
         match dir {
-            Direction::Up => -IVec2::Y,
-            Direction::Down => IVec2::Y,
-            Direction::Left => -IVec2::X,
-            Direction::Right => IVec2::X,
+            Direction::Up => -I8Vec2::Y,
+            Direction::Down => I8Vec2::Y,
+            Direction::Left => -I8Vec2::X,
+            Direction::Right => I8Vec2::X,
         }
     }
 }

src/map/graph.rs

@@ -107,7 +107,7 @@ impl Graph {
 
     /// Adds a new node with the given data to the graph and returns its ID.
     pub fn add_node(&mut self, data: Node) -> NodeId {
-        let id = self.nodes.len();
+        let id = self.nodes.len() as NodeId;
         self.nodes.push(data);
         self.adjacency_list.push(Intersection::default());
         id
@@ -129,10 +129,10 @@ impl Graph {
         distance: Option<f32>,
         direction: Direction,
     ) -> Result<(), &'static str> {
-        if from >= self.adjacency_list.len() {
+        if from as usize >= self.adjacency_list.len() {
             return Err("From node does not exist.");
         }
-        if to >= self.adjacency_list.len() {
+        if to as usize >= self.adjacency_list.len() {
             return Err("To node does not exist.");
         }
 
@@ -178,8 +178,8 @@ impl Graph {
                 }
                 None => {
                     // If no distance is provided, calculate it based on the positions of the nodes
-                    let from_pos = self.nodes[from].position;
-                    let to_pos = self.nodes[to].position;
+                    let from_pos = self.nodes[from as usize].position;
+                    let to_pos = self.nodes[to as usize].position;
                     from_pos.distance(to_pos)
                 }
             },
@@ -187,11 +187,11 @@ impl Graph {
             traversal_flags,
         };
 
-        if from >= self.adjacency_list.len() {
+        if from as usize >= self.adjacency_list.len() {
             return Err("From node does not exist.");
         }
 
-        let adjacency_list = &mut self.adjacency_list[from];
+        let adjacency_list = &mut self.adjacency_list[from as usize];
 
         // Check if the edge already exists in this direction or to the same target
         if let Some(err) = adjacency_list.edges().find_map(|e| {
@@ -215,7 +215,7 @@ impl Graph {
 
     /// Retrieves an immutable reference to a node's data.
     pub fn get_node(&self, id: NodeId) -> Option<&Node> {
-        self.nodes.get(id)
+        self.nodes.get(id as usize)
     }
 
     /// Returns an iterator over all nodes in the graph.
@@ -228,17 +228,17 @@ impl Graph {
         self.adjacency_list
             .iter()
             .enumerate()
-            .flat_map(|(node_id, intersection)| intersection.edges().map(move |edge| (node_id, edge)))
+            .flat_map(|(node_id, intersection)| intersection.edges().map(move |edge| (node_id as NodeId, edge)))
     }
 
     /// Finds a specific edge from a source node to a target node.
     pub fn find_edge(&self, from: NodeId, to: NodeId) -> Option<Edge> {
-        self.adjacency_list.get(from)?.edges().find(|edge| edge.target == to)
+        self.adjacency_list.get(from as usize)?.edges().find(|edge| edge.target == to)
     }
 
     /// Finds an edge originating from a given node that follows a specific direction.
     pub fn find_edge_in_direction(&self, from: NodeId, direction: Direction) -> Option<Edge> {
-        self.adjacency_list.get(from)?.get(direction)
+        self.adjacency_list.get(from as usize)?.get(direction)
     }
 }
 

src/map/parser.rs

@@ -2,7 +2,7 @@
 
 use crate::constants::{MapTile, BOARD_CELL_SIZE};
 use crate::error::ParseError;
-use glam::IVec2;
+use glam::I8Vec2;
 
 /// Structured representation of parsed ASCII board layout with extracted special positions.
 ///
@@ -15,11 +15,11 @@ pub struct ParsedMap {
     /// 2D array of tiles converted from ASCII characters
     pub tiles: [[MapTile; BOARD_CELL_SIZE.y as usize]; BOARD_CELL_SIZE.x as usize],
     /// Two positions marking the ghost house entrance (represented by '=' characters)
-    pub house_door: [Option<IVec2>; 2],
+    pub house_door: [Option<I8Vec2>; 2],
     /// Two positions marking tunnel portals for wraparound teleportation ('T' characters)
-    pub tunnel_ends: [Option<IVec2>; 2],
+    pub tunnel_ends: [Option<I8Vec2>; 2],
     /// Starting position for Pac-Man (marked by 'X' character in the layout)
-    pub pacman_start: Option<IVec2>,
+    pub pacman_start: Option<I8Vec2>,
 }
 
 /// Parser for converting raw board layouts into structured map data.
@@ -88,7 +88,7 @@ impl MapTileParser {
         let mut tiles = [[MapTile::Empty; BOARD_CELL_SIZE.y as usize]; BOARD_CELL_SIZE.x as usize];
         let mut house_door = [None; 2];
         let mut tunnel_ends = [None; 2];
-        let mut pacman_start: Option<IVec2> = None;
+        let mut pacman_start: Option<I8Vec2> = None;
 
         for (y, line) in raw_board.iter().enumerate().take(BOARD_CELL_SIZE.y as usize) {
             for (x, character) in line.chars().enumerate().take(BOARD_CELL_SIZE.x as usize) {
@@ -98,16 +98,16 @@ impl MapTileParser {
                 match tile {
                     MapTile::Tunnel => {
                         if tunnel_ends[0].is_none() {
-                            tunnel_ends[0] = Some(IVec2::new(x as i32, y as i32));
+                            tunnel_ends[0] = Some(I8Vec2::new(x as i8, y as i8));
                         } else {
-                            tunnel_ends[1] = Some(IVec2::new(x as i32, y as i32));
+                            tunnel_ends[1] = Some(I8Vec2::new(x as i8, y as i8));
                         }
                     }
                     MapTile::Wall if character == '=' => {
                         if house_door[0].is_none() {
-                            house_door[0] = Some(IVec2::new(x as i32, y as i32));
+                            house_door[0] = Some(I8Vec2::new(x as i8, y as i8));
                         } else {
-                            house_door[1] = Some(IVec2::new(x as i32, y as i32));
+                            house_door[1] = Some(I8Vec2::new(x as i8, y as i8));
                         }
                     }
                     _ => {}
@@ -115,7 +115,7 @@ impl MapTileParser {
 
                 // Track Pac-Man's starting position
                 if character == 'X' {
-                    pacman_start = Some(IVec2::new(x as i32, y as i32));
+                    pacman_start = Some(I8Vec2::new(x as i8, y as i8));
                 }
 
                 tiles[x][y] = tile;

src/platform/desktop.rs

@@ -24,44 +24,6 @@ impl CommonPlatform for Platform {
     }
 
     fn init_console(&self) -> Result<(), PlatformError> {
-        #[cfg(windows)]
-        {
-            unsafe {
-                use winapi::{
-                    shared::ntdef::NULL,
-                    um::{
-                        fileapi::{CreateFileA, OPEN_EXISTING},
-                        handleapi::INVALID_HANDLE_VALUE,
-                        processenv::SetStdHandle,
-                        winbase::{STD_ERROR_HANDLE, STD_OUTPUT_HANDLE},
-                        wincon::{AttachConsole, GetConsoleWindow},
-                        winnt::{FILE_SHARE_READ, FILE_SHARE_WRITE, GENERIC_READ, GENERIC_WRITE},
-                    },
-                };
-
-                if !std::ptr::eq(GetConsoleWindow(), std::ptr::null_mut()) {
-                    return Ok(());
-                }
-
-                if AttachConsole(winapi::um::wincon::ATTACH_PARENT_PROCESS) != 0 {
-                    let handle = CreateFileA(
-                        c"CONOUT$".as_ptr(),
-                        GENERIC_READ | GENERIC_WRITE,
-                        FILE_SHARE_READ | FILE_SHARE_WRITE,
-                        std::ptr::null_mut(),
-                        OPEN_EXISTING,
-                        0,
-                        NULL,
-                    );
-
-                    if handle != INVALID_HANDLE_VALUE {
-                        SetStdHandle(STD_OUTPUT_HANDLE, handle);
-                        SetStdHandle(STD_ERROR_HANDLE, handle);
-                    }
-                }
-            }
-        }
-
         Ok(())
     }
 

src/systems/blinking.rs

@@ -1,27 +1,63 @@
 use bevy_ecs::{
     component::Component,
-    system::{Query, Res},
+    entity::Entity,
+    query::{Has, With},
+    system::{Commands, Query, Res},
 };
 
-use crate::systems::components::{DeltaTime, Renderable};
+use crate::systems::{
+    components::{DeltaTime, Renderable},
+    Frozen, Hidden,
+};
 
-#[derive(Component)]
+#[derive(Component, Debug)]
 pub struct Blinking {
     pub timer: f32,
     pub interval: f32,
 }
 
+impl Blinking {
+    pub fn new(interval: f32) -> Self {
+        Self { timer: 0.0, interval }
+    }
+}
+
 /// Updates blinking entities by toggling their visibility at regular intervals.
 ///
 /// This system manages entities that have both `Blinking` and `Renderable` components,
 /// accumulating time and toggling visibility when the specified interval is reached.
-pub fn blinking_system(time: Res<DeltaTime>, mut query: Query<(&mut Blinking, &mut Renderable)>) {
-    for (mut blinking, mut renderable) in query.iter_mut() {
+#[allow(clippy::type_complexity)]
+pub fn blinking_system(
+    mut commands: Commands,
+    time: Res<DeltaTime>,
+    mut query: Query<(Entity, &mut Blinking, Has<Hidden>, Has<Frozen>), With<Renderable>>,
+) {
+    for (entity, mut blinking, hidden, frozen) in query.iter_mut() {
+        // If the entity is frozen, blinking is disabled and the entity is unhidden (if it was hidden)
+        if frozen {
+            if hidden {
+                commands.entity(entity).remove::<Hidden>();
+            }
+
+            continue;
+        }
+
+        // Increase the timer by the delta time
         blinking.timer += time.0;
 
-        if blinking.timer >= blinking.interval {
-            blinking.timer = 0.0;
-            renderable.visible = !renderable.visible;
+        // If the timer is less than the interval, there's nothing to do yet
+        if blinking.timer < blinking.interval {
+            continue;
+        }
+
+        // Subtract the interval (allows for the timer to retain partial interval progress)
+        blinking.timer -= blinking.interval;
+
+        // Toggle the Hidden component
+        if hidden {
+            commands.entity(entity).remove::<Hidden>();
+        } else {
+            commands.entity(entity).insert(Hidden);
         }
     }
 }

src/systems/collision.rs

@@ -8,7 +8,7 @@ use crate::error::GameError;
 use crate::events::GameEvent;
 use crate::map::builder::Map;
 use crate::systems::movement::Position;
-use crate::systems::{AudioEvent, Ghost, PlayerControlled, ScoreResource, Vulnerable};
+use crate::systems::{AudioEvent, Eaten, Ghost, PlayerControlled, ScoreResource, Vulnerable};
 
 #[derive(Component)]
 pub struct Collider {
@@ -136,7 +136,7 @@ pub fn ghost_collision_system(
                     score.0 += 200;
 
                     // Remove the ghost
-                    commands.entity(ghost_ent).despawn();
+                    commands.entity(ghost_ent).remove::<Vulnerable>().insert(Eaten);
 
                     // Play eat sound
                     events.write(AudioEvent::PlayEat);

src/systems/components.rs

@@ -5,16 +5,17 @@ use crate::{
     map::graph::TraversalFlags,
     systems::{
         movement::{BufferedDirection, Position, Velocity},
-        Collider, GhostCollider, ItemCollider, PacmanCollider, PlayerLifecycle,
+        Collider, GhostCollider, ItemCollider, PacmanCollider,
     },
     texture::{animated::AnimatedTexture, sprite::AtlasTile},
 };
+use micromap::Map;
 
 /// A tag component for entities that are controlled by the player.
 #[derive(Default, Component)]
 pub struct PlayerControlled;
 
-#[derive(Component, Debug, Clone, Copy, PartialEq, Eq)]
+#[derive(Component, Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum Ghost {
     Blinky,
     Pinky,
@@ -93,16 +94,36 @@ impl EntityType {
 pub struct Renderable {
     pub sprite: AtlasTile,
     pub layer: u8,
-    pub visible: bool,
 }
 
 /// A component for entities that have a directional animated texture.
-#[derive(Component)]
+#[derive(Component, Clone, Default)]
 pub struct DirectionalAnimated {
     pub textures: [Option<AnimatedTexture>; 4],
     pub stopped_textures: [Option<AnimatedTexture>; 4],
 }
 
+impl DirectionalAnimated {
+    pub fn from_animation(animation: AnimatedTexture) -> Self {
+        // Create 4 copies of the animation - necessary for independent state per direction
+        // This is initialization-time only, so the cloning cost is acceptable
+        Self {
+            textures: [
+                Some(animation.clone()),
+                Some(animation.clone()),
+                Some(animation.clone()),
+                Some(animation.clone()),
+            ],
+            stopped_textures: [
+                Some(animation.clone()),
+                Some(animation.clone()),
+                Some(animation.clone()),
+                Some(animation),
+            ],
+        }
+    }
+}
+
 bitflags! {
     #[derive(Component, Default, Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
     pub struct CollisionLayer: u8 {
@@ -141,45 +162,96 @@ impl Default for MovementModifiers {
     }
 }
 
-/// 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,
-}
-
-impl Default for LevelTiming {
-    fn default() -> Self {
-        Self {
-            energizer_duration: 6.0,
-            spawn_freeze_duration: 1.5,
-            energizer_flash_threshold: 2.0,
-        }
-    }
-}
-
-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;
 
+/// Tag component for eaten ghosts
+#[derive(Component, Debug, Clone, Copy)]
+pub struct Eaten;
+
 /// Component for ghosts that are vulnerable to Pac-Man
 #[derive(Component, Debug, Clone, Copy)]
 pub struct Vulnerable {
     pub remaining_ticks: u32,
 }
 
+/// Enumeration of different ghost animation states.
+/// Note that this is used in micromap which has a fixed size based on the number of variants,
+/// so extending this should be done with caution, and will require updating the micromap's capacity.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum GhostAnimation {
+    /// Normal ghost appearance with directional movement animations
+    Normal,
+    /// Blue ghost appearance when vulnerable (power pellet active)
+    Frightened { flash: bool },
+    /// Eyes-only animation when ghost has been consumed by Pac-Man (Eaten state)
+    Eyes,
+}
+
+/// A complete set of animations for a ghost in different behavioral states.
+///
+/// Each ghost maintains animations mapped by their current gameplay state.
+/// The animation system automatically switches between these states based on
+/// the presence of `Vulnerable` and `Eaten` components on the ghost entity.
+#[derive(Component, Clone)]
+pub struct GhostAnimationSet {
+    pub animations: Map<GhostAnimation, DirectionalAnimated, 4>,
+}
+
+impl GhostAnimationSet {
+    /// Creates a new GhostAnimationSet with the provided animations.
+    pub fn new(
+        normal: DirectionalAnimated,
+        frightened: DirectionalAnimated,
+        frightened_flashing: DirectionalAnimated,
+        eyes: DirectionalAnimated,
+    ) -> Self {
+        let mut animations = Map::new();
+        animations.insert(GhostAnimation::Normal, normal);
+        animations.insert(GhostAnimation::Frightened { flash: false }, frightened);
+        animations.insert(GhostAnimation::Frightened { flash: true }, frightened_flashing);
+        animations.insert(GhostAnimation::Eyes, eyes);
+        Self { animations }
+    }
+
+    /// Gets the animation for the specified ghost animation state.
+    pub fn get(&self, animation: GhostAnimation) -> Option<&DirectionalAnimated> {
+        self.animations.get(&animation)
+    }
+
+    /// Gets the normal animation state.
+    pub fn normal(&self) -> Option<&DirectionalAnimated> {
+        self.get(GhostAnimation::Normal)
+    }
+
+    /// Gets the frightened animation state (non-flashing).
+    pub fn frightened(&self) -> Option<&DirectionalAnimated> {
+        self.get(GhostAnimation::Frightened { flash: false })
+    }
+
+    /// Gets the frightened flashing animation state.
+    pub fn frightened_flashing(&self) -> Option<&DirectionalAnimated> {
+        self.get(GhostAnimation::Frightened { flash: true })
+    }
+
+    /// Gets the eyes animation state (for eaten ghosts).
+    pub fn eyes(&self) -> Option<&DirectionalAnimated> {
+        self.get(GhostAnimation::Eyes)
+    }
+}
+
+/// Global resource containing pre-loaded animation sets for all ghost types.
+///
+/// This resource is initialized once during game startup and provides O(1) access
+/// to animation sets for each ghost type. The animation system uses this resource
+/// to efficiently switch between different ghost states without runtime asset loading.
+///
+/// The HashMap is keyed by `Ghost` enum variants (Blinky, Pinky, Inky, Clyde) and
+/// contains complete animation sets mapped by GhostAnimation states.
+#[derive(Resource)]
+pub struct GhostAnimations(pub std::collections::HashMap<Ghost, GhostAnimationSet>);
+
 #[derive(Bundle)]
 pub struct PlayerBundle {
     pub player: PlayerControlled,
@@ -190,14 +262,8 @@ pub struct PlayerBundle {
     pub directional_animated: DirectionalAnimated,
     pub entity_type: EntityType,
     pub collider: Collider,
-    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,
+    pub pacman_collider: PacmanCollider,
 }
 
 #[derive(Bundle)]

src/systems/debug.rs

@@ -3,7 +3,7 @@ use std::cmp::Ordering;
 
 use crate::constants::BOARD_PIXEL_OFFSET;
 use crate::map::builder::Map;
-use crate::systems::{BackbufferResource, Collider, CursorPosition, Position, SystemTimings};
+use crate::systems::{Collider, CursorPosition, NodeId, Position, SystemTimings};
 use bevy_ecs::resource::Resource;
 use bevy_ecs::system::{NonSendMut, Query, Res};
 use glam::{IVec2, UVec2, Vec2};
@@ -54,8 +54,8 @@ fn render_timing_display(
         .unwrap_or(0);
 
     // Only draw background if there is text to display
-    if max_width > 0 {
-        let total_height = (lines.len() as u32) * line_height as u32;
+    let total_height = (lines.len() as u32) * line_height as u32;
+    if max_width > 0 && total_height > 0 {
         let bg_padding = 5;
 
         // Draw background
@@ -89,7 +89,6 @@ fn render_timing_display(
 #[allow(clippy::too_many_arguments)]
 pub fn debug_render_system(
     mut canvas: NonSendMut<&mut Canvas<Window>>,
-    backbuffer: NonSendMut<BackbufferResource>,
     mut debug_texture: NonSendMut<DebugTextureResource>,
     debug_font: NonSendMut<DebugFontResource>,
     debug_state: Res<DebugState>,
@@ -104,18 +103,6 @@ pub fn debug_render_system(
     let scale =
         (UVec2::from(canvas.output_size().unwrap()).as_vec2() / UVec2::from(canvas.logical_size()).as_vec2()).min_element();
 
-    // Copy the current backbuffer to the debug texture
-    canvas
-        .with_texture_canvas(&mut debug_texture.0, |debug_canvas| {
-            // Clear the debug canvas
-            debug_canvas.set_draw_color(Color::BLACK);
-            debug_canvas.clear();
-
-            // Copy the backbuffer to the debug canvas
-            debug_canvas.copy(&backbuffer.0, None, None).unwrap();
-        })
-        .unwrap();
-
     // Get texture creator before entering the closure to avoid borrowing conflicts
     let mut texture_creator = canvas.texture_creator();
     let font = &debug_font.0;
@@ -128,8 +115,11 @@ pub fn debug_render_system(
     // Draw debug info on the high-resolution debug texture
     canvas
         .with_texture_canvas(&mut debug_texture.0, |debug_canvas| {
-            // Find the closest node to the cursor
+            // Clear the debug canvas
+            debug_canvas.set_draw_color(Color::RGBA(0, 0, 0, 0));
+            debug_canvas.clear();
 
+            // Find the closest node to the cursor
             let closest_node = if let Some(cursor_world_pos) = cursor_world_pos {
                 map.graph
                     .nodes()
@@ -195,7 +185,7 @@ pub fn debug_render_system(
 
             // Render node ID if a node is highlighted
             if let Some(closest_node_id) = closest_node {
-                let node = map.graph.get_node(closest_node_id).unwrap();
+                let node = map.graph.get_node(closest_node_id as NodeId).unwrap();
                 let pos = transform_position_with_offset(node.position, scale);
 
                 let surface = font
@@ -214,8 +204,4 @@ pub fn debug_render_system(
             render_timing_display(debug_canvas, &mut texture_creator, &timings, font);
         })
         .unwrap();
-
-    // Draw the debug texture directly onto the main canvas at full resolution
-    canvas.copy(&debug_texture.0, None, None).unwrap();
-    canvas.present();
 }

src/systems/formatting.rs

@@ -1,107 +0,0 @@
-use num_width::NumberWidth;
-use smallvec::SmallVec;
-use std::time::Duration;
-use strum::EnumCount;
-
-use crate::systems::profiling::SystemId;
-
-// Helper to split a duration into a integer, decimal, and unit
-fn get_value(duration: &Duration) -> (u64, u32, &'static str) {
-    let (int, decimal, unit) = match duration {
-        // if greater than 1 second, return as seconds
-        n if n >= &Duration::from_secs(1) => {
-            let secs = n.as_secs();
-            let decimal = n.as_millis() as u64 % 1000;
-            (secs, decimal as u32, "s")
-        }
-        // if greater than 1 millisecond, return as milliseconds
-        n if n >= &Duration::from_millis(1) => {
-            let ms = n.as_millis() as u64;
-            let decimal = n.as_micros() as u64 % 1000;
-            (ms, decimal as u32, "ms")
-        }
-        // if greater than 1 microsecond, return as microseconds
-        n if n >= &Duration::from_micros(1) => {
-            let us = n.as_micros() as u64;
-            let decimal = n.as_nanos() as u64 % 1000;
-            (us, decimal as u32, "µs")
-        }
-        // otherwise, return as nanoseconds
-        n => {
-            let ns = n.as_nanos() as u64;
-            (ns, 0, "ns")
-        }
-    };
-
-    (int, decimal, unit)
-}
-
-/// Formats timing data into a vector of strings with proper alignment
-pub fn format_timing_display(
-    timing_data: impl IntoIterator<Item = (String, Duration, Duration)>,
-) -> SmallVec<[String; SystemId::COUNT]> {
-    let mut iter = timing_data.into_iter().peekable();
-    if iter.peek().is_none() {
-        return SmallVec::new();
-    }
-
-    struct Entry {
-        name: String,
-        avg_int: u64,
-        avg_decimal: u32,
-        avg_unit: &'static str,
-        std_int: u64,
-        std_decimal: u32,
-        std_unit: &'static str,
-    }
-
-    let entries = iter
-        .map(|(name, avg, std_dev)| {
-            let (avg_int, avg_decimal, avg_unit) = get_value(&avg);
-            let (std_int, std_decimal, std_unit) = get_value(&std_dev);
-
-            Entry {
-                name: name.clone(),
-                avg_int,
-                avg_decimal,
-                avg_unit,
-                std_int,
-                std_decimal,
-                std_unit,
-            }
-        })
-        .collect::<SmallVec<[Entry; 12]>>();
-
-    let (max_name_width, max_avg_int_width, max_avg_decimal_width, max_std_int_width, max_std_decimal_width) = entries
-        .iter()
-        .fold((0, 0, 3, 0, 3), |(name_w, avg_int_w, avg_dec_w, std_int_w, std_dec_w), e| {
-            (
-                name_w.max(e.name.len()),
-                avg_int_w.max(e.avg_int.width() as usize),
-                avg_dec_w.max(e.avg_decimal.width() as usize),
-                std_int_w.max(e.std_int.width() as usize),
-                std_dec_w.max(e.std_decimal.width() as usize),
-            )
-        });
-
-    entries.iter().map(|e| {
-            format!(
-                "{name:max_name_width$} : {avg_int:max_avg_int_width$}.{avg_decimal:<max_avg_decimal_width$}{avg_unit} ± {std_int:max_std_int_width$}.{std_decimal:<max_std_decimal_width$}{std_unit}",
-                // Content
-                name = e.name,
-                avg_int = e.avg_int,
-                avg_decimal = e.avg_decimal,
-                std_int = e.std_int,
-                std_decimal = e.std_decimal,
-                // Units
-                avg_unit = e.avg_unit,
-                std_unit = e.std_unit,
-                // Padding
-                max_name_width = max_name_width,
-                max_avg_int_width = max_avg_int_width,
-                max_avg_decimal_width = max_avg_decimal_width,
-                max_std_int_width = max_std_int_width,
-                max_std_decimal_width = max_std_decimal_width
-            )
-        }).collect::<SmallVec<[String; SystemId::COUNT]>>()
-}

src/systems/ghost.rs

@@ -10,8 +10,16 @@ use crate::{
         movement::{Position, Velocity},
     },
 };
-use bevy_ecs::query::Without;
-use bevy_ecs::system::{Query, Res};
+
+use bevy_ecs::{
+    query::Added,
+    removal_detection::RemovedComponents,
+    system::{Commands, Query, Res},
+};
+
+use crate::systems::{Eaten, GhostAnimations, Vulnerable};
+
+use bevy_ecs::query::{With, Without};
 use rand::rngs::SmallRng;
 use rand::seq::IndexedRandom;
 use rand::SeedableRng;
@@ -28,7 +36,7 @@ pub fn ghost_movement_system(
         loop {
             match *position {
                 Position::Stopped { node: current_node } => {
-                    let intersection = &map.graph.adjacency_list[current_node];
+                    let intersection = &map.graph.adjacency_list[current_node as usize];
                     let opposite = velocity.direction.opposite();
 
                     let mut non_opposite_options: SmallVec<[Edge; 3]> = SmallVec::new();
@@ -68,3 +76,167 @@ pub fn ghost_movement_system(
         }
     }
 }
+
+/// System that manages ghost animation state transitions based on ghost behavior.
+///
+/// This system handles the following animation state changes:
+/// - When a ghost becomes vulnerable (power pellet eaten): switches to frightened animation
+/// - When a ghost is eaten by Pac-Man: switches to eaten (eyes) animation
+/// - When vulnerability ends: switches back to normal animation
+///
+/// The system uses ECS change detection to efficiently track state transitions:
+/// - `Added<Vulnerable>` detects when ghosts become frightened
+/// - `Added<Eaten>` detects when ghosts are consumed
+/// - `RemovedComponents<Vulnerable>` detects when fright period ends
+///
+/// This ensures smooth visual feedback for gameplay state changes while maintaining
+/// separation between game logic and animation state.
+pub fn ghost_state_animation_system(
+    mut commands: Commands,
+    animations: Res<GhostAnimations>,
+    mut vulnerable_added: Query<(bevy_ecs::entity::Entity, &Ghost), Added<Vulnerable>>,
+    mut eaten_added: Query<(bevy_ecs::entity::Entity, &Ghost), Added<Eaten>>,
+    mut vulnerable_removed: RemovedComponents<Vulnerable>,
+    ghosts: Query<&Ghost>,
+) {
+    // When a ghost becomes vulnerable, switch to the frightened animation
+    for (entity, ghost_type) in vulnerable_added.iter_mut() {
+        if let Some(animation_set) = animations.0.get(ghost_type) {
+            if let Some(animation) = animation_set.frightened() {
+                commands.entity(entity).insert(animation.clone());
+            }
+        }
+    }
+
+    // When a ghost is eaten, switch to the eaten animation
+    for (entity, ghost_type) in eaten_added.iter_mut() {
+        if let Some(animation_set) = animations.0.get(ghost_type) {
+            if let Some(animation) = animation_set.eyes() {
+                commands.entity(entity).insert(animation.clone());
+            }
+        }
+    }
+
+    // When a ghost is no longer vulnerable, switch back to the normal animation
+    for entity in vulnerable_removed.read() {
+        if let Ok(ghost_type) = ghosts.get(entity) {
+            if let Some(animation_set) = animations.0.get(ghost_type) {
+                if let Some(animation) = animation_set.normal() {
+                    commands.entity(entity).insert(animation.clone());
+                }
+            }
+        }
+    }
+}
+
+/// System that handles eaten ghost behavior and respawn logic.
+///
+/// When a ghost is eaten by Pac-Man, it enters an "eaten" state where:
+/// 1. It displays eyes-only animation
+/// 2. It moves directly back to the ghost house at increased speed
+/// 3. Once it reaches the ghost house center, it respawns as a normal ghost
+///
+/// This system runs after the main movement system to override eaten ghost movement.
+pub fn eaten_ghost_system(
+    map: Res<Map>,
+    delta_time: Res<DeltaTime>,
+    animations: Res<GhostAnimations>,
+    mut commands: Commands,
+    mut eaten_ghosts: Query<(bevy_ecs::entity::Entity, &Ghost, &mut Position, &mut Velocity), With<Eaten>>,
+) {
+    for (entity, ghost_type, mut position, mut velocity) in eaten_ghosts.iter_mut() {
+        // Set higher speed for eaten ghosts returning to ghost house
+        let original_speed = velocity.speed;
+        velocity.speed = ghost_type.base_speed() * 2.0; // Move twice as fast when eaten
+
+        // Calculate direction towards ghost house center (using Clyde's start position)
+        let ghost_house_center = map.start_positions.clyde;
+
+        match *position {
+            Position::Stopped { node: current_node } => {
+                // Find path to ghost house center and start moving
+                if let Some(direction) = find_direction_to_target(&map, current_node, ghost_house_center) {
+                    velocity.direction = direction;
+                    *position = Position::Moving {
+                        from: current_node,
+                        to: map.graph.adjacency_list[current_node as usize].get(direction).unwrap().target,
+                        remaining_distance: map.graph.adjacency_list[current_node as usize]
+                            .get(direction)
+                            .unwrap()
+                            .distance,
+                    };
+                }
+            }
+            Position::Moving { to, .. } => {
+                let distance = velocity.speed * 60.0 * delta_time.0;
+                if let Some(_overflow) = position.tick(distance) {
+                    // Reached target node, check if we're at ghost house center
+                    if to == ghost_house_center {
+                        // Respawn the ghost - remove Eaten component and switch to normal animation
+                        commands.entity(entity).remove::<Eaten>();
+                        if let Some(animation_set) = animations.0.get(ghost_type) {
+                            if let Some(animation) = animation_set.normal() {
+                                commands.entity(entity).insert(animation.clone());
+                            }
+                        }
+                        // Reset to stopped at ghost house center
+                        *position = Position::Stopped {
+                            node: ghost_house_center,
+                        };
+                    } else {
+                        // Continue pathfinding to ghost house
+                        if let Some(next_direction) = find_direction_to_target(&map, to, ghost_house_center) {
+                            velocity.direction = next_direction;
+                            *position = Position::Moving {
+                                from: to,
+                                to: map.graph.adjacency_list[to as usize].get(next_direction).unwrap().target,
+                                remaining_distance: map.graph.adjacency_list[to as usize].get(next_direction).unwrap().distance,
+                            };
+                        }
+                    }
+                }
+            }
+        }
+
+        // Restore original speed
+        velocity.speed = original_speed;
+    }
+}
+
+/// Helper function to find the direction from a node towards a target node.
+/// Uses simple greedy pathfinding - prefers straight lines when possible.
+fn find_direction_to_target(
+    map: &Map,
+    from_node: crate::systems::movement::NodeId,
+    target_node: crate::systems::movement::NodeId,
+) -> Option<Direction> {
+    let from_pos = map.graph.get_node(from_node).unwrap().position;
+    let target_pos = map.graph.get_node(target_node).unwrap().position;
+
+    let dx = target_pos.x as i32 - from_pos.x as i32;
+    let dy = target_pos.y as i32 - from_pos.y as i32;
+
+    // Prefer horizontal movement first, then vertical
+    let preferred_dirs = if dx.abs() > dy.abs() {
+        if dx > 0 {
+            [Direction::Right, Direction::Up, Direction::Down, Direction::Left]
+        } else {
+            [Direction::Left, Direction::Up, Direction::Down, Direction::Right]
+        }
+    } else if dy > 0 {
+        [Direction::Down, Direction::Left, Direction::Right, Direction::Up]
+    } else {
+        [Direction::Up, Direction::Left, Direction::Right, Direction::Down]
+    };
+
+    // Return first available direction towards target
+    for direction in preferred_dirs {
+        if let Some(edge) = map.graph.adjacency_list[from_node as usize].get(direction) {
+            if edge.traversal_flags.contains(TraversalFlags::GHOST) {
+                return Some(direction);
+            }
+        }
+    }
+
+    None
+}

src/systems/item.rs

@@ -2,12 +2,12 @@ use bevy_ecs::{
     entity::Entity,
     event::{EventReader, EventWriter},
     query::With,
-    system::{Commands, Query, Res, ResMut},
+    system::{Commands, Query, ResMut},
 };
 
 use crate::{
     events::GameEvent,
-    systems::{AudioEvent, EntityType, GhostCollider, ItemCollider, LevelTiming, PacmanCollider, ScoreResource, Vulnerable},
+    systems::{AudioEvent, EntityType, GhostCollider, ItemCollider, PacmanCollider, ScoreResource, Vulnerable},
 };
 
 /// Determines if a collision between two entity types should be handled by the item system.
@@ -29,7 +29,6 @@ pub fn item_system(
     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 {
@@ -58,7 +57,7 @@ pub fn item_system(
                     // 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;
+                        let total_ticks = 60 * 5;
 
                         // Add Vulnerable component to all ghosts
                         for ghost_entity in ghost_query.iter() {

src/systems/mod.rs

@@ -8,7 +8,6 @@ pub mod blinking;
 pub mod collision;
 pub mod components;
 pub mod debug;
-pub mod formatting;
 pub mod ghost;
 pub mod input;
 pub mod item;

src/systems/movement.rs

@@ -8,7 +8,7 @@ use glam::Vec2;
 ///
 /// Nodes represent discrete movement targets in the maze. The index directly corresponds to the node's position in the
 /// graph's internal storage arrays.
-pub type NodeId = usize;
+pub type NodeId = u16;
 
 /// A component that represents the speed and cardinal direction of an entity.
 /// Speed is static, only applied when the entity has an edge to traverse.
@@ -57,7 +57,7 @@ impl Position {
         let pos = match &self {
             Position::Stopped { node } => {
                 // Entity is stationary at a node
-                let node = graph.get_node(*node).ok_or(EntityError::NodeNotFound(*node))?;
+                let node = graph.get_node(*node).ok_or(EntityError::NodeNotFound(*node as usize))?;
                 node.position
             }
             Position::Moving {
@@ -66,11 +66,12 @@ impl Position {
                 remaining_distance,
             } => {
                 // Entity is traveling between nodes
-                let from_node = graph.get_node(*from).ok_or(EntityError::NodeNotFound(*from))?;
-                let to_node = graph.get_node(*to).ok_or(EntityError::NodeNotFound(*to))?;
-                let edge = graph
-                    .find_edge(*from, *to)
-                    .ok_or(EntityError::EdgeNotFound { from: *from, to: *to })?;
+                let from_node = graph.get_node(*from).ok_or(EntityError::NodeNotFound(*from as usize))?;
+                let to_node = graph.get_node(*to).ok_or(EntityError::NodeNotFound(*to as usize))?;
+                let edge = graph.find_edge(*from, *to).ok_or(EntityError::EdgeNotFound {
+                    from: *from as usize,
+                    to: *to as usize,
+                })?;
 
                 // For zero-distance edges (tunnels), progress >= 1.0 means we're at the target
                 if edge.distance == 0.0 {

src/systems/player.rs

@@ -1,5 +1,4 @@
 use bevy_ecs::{
-    component::Component,
     event::{EventReader, EventWriter},
     query::{With, Without},
     system::{Query, Res, ResMut},
@@ -17,26 +16,9 @@ use crate::{
     },
 };
 
-/// 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
-    }
+pub fn can_traverse(entity_type: EntityType, edge: Edge) -> bool {
+    let entity_flags = entity_type.traversal_flags();
+    edge.traversal_flags.contains(entity_flags)
 }
 
 /// Processes player input commands and updates game state accordingly.
@@ -50,29 +32,26 @@ pub fn player_control_system(
     mut state: ResMut<GlobalState>,
     mut debug_state: ResMut<DebugState>,
     mut audio_state: ResMut<AudioState>,
-    mut players: Query<(&PlayerLifecycle, &mut BufferedDirection), (With<PlayerControlled>, Without<Frozen>)>,
+    mut players: Query<&mut BufferedDirection, (With<PlayerControlled>, Without<Frozen>)>,
     mut errors: EventWriter<GameError>,
 ) {
-    // Get the player's movable component (ensuring there is only one player)
-    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: {}",
-                e
-            )));
-            return;
-        }
-    };
-
-    // 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 {
             match command {
                 GameCommand::MovePlayer(direction) => {
+                    // Get the player's movable component (ensuring there is only one player)
+                    let mut buffered_direction = match players.single_mut() {
+                        Ok(tuple) => tuple,
+                        Err(e) => {
+                            errors.write(GameError::InvalidState(format!(
+                                "No/multiple entities queried for player system: {}",
+                                e
+                            )));
+                            return;
+                        }
+                    };
+
                     *buffered_direction = BufferedDirection::Some {
                         direction: *direction,
                         remaining_time: 0.25,
@@ -94,32 +73,21 @@ pub fn player_control_system(
     }
 }
 
-pub fn can_traverse(entity_type: EntityType, edge: Edge) -> bool {
-    let entity_flags = entity_type.traversal_flags();
-    edge.traversal_flags.contains(entity_flags)
-}
-
 /// Executes frame-by-frame movement for Pac-Man.
 ///
 /// Handles movement logic including buffered direction changes, edge traversal validation, and continuous movement between nodes.
 /// When stopped, prioritizes buffered directions for responsive controls, falling back to current direction.
 /// Supports movement chaining within a single frame when traveling at high speeds.
+#[allow(clippy::type_complexity)]
 pub fn player_movement_system(
     map: Res<Map>,
     delta_time: Res<DeltaTime>,
     mut entities: Query<
-        (
-            &PlayerLifecycle,
-            &MovementModifiers,
-            &mut Position,
-            &mut Velocity,
-            &mut BufferedDirection,
-        ),
+        (&MovementModifiers, &mut Position, &mut Velocity, &mut BufferedDirection),
         (With<PlayerControlled>, Without<Frozen>),
     >,
-    // mut errors: EventWriter<GameError>,
 ) {
-    for (lifecycle, modifiers, mut position, mut velocity, mut buffered_direction) in entities.iter_mut() {
+    for (modifiers, mut position, mut velocity, mut buffered_direction) in entities.iter_mut() {
         // Decrement the buffered direction remaining time
         if let BufferedDirection::Some {
             direction,

src/systems/profiling.rs

@@ -2,6 +2,7 @@ use bevy_ecs::system::IntoSystem;
 use bevy_ecs::{resource::Resource, system::System};
 use circular_buffer::CircularBuffer;
 use micromap::Map;
+use num_width::NumberWidth;
 use parking_lot::{Mutex, RwLock};
 use smallvec::SmallVec;
 use std::fmt::Display;
@@ -10,8 +11,6 @@ use strum::EnumCount;
 use strum_macros::{EnumCount, IntoStaticStr};
 use thousands::Separable;
 
-use crate::systems::formatting;
-
 /// The maximum number of systems that can be profiled. Must not be exceeded, or it will panic.
 const MAX_SYSTEMS: usize = SystemId::COUNT;
 /// The number of durations to keep in the circular buffer.
@@ -36,6 +35,8 @@ pub enum SystemId {
     PlayerMovement,
     GhostCollision,
     Stage,
+    GhostStateAnimation,
+    EatenGhost,
 }
 
 impl Display for SystemId {
@@ -110,28 +111,26 @@ impl SystemTimings {
     }
 
     pub fn get_total_stats(&self) -> (Duration, Duration) {
-        let timings = self.timings.read();
-        let mut all_durations = Vec::new();
+        let duration_sums = {
+            let timings = self.timings.read();
+            timings
+                .iter()
+                .map(|(_, queue)| queue.lock().iter().sum::<Duration>())
+                .collect::<Vec<_>>()
+        };
 
-        for queue in timings.values() {
-            all_durations.extend(queue.lock().iter().map(|d| d.as_secs_f64() * 1000.0));
-        }
+        let mean = duration_sums.iter().sum::<Duration>() / duration_sums.len() as u32;
+        let variance = duration_sums
+            .iter()
+            .map(|x| {
+                let diff_secs = x.as_secs_f64() - mean.as_secs_f64();
+                diff_secs * diff_secs
+            })
+            .sum::<f64>()
+            / duration_sums.len() as f64;
+        let std_dev_secs = variance.sqrt();
 
-        if all_durations.is_empty() {
-            return (Duration::ZERO, Duration::ZERO);
-        }
-
-        let count = all_durations.len() as f64;
-        let sum: f64 = all_durations.iter().sum();
-        let mean = sum / count;
-
-        let variance = all_durations.iter().map(|x| (x - mean).powi(2)).sum::<f64>() / count;
-        let std_dev = variance.sqrt();
-
-        (
-            Duration::from_secs_f64(mean / 1000.0),
-            Duration::from_secs_f64(std_dev / 1000.0),
-        )
+        (mean, Duration::from_secs_f64(std_dev_secs))
     }
 
     pub fn format_timing_display(&self) -> SmallVec<[String; SystemId::COUNT]> {
@@ -145,21 +144,19 @@ impl SystemTimings {
         };
 
         // Collect timing data for formatting
-        let mut timing_data = Vec::new();
+        let mut timing_data = vec![(effective_fps, total_avg, total_std)];
 
-        // Add total stats
-        timing_data.push((effective_fps, total_avg, total_std));
-
-        // Add top 5 most expensive systems
+        // Sort the stats by average duration
         let mut sorted_stats: Vec<_> = stats.iter().collect();
         sorted_stats.sort_by(|a, b| b.1 .0.cmp(&a.1 .0));
 
-        for (name, (avg, std_dev)) in sorted_stats.iter().take(5) {
+        // Add the top 5 most expensive systems
+        for (name, (avg, std_dev)) in sorted_stats.iter().take(7) {
             timing_data.push((name.to_string(), *avg, *std_dev));
         }
 
         // Use the formatting module to format the data
-        formatting::format_timing_display(timing_data)
+        format_timing_display(timing_data)
     }
 }
 
@@ -184,3 +181,104 @@ where
         }
     }
 }
+
+// Helper to split a duration into a integer, decimal, and unit
+fn get_value(duration: &Duration) -> (u64, u32, &'static str) {
+    let (int, decimal, unit) = match duration {
+        // if greater than 1 second, return as seconds
+        n if n >= &Duration::from_secs(1) => {
+            let secs = n.as_secs();
+            let decimal = n.as_millis() as u64 % 1000;
+            (secs, decimal as u32, "s")
+        }
+        // if greater than 1 millisecond, return as milliseconds
+        n if n >= &Duration::from_millis(1) => {
+            let ms = n.as_millis() as u64;
+            let decimal = n.as_micros() as u64 % 1000;
+            (ms, decimal as u32, "ms")
+        }
+        // if greater than 1 microsecond, return as microseconds
+        n if n >= &Duration::from_micros(1) => {
+            let us = n.as_micros() as u64;
+            let decimal = n.as_nanos() as u64 % 1000;
+            (us, decimal as u32, "µs")
+        }
+        // otherwise, return as nanoseconds
+        n => {
+            let ns = n.as_nanos() as u64;
+            (ns, 0, "ns")
+        }
+    };
+
+    (int, decimal, unit)
+}
+
+/// Formats timing data into a vector of strings with proper alignment
+pub fn format_timing_display(
+    timing_data: impl IntoIterator<Item = (String, Duration, Duration)>,
+) -> SmallVec<[String; SystemId::COUNT]> {
+    let mut iter = timing_data.into_iter().peekable();
+    if iter.peek().is_none() {
+        return SmallVec::new();
+    }
+
+    struct Entry {
+        name: String,
+        avg_int: u64,
+        avg_decimal: u32,
+        avg_unit: &'static str,
+        std_int: u64,
+        std_decimal: u32,
+        std_unit: &'static str,
+    }
+
+    let entries = iter
+        .map(|(name, avg, std_dev)| {
+            let (avg_int, avg_decimal, avg_unit) = get_value(&avg);
+            let (std_int, std_decimal, std_unit) = get_value(&std_dev);
+
+            Entry {
+                name: name.clone(),
+                avg_int,
+                avg_decimal,
+                avg_unit,
+                std_int,
+                std_decimal,
+                std_unit,
+            }
+        })
+        .collect::<SmallVec<[Entry; 12]>>();
+
+    let (max_name_width, max_avg_int_width, max_avg_decimal_width, max_std_int_width, max_std_decimal_width) = entries
+        .iter()
+        .fold((0, 0, 3, 0, 3), |(name_w, avg_int_w, avg_dec_w, std_int_w, std_dec_w), e| {
+            (
+                name_w.max(e.name.len()),
+                avg_int_w.max(e.avg_int.width() as usize),
+                avg_dec_w.max(e.avg_decimal.width() as usize),
+                std_int_w.max(e.std_int.width() as usize),
+                std_dec_w.max(e.std_decimal.width() as usize),
+            )
+        });
+
+    entries.iter().map(|e| {
+            format!(
+                "{name:max_name_width$} : {avg_int:max_avg_int_width$}.{avg_decimal:<max_avg_decimal_width$}{avg_unit} ± {std_int:max_std_int_width$}.{std_decimal:<max_std_decimal_width$}{std_unit}",
+                // Content
+                name = e.name,
+                avg_int = e.avg_int,
+                avg_decimal = e.avg_decimal,
+                std_int = e.std_int,
+                std_decimal = e.std_decimal,
+                // Units
+                avg_unit = e.avg_unit,
+                std_unit = e.std_unit,
+                // Padding
+                max_name_width = max_name_width,
+                max_avg_int_width = max_avg_int_width,
+                max_avg_decimal_width = max_avg_decimal_width,
+                max_std_int_width = max_std_int_width,
+                max_std_decimal_width = max_std_decimal_width
+            )
+        }).collect::<SmallVec<[String; SystemId::COUNT]>>()
+}

src/systems/render.rs

@@ -2,32 +2,37 @@ use crate::constants::CANVAS_SIZE;
 use crate::error::{GameError, TextureError};
 use crate::map::builder::Map;
 use crate::systems::{
-    Blinking, DeltaTime, DirectionalAnimated, EntityType, GhostCollider, PlayerControlled, Position, Renderable, ScoreResource,
-    StartupSequence, Velocity,
+    DebugState, DebugTextureResource, DeltaTime, DirectionalAnimated, Position, Renderable, ScoreResource, StartupSequence,
+    Velocity,
 };
 use crate::texture::sprite::SpriteAtlas;
 use crate::texture::text::TextTexture;
+use bevy_ecs::component::Component;
 use bevy_ecs::entity::Entity;
 use bevy_ecs::event::EventWriter;
-use bevy_ecs::query::{Changed, Or, With, Without};
+use bevy_ecs::query::{Changed, Or, 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::render::{BlendMode, Canvas, Texture};
 use sdl2::video::Window;
 
 #[derive(Resource, Default)]
 pub struct RenderDirty(pub bool);
 
+#[derive(Component)]
+pub struct Hidden;
+
 #[allow(clippy::type_complexity)]
 pub fn dirty_render_system(
     mut dirty: ResMut<RenderDirty>,
-    changed_renderables: Query<(), Or<(Changed<Renderable>, Changed<Position>)>>,
+    changed: Query<(), Or<(Changed<Renderable>, Changed<Position>)>>,
+    removed_hidden: RemovedComponents<Hidden>,
     removed_renderables: RemovedComponents<Renderable>,
 ) {
-    if !changed_renderables.is_empty() || !removed_renderables.is_empty() {
+    if !changed.is_empty() || !removed_hidden.is_empty() || !removed_renderables.is_empty() {
         dirty.0 = true;
     }
 }
@@ -71,108 +76,69 @@ 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 backbuffer: NonSendMut<BackbufferResource>,
     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);
+    let _ = canvas.with_texture_canvas(&mut backbuffer.0, |canvas| {
+        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
+        // 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 let Err(e) = text_renderer.render(canvas, &mut atlas, &lives_text, lives_position) {
+            errors.write(TextureError::RenderFailed(format!("Failed to render lives 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);
+        // Render score text
+        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_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());
+        if let Err(e) = text_renderer.render(canvas, &mut atlas, &score_text, score_position) {
+            errors.write(TextureError::RenderFailed(format!("Failed to render score text: {}", e)).into());
+        }
+
+        // Render high score text
+        let high_score_text = format!("{:02}", score.0);
+        let high_score_offset = 17 - (high_score_text.len() as i32);
+        let high_score_position = glam::UVec2::new(4 + 8 * high_score_offset as u32, 10); // x_offset + score_offset * 8, 8 + y_offset
+        if let Err(e) = text_renderer.render(canvas, &mut atlas, &high_score_text, high_score_position) {
+            errors.write(TextureError::RenderFailed(format!("Failed to render high 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(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(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)]
@@ -183,7 +149,7 @@ pub fn render_system(
     mut atlas: NonSendMut<SpriteAtlas>,
     map: Res<Map>,
     dirty: Res<RenderDirty>,
-    renderables: Query<(Entity, &Renderable, &Position)>,
+    renderables: Query<(Entity, &Renderable, &Position), Without<Hidden>>,
     mut errors: EventWriter<GameError>,
 ) {
     if !dirty.0 {
@@ -207,10 +173,6 @@ pub fn render_system(
                 .sort_by_key::<(Entity, &Renderable, &Position), _>(|(_, renderable, _)| renderable.layer)
                 .rev()
             {
-                if !renderable.visible {
-                    continue;
-                }
-
                 let pos = position.get_pixel_position(&map.graph);
                 match pos {
                     Ok(pos) => {
@@ -237,3 +199,25 @@ pub fn render_system(
 
     canvas.copy(&backbuffer.0, None, None).unwrap();
 }
+
+pub fn present_system(
+    mut canvas: NonSendMut<&mut Canvas<Window>>,
+    mut dirty: ResMut<RenderDirty>,
+    backbuffer: NonSendMut<BackbufferResource>,
+    debug_texture: NonSendMut<DebugTextureResource>,
+    debug_state: Res<DebugState>,
+) {
+    if dirty.0 {
+        // Copy the backbuffer to the main canvas
+        canvas.copy(&backbuffer.0, None, None).unwrap();
+
+        // Copy the debug texture to the canvas
+        if debug_state.enabled {
+            canvas.set_blend_mode(BlendMode::Blend);
+            canvas.copy(&debug_texture.0, None, None).unwrap();
+        }
+
+        canvas.present();
+        dirty.0 = false;
+    }
+}

src/systems/stage.rs

@@ -4,8 +4,9 @@ use bevy_ecs::{
     resource::Resource,
     system::{Commands, Query, ResMut},
 };
+use tracing::debug;
 
-use crate::systems::{Frozen, GhostCollider, PlayerControlled};
+use crate::systems::{Blinking, Frozen, GhostCollider, Hidden, PlayerControlled};
 
 #[derive(Resource, Debug, Clone, Copy)]
 pub enum StartupSequence {
@@ -71,25 +72,28 @@ impl StartupSequence {
 pub fn startup_stage_system(
     mut startup: ResMut<StartupSequence>,
     mut commands: Commands,
+    mut blinking_query: Query<Entity, With<Blinking>>,
     mut player_query: Query<Entity, With<PlayerControlled>>,
     mut ghost_query: Query<Entity, With<GhostCollider>>,
 ) {
     if let Some((from, to)) = startup.tick() {
+        debug!("StartupSequence transition from {from:?} to {to:?}");
         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
+                // Unhide the player & ghosts
+                for entity in player_query.iter_mut().chain(ghost_query.iter_mut()) {
+                    commands.entity(entity).remove::<Hidden>();
+                }
             }
             (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);
+                // Unfreeze the player & ghosts & pellet blinking
+                for entity in player_query
+                    .iter_mut()
+                    .chain(ghost_query.iter_mut())
+                    .chain(blinking_query.iter_mut())
+                {
                     commands.entity(entity).remove::<Frozen>();
                 }
-
-                // TODO: Add GameActive tag component
-                // TODO: Remove CharactersVisible tag component
             }
             _ => {}
         }

src/systems/vulnerable.rs

@@ -1,18 +1,31 @@
-use bevy_ecs::query::With;
-use bevy_ecs::system::{Commands, Query};
+use bevy_ecs::{
+    query::With,
+    system::{Commands, Query, Res},
+};
 
-use crate::systems::{GhostCollider, Vulnerable};
+use crate::constants::animation::FRIGHTENED_FLASH_START_TICKS;
+use crate::systems::{Ghost, GhostAnimations, 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>>,
+    animations: Res<GhostAnimations>,
+    mut vulnerable_query: Query<(bevy_ecs::entity::Entity, &mut Vulnerable, &Ghost), With<GhostCollider>>,
 ) {
-    for (entity, mut vulnerable) in vulnerable_query.iter_mut() {
+    for (entity, mut vulnerable, ghost_type) in vulnerable_query.iter_mut() {
         if vulnerable.remaining_ticks > 0 {
             vulnerable.remaining_ticks -= 1;
         }
 
+        // When 2 seconds are remaining, start flashing
+        if vulnerable.remaining_ticks == FRIGHTENED_FLASH_START_TICKS {
+            if let Some(animation_set) = animations.0.get(ghost_type) {
+                if let Some(animation) = animation_set.frightened_flashing() {
+                    commands.entity(entity).insert(animation.clone());
+                }
+            }
+        }
+
         if vulnerable.remaining_ticks == 0 {
             commands.entity(entity).remove::<Vulnerable>();
         }

src/texture/animated.rs

@@ -1,3 +1,5 @@
+use smallvec::SmallVec;
+
 use crate::error::{AnimatedTextureError, GameError, GameResult, TextureError};
 use crate::texture::sprite::AtlasTile;
 
@@ -8,7 +10,7 @@ use crate::texture::sprite::AtlasTile;
 #[derive(Debug, Clone)]
 pub struct AnimatedTexture {
     /// Sequence of sprite tiles that make up the animation frames
-    tiles: Vec<AtlasTile>,
+    tiles: SmallVec<[AtlasTile; 4]>,
     /// Duration each frame should be displayed (in seconds)
     frame_duration: f32,
     /// Index of the currently active frame in the tiles vector
@@ -18,7 +20,7 @@ pub struct AnimatedTexture {
 }
 
 impl AnimatedTexture {
-    pub fn new(tiles: Vec<AtlasTile>, frame_duration: f32) -> GameResult<Self> {
+    pub fn new(tiles: SmallVec<[AtlasTile; 4]>, frame_duration: f32) -> GameResult<Self> {
         if frame_duration <= 0.0 {
             return Err(GameError::Texture(TextureError::Animated(
                 AnimatedTextureError::InvalidFrameDuration(frame_duration),

src/texture/sprite.rs

@@ -3,24 +3,21 @@ use glam::U16Vec2;
 use sdl2::pixels::Color;
 use sdl2::rect::Rect;
 use sdl2::render::{Canvas, RenderTarget, Texture};
-use serde::Deserialize;
 use std::collections::HashMap;
 
 use crate::error::TextureError;
 
 /// Atlas frame mapping data loaded from JSON metadata files.
-#[derive(Clone, Debug, Deserialize)]
+#[derive(Clone, Debug)]
 pub struct AtlasMapper {
     /// Mapping from sprite name to frame bounds within the atlas texture
     pub frames: HashMap<String, MapperFrame>,
 }
 
-#[derive(Copy, Clone, Debug, Deserialize)]
+#[derive(Copy, Clone, Debug)]
 pub struct MapperFrame {
-    pub x: u16,
-    pub y: u16,
-    pub width: u16,
-    pub height: u16,
+    pub pos: U16Vec2,
+    pub size: U16Vec2,
 }
 
 #[derive(Copy, Clone, Debug, PartialEq)]
@@ -108,8 +105,8 @@ impl SpriteAtlas {
     /// for repeated use in animations and entity sprites.
     pub fn get_tile(&self, name: &str) -> Option<AtlasTile> {
         self.tiles.get(name).map(|frame| AtlasTile {
-            pos: U16Vec2::new(frame.x, frame.y),
-            size: U16Vec2::new(frame.width, frame.height),
+            pos: frame.pos,
+            size: frame.size,
             color: None,
         })
     }

tests/animated.rs

@@ -3,6 +3,7 @@ use pacman::error::{AnimatedTextureError, GameError, TextureError};
 use pacman::texture::animated::AnimatedTexture;
 use pacman::texture::sprite::AtlasTile;
 use sdl2::pixels::Color;
+use smallvec::smallvec;
 
 fn mock_atlas_tile(id: u32) -> AtlasTile {
     AtlasTile {
@@ -14,7 +15,7 @@ fn mock_atlas_tile(id: u32) -> AtlasTile {
 
 #[test]
 fn test_animated_texture_creation_errors() {
-    let tiles = vec![mock_atlas_tile(1), mock_atlas_tile(2)];
+    let tiles = smallvec![mock_atlas_tile(1), mock_atlas_tile(2)];
 
     assert!(matches!(
         AnimatedTexture::new(tiles.clone(), 0.0).unwrap_err(),
@@ -29,7 +30,7 @@ fn test_animated_texture_creation_errors() {
 
 #[test]
 fn test_animated_texture_advancement() {
-    let tiles = vec![mock_atlas_tile(1), mock_atlas_tile(2), mock_atlas_tile(3)];
+    let tiles = smallvec![mock_atlas_tile(1), mock_atlas_tile(2), mock_atlas_tile(3)];
     let mut texture = AnimatedTexture::new(tiles, 0.1).unwrap();
 
     assert_eq!(texture.current_frame(), 0);
@@ -41,7 +42,7 @@ fn test_animated_texture_advancement() {
 
 #[test]
 fn test_animated_texture_wrap_around() {
-    let tiles = vec![mock_atlas_tile(1), mock_atlas_tile(2)];
+    let tiles = smallvec![mock_atlas_tile(1), mock_atlas_tile(2)];
     let mut texture = AnimatedTexture::new(tiles, 0.1).unwrap();
 
     texture.tick(0.1);
@@ -53,7 +54,7 @@ fn test_animated_texture_wrap_around() {
 
 #[test]
 fn test_animated_texture_single_frame() {
-    let tiles = vec![mock_atlas_tile(1)];
+    let tiles = smallvec![mock_atlas_tile(1)];
     let mut texture = AnimatedTexture::new(tiles, 0.1).unwrap();
 
     texture.tick(0.1);

tests/collision.rs

@@ -5,7 +5,8 @@ use pacman::{
     events::GameEvent,
     map::builder::Map,
     systems::{
-        check_collision, collision_system, Collider, EntityType, Ghost, GhostCollider, ItemCollider, PacmanCollider, Position,
+        check_collision, collision_system, Collider, EntityType, Ghost, GhostCollider, ItemCollider, NodeId, PacmanCollider,
+        Position,
     },
 };
 
@@ -59,7 +60,7 @@ fn spawn_test_ghost(world: &mut World) -> Entity {
 fn spawn_test_ghost_at_node(world: &mut World, node: usize) -> Entity {
     world
         .spawn((
-            Position::Stopped { node },
+            Position::Stopped { node: node as NodeId },
             Collider { size: 12.0 },
             GhostCollider,
             Ghost::Blinky,

tests/direction.rs

@@ -1,4 +1,4 @@
-use glam::IVec2;
+use glam::I8Vec2;
 use pacman::map::direction::*;
 
 #[test]
@@ -18,14 +18,14 @@ fn test_direction_opposite() {
 #[test]
 fn test_direction_as_ivec2() {
     let test_cases = [
-        (Direction::Up, -IVec2::Y),
-        (Direction::Down, IVec2::Y),
-        (Direction::Left, -IVec2::X),
-        (Direction::Right, IVec2::X),
+        (Direction::Up, -I8Vec2::Y),
+        (Direction::Down, I8Vec2::Y),
+        (Direction::Left, -I8Vec2::X),
+        (Direction::Right, I8Vec2::X),
     ];
 
     for (dir, expected) in test_cases {
         assert_eq!(dir.as_ivec2(), expected);
-        assert_eq!(IVec2::from(dir), expected);
+        assert_eq!(I8Vec2::from(dir), expected);
     }
 }

tests/formatting.rs

@@ -1,4 +1,4 @@
-use pacman::systems::formatting::format_timing_display;
+use pacman::systems::profiling::format_timing_display;
 use std::time::Duration;
 
 use pretty_assertions::assert_eq;

tests/map_builder.rs

@@ -26,8 +26,10 @@ fn test_map_node_positions() {
 
     for (grid_pos, &node_id) in &map.grid_to_node {
         let node = map.graph.get_node(node_id).unwrap();
-        let expected_pos = Vec2::new((grid_pos.x * CELL_SIZE as i32) as f32, (grid_pos.y * CELL_SIZE as i32) as f32)
-            + Vec2::splat(CELL_SIZE as f32 / 2.0);
+        let expected_pos = Vec2::new(
+            (grid_pos.x as i32 * CELL_SIZE as i32) as f32,
+            (grid_pos.y as i32 * CELL_SIZE as i32) as f32,
+        ) + Vec2::splat(CELL_SIZE as f32 / 2.0);
 
         assert_eq!(node.position, expected_pos);
     }

tests/player.rs

@@ -9,7 +9,7 @@ use pacman::{
     },
     systems::{
         can_traverse, player_control_system, player_movement_system, AudioState, BufferedDirection, DebugState, DeltaTime,
-        EntityType, GlobalState, PlayerControlled, Position, Velocity,
+        EntityType, GlobalState, MovementModifiers, PlayerControlled, Position, Velocity,
     },
 };
 
@@ -49,6 +49,7 @@ fn spawn_test_player(world: &mut World) -> Entity {
             },
             BufferedDirection::None,
             EntityType::Player,
+            MovementModifiers::default(),
         ))
         .id()
 }

tests/profiling.rs

@@ -5,21 +5,41 @@ use std::time::Duration;
 fn test_timing_statistics() {
     let timings = SystemTimings::default();
 
-    // Add some test data
+    // 10ms average, 2ms std dev
     timings.add_timing(SystemId::PlayerControls, Duration::from_millis(10));
     timings.add_timing(SystemId::PlayerControls, Duration::from_millis(12));
     timings.add_timing(SystemId::PlayerControls, Duration::from_millis(8));
 
+    // 2ms average, 1ms std dev
+    timings.add_timing(SystemId::Blinking, Duration::from_millis(3));
+    timings.add_timing(SystemId::Blinking, Duration::from_millis(2));
+    timings.add_timing(SystemId::Blinking, Duration::from_millis(1));
+    fn close_enough(a: Duration, b: Duration) -> bool {
+        if a > b {
+            a - b < Duration::from_micros(500) // 0.1ms
+        } else {
+            b - a < Duration::from_micros(500)
+        }
+    }
+
     let stats = timings.get_stats();
     let (avg, std_dev) = stats.get(&SystemId::PlayerControls).unwrap();
 
     // Average should be 10ms, standard deviation should be small
-    assert!((avg.as_millis() as f64 - 10.0).abs() < 1.0);
-    assert!(std_dev.as_millis() > 0);
+    assert!(close_enough(*avg, Duration::from_millis(10)), "avg: {:?}", avg);
+    assert!(close_enough(*std_dev, Duration::from_millis(2)), "std_dev: {:?}", std_dev);
 
     let (total_avg, total_std) = timings.get_total_stats();
-    assert!((total_avg.as_millis() as f64 - 10.0).abs() < 1.0);
-    assert!(total_std.as_millis() > 0);
+    assert!(
+        close_enough(total_avg, Duration::from_millis(18)),
+        "total_avg: {:?}",
+        total_avg
+    );
+    assert!(
+        close_enough(total_std, Duration::from_millis(12)),
+        "total_std: {:?}",
+        total_std
+    );
 }
 
 // #[test]

tests/sprite.rs

@@ -13,10 +13,8 @@ fn test_sprite_atlas_basic() {
     frames.insert(
         "test".to_string(),
         MapperFrame {
-            x: 10,
-            y: 20,
-            width: 32,
-            height: 64,
+            pos: U16Vec2::new(10, 20),
+            size: U16Vec2::new(32, 64),
         },
     );
 
@@ -38,19 +36,15 @@ fn test_sprite_atlas_multiple_tiles() {
     frames.insert(
         "tile1".to_string(),
         MapperFrame {
-            x: 0,
-            y: 0,
-            width: 32,
-            height: 32,
+            pos: U16Vec2::new(0, 0),
+            size: U16Vec2::new(32, 32),
         },
     );
     frames.insert(
         "tile2".to_string(),
         MapperFrame {
-            x: 32,
-            y: 0,
-            width: 64,
-            height: 64,
+            pos: U16Vec2::new(32, 0),
+            size: U16Vec2::new(64, 64),
         },
     );