fix: use c-style strings instead of manual termination, cast pointer, use then_some

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",
@@ -620,7 +618,8 @@ dependencies = [
  "tracing",
  "tracing-error",
  "tracing-subscriber",
- "winapi",
+ "windows",
+ "windows-sys",
 ]
 
 [[package]]
@@ -1306,6 +1305,108 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
+[[package]]
+name = "windows"
+version = "0.61.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9babd3a767a4c1aef6900409f85f5d53ce2544ccdfaa86dad48c91782c6d6893"
+dependencies = [
+ "windows-collections",
+ "windows-core",
+ "windows-future",
+ "windows-link",
+ "windows-numerics",
+]
+
+[[package]]
+name = "windows-collections"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3beeceb5e5cfd9eb1d76b381630e82c4241ccd0d27f1a39ed41b2760b255c5e8"
+dependencies = [
+ "windows-core",
+]
+
+[[package]]
+name = "windows-core"
+version = "0.61.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0fdd3ddb90610c7638aa2b3a3ab2904fb9e5cdbecc643ddb3647212781c4ae3"
+dependencies = [
+ "windows-implement",
+ "windows-interface",
+ "windows-link",
+ "windows-result",
+ "windows-strings",
+]
+
+[[package]]
+name = "windows-future"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc6a41e98427b19fe4b73c550f060b59fa592d7d686537eebf9385621bfbad8e"
+dependencies = [
+ "windows-core",
+ "windows-link",
+ "windows-threading",
+]
+
+[[package]]
+name = "windows-implement"
+version = "0.60.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a47fddd13af08290e67f4acabf4b459f647552718f683a7b415d290ac744a836"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "windows-interface"
+version = "0.59.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bd9211b69f8dcdfa817bfd14bf1c97c9188afa36f4750130fcdf3f400eca9fa8"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "windows-link"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e6ad25900d524eaabdbbb96d20b4311e1e7ae1699af4fb28c17ae66c80d798a"
+
+[[package]]
+name = "windows-numerics"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9150af68066c4c5c07ddc0ce30421554771e528bde427614c61038bc2c92c2b1"
+dependencies = [
+ "windows-core",
+ "windows-link",
+]
+
+[[package]]
+name = "windows-result"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56f42bd332cc6c8eac5af113fc0c1fd6a8fd2aa08a0119358686e5160d0586c6"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "windows-strings"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56e6c93f3a0c3b36176cb1327a4958a0353d5d166c2a35cb268ace15e91d3b57"
+dependencies = [
+ "windows-link",
+]
+
 [[package]]
 name = "windows-sys"
 version = "0.60.2"
@@ -1347,6 +1448,15 @@ dependencies = [
  "windows_x86_64_msvc 0.53.0",
 ]
 
+[[package]]
+name = "windows-threading"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b66463ad2e0ea3bbf808b7f1d371311c80e115c0b71d60efc142cafbcfb057a6"
+dependencies = [
+ "windows-link",
+]
+
 [[package]]
 name = "windows_aarch64_gnullvm"
 version = "0.52.6"

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"
@@ -38,9 +35,12 @@ lto = true
 panic = "abort"
 opt-level = "z"
 
-[target.'cfg(target_os = "windows")'.dependencies.winapi]
+[target.'cfg(target_os = "windows")'.dependencies]
-version = "0.3"
+windows = { version = "0.61.3", features = ["Win32_Security", "Win32_Storage_FileSystem", "Win32_System_Console"] }
-features = ["consoleapi", "fileapi", "handleapi", "processenv", "winbase", "wincon", "winnt", "winuser", "windef", "minwindef"]
+windows-sys = { version = "0.60.2", features = ["Win32_System_Console"] }
+
+[target.'cfg(not(target_os = "windows"))'.dependencies]
+libc = "0.2"
 
 
 [target.'cfg(target_os = "emscripten")'.dependencies.sdl2]
@@ -71,3 +71,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!(
+        writeln!(&mut file, "    \"{}\" => {},", name, frame.to_u16vec2_format()).unwrap();
-            &mut file,
-            "    \"{}\" => MapperFrame {{ x: {}, y: {}, width: {}, height: {} }},",
-            name, frame.x, frame.y, frame.width, frame.height
-        )
-        .unwrap();
     }
 
     writeln!(&mut file, "}};").unwrap();

src/app.rs

@@ -25,8 +25,8 @@ pub struct App {
 impl App {
     /// Initializes SDL subsystems, creates the game window, and sets up the game state.
     ///
-    /// Performs comprehensive initialization including video/audio subsystems, platform-specific
+    /// Performs comprehensive initialization including video/audio subsystems,
-    /// console setup, window creation with proper scaling, and canvas configuration. All SDL
+    /// window creation with proper scaling, and canvas configuration. All SDL
     /// resources are leaked to maintain 'static lifetimes required by the game architecture.
     ///
     /// # Errors
@@ -44,9 +44,6 @@ impl App {
         let event_pump: &'static mut EventPump =
             Box::leak(Box::new(sdl_context.event_pump().map_err(|e| GameError::Sdl(e.to_string()))?));
 
-        // Initialize platform-specific console
-        get_platform().init_console()?;
-
         let window = video_subsystem
             .window(
                 "Pac-Man",
@@ -96,31 +93,6 @@ impl App {
         {
             let start = Instant::now();
 
-            // for event in self
-            //     .game
-            //     .world
-            //     .get_non_send_resource_mut::<&'static mut EventPump>()
-            //     .unwrap()
-            //     .poll_iter()
-            // {
-            //     match event {
-            //         Event::Window { win_event, .. } => match win_event {
-            //             WindowEvent::FocusGained => {
-            //                 self.focused = true;
-            //             }
-            //             WindowEvent::FocusLost => {
-            //                 self.focused = false;
-            //             }
-            //             _ => {}
-            //         },
-            //         Event::MouseMotion { x, y, .. } => {
-            //             // Convert window coordinates to logical coordinates
-            //             self.cursor_pos = Vec2::new(x as f32, y as f32);
-            //         }
-            //         _ => {}
-            //     }
-            // }
-
             let dt = self.last_tick.elapsed().as_secs_f32();
             self.last_tick = Instant::now();
 

src/constants.rs

@@ -33,14 +33,12 @@ pub const BOARD_PIXEL_OFFSET: UVec2 = UVec2::new(BOARD_CELL_OFFSET.x * CELL_SIZE
 
 /// Animation timing constants for ghost state management
 pub mod animation {
-    /// Normal ghost movement animation speed (frames per second)
+    /// Normal ghost movement animation speed (ticks per frame at 60 ticks/sec)
-    pub const GHOST_NORMAL_SPEED: f32 = 0.2;
+    pub const GHOST_NORMAL_SPEED: u16 = 12;
-    /// Eaten ghost (eyes) animation speed (frames per second)
+    /// Eaten ghost (eyes) animation speed (ticks per frame at 60 ticks/sec)
-    pub const GHOST_EATEN_SPEED: f32 = 0.1;
+    pub const GHOST_EATEN_SPEED: u16 = 6;
-    /// Frightened ghost animation speed (frames per second)
+    /// Frightened ghost animation speed (ticks per frame at 60 ticks/sec)
-    pub const GHOST_FRIGHTENED_SPEED: f32 = 0.2;
+    pub const GHOST_FRIGHTENED_SPEED: u16 = 12;
-    /// 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;
@@ -51,6 +49,26 @@ pub const CANVAS_SIZE: UVec2 = UVec2::new(
     (BOARD_CELL_SIZE.y + BOARD_CELL_OFFSET.y) * CELL_SIZE,
 );
 
+/// Collider size constants for different entity types
+pub mod collider {
+    use super::CELL_SIZE;
+
+    /// Collider size for player and ghosts (1.375x cell size)
+    pub const PLAYER_GHOST_SIZE: f32 = CELL_SIZE as f32 * 1.375;
+    /// Collider size for pellets (0.4x cell size)
+    pub const PELLET_SIZE: f32 = CELL_SIZE as f32 * 0.4;
+    /// Collider size for power pellets/energizers (0.95x cell size)
+    pub const POWER_PELLET_SIZE: f32 = CELL_SIZE as f32 * 0.95;
+}
+
+/// UI and rendering constants
+pub mod ui {
+    /// Debug font size in points
+    pub const DEBUG_FONT_SIZE: u16 = 12;
+    /// Power pellet blink rate in seconds
+    pub const POWER_PELLET_BLINK_RATE: f32 = 0.2;
+}
+
 /// Map tile types that define gameplay behavior and collision properties.
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub enum MapTile {
@@ -102,3 +120,17 @@ pub const RAW_BOARD: [&str; BOARD_CELL_SIZE.y as usize] = [
     "#..........................#",
     "############################",
 ];
+
+/// Game initialization constants
+pub mod startup {
+    /// Number of frames for the startup sequence (3 seconds at 60 FPS)
+    pub const STARTUP_FRAMES: u32 = 60 * 3;
+    /// Number of ticks per frame during startup
+    pub const STARTUP_TICKS_PER_FRAME: u32 = 60;
+}
+
+/// Game mechanics constants
+pub mod mechanics {
+    /// Player movement speed multiplier
+    pub const PLAYER_SPEED: f32 = 1.15;
+}

src/error.rs

@@ -78,9 +78,6 @@ pub enum ParseError {
 /// Errors related to texture operations.
 #[derive(thiserror::Error, Debug)]
 pub enum TextureError {
-    #[error("Animated texture error: {0}")]
-    Animated(#[from] AnimatedTextureError),
-
     #[error("Failed to load texture: {0}")]
     LoadFailed(String),
 
@@ -94,12 +91,6 @@ pub enum TextureError {
     RenderFailed(String),
 }
 
-#[derive(thiserror::Error, Debug)]
-pub enum AnimatedTextureError {
-    #[error("Frame duration must be positive, got {0}")]
-    InvalidFrameDuration(f32),
-}
-
 /// Errors related to entity operations.
 #[derive(thiserror::Error, Debug)]
 pub enum EntityError {

src/game.rs

@@ -2,25 +2,28 @@
 
 include!(concat!(env!("OUT_DIR"), "/atlas_data.rs"));
 
-use crate::constants::{animation, MapTile, CANVAS_SIZE};
+use std::collections::HashMap;
+
+use crate::constants::{self, 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::components::{GhostAnimation, GhostState, LastAnimationState};
 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};
+use crate::systems::{self, ghost_collision_system, present_system, Hidden, LinearAnimation, MovementModifiers, NodeId};
 use crate::systems::{
     audio_system, blinking_system, collision_system, debug_render_system, directional_render_system, dirty_render_system,
-    eaten_ghost_system, ghost_movement_system, ghost_state_animation_system, hud_render_system, item_system, profile,
+    eaten_ghost_system, ghost_movement_system, ghost_state_system, hud_render_system, item_system, linear_render_system, profile,
     render_system, AudioEvent, AudioResource, AudioState, BackbufferResource, Collider, DebugFontResource, DebugState,
-    DebugTextureResource, DeltaTime, DirectionalAnimated, EntityType, Frozen, Ghost, GhostAnimationSet, GhostAnimations,
+    DebugTextureResource, DeltaTime, DirectionalAnimation, EntityType, Frozen, Ghost, GhostAnimations, GhostBundle,
-    GhostBundle, GhostCollider, GlobalState, ItemBundle, ItemCollider, MapTextureResource, PacmanCollider, PlayerBundle,
+    GhostCollider, GlobalState, ItemBundle, ItemCollider, MapTextureResource, PacmanCollider, PlayerBundle, PlayerControlled,
-    PlayerControlled, Renderable, ScoreResource, StartupSequence, SystemTimings,
+    Renderable, ScoreResource, StartupSequence, SystemTimings,
 };
-use crate::texture::animated::AnimatedTexture;
+use crate::texture::animated::{DirectionalTiles, TileSequence};
 use crate::texture::sprite::AtlasTile;
 use bevy_ecs::event::EventRegistry;
 use bevy_ecs::observer::Trigger;
@@ -33,11 +36,9 @@ 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},
-    constants,
     events::GameCommand,
     map::render::MapRenderer,
     systems::input::{Bindings, CursorPosition},
@@ -109,7 +110,7 @@ impl Game {
         let static_font_data: &'static [u8] = Box::leak(font_data.to_vec().into_boxed_slice());
         let font_asset = RWops::from_bytes(static_font_data).map_err(|_| GameError::Sdl("Failed to load font".to_string()))?;
         let debug_font = ttf_context
-            .load_font_from_rwops(font_asset, 12)
+            .load_font_from_rwops(font_asset, constants::ui::DEBUG_FONT_SIZE)
             .map_err(|e| GameError::Sdl(e.to_string()))?;
 
         // Initialize audio system
@@ -150,30 +151,61 @@ impl Game {
         let map = Map::new(constants::RAW_BOARD)?;
 
         // Create directional animated textures for Pac-Man
-        let mut textures = [None, None, None, None];
+        let up_moving_tiles = [
-        let mut stopped_textures = [None, None, None, None];
+            SpriteAtlas::get_tile(&atlas, "pacman/up_a.png")
-        for direction in Direction::DIRECTIONS {
+                .ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/up_a.png".to_string())))?,
-            let moving_prefix = match direction {
+            SpriteAtlas::get_tile(&atlas, "pacman/up_b.png")
-                Direction::Up => "pacman/up",
+                .ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/up_b.png".to_string())))?,
-                Direction::Down => "pacman/down",
+            SpriteAtlas::get_tile(&atlas, "pacman/full.png")
-                Direction::Left => "pacman/left",
+                .ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/full.png".to_string())))?,
-                Direction::Right => "pacman/right",
+        ];
-            };
+        let down_moving_tiles = [
-            let moving_tiles = smallvec![
+            SpriteAtlas::get_tile(&atlas, "pacman/down_a.png")
-                SpriteAtlas::get_tile(&atlas, &format!("{moving_prefix}_a.png"))
+                .ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/down_a.png".to_string())))?,
-                    .ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound(format!("{moving_prefix}_a.png"))))?,
+            SpriteAtlas::get_tile(&atlas, "pacman/down_b.png")
-                SpriteAtlas::get_tile(&atlas, &format!("{moving_prefix}_b.png"))
+                .ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/down_b.png".to_string())))?,
-                    .ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound(format!("{moving_prefix}_b.png"))))?,
+            SpriteAtlas::get_tile(&atlas, "pacman/full.png")
-                SpriteAtlas::get_tile(&atlas, "pacman/full.png")
+                .ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/full.png".to_string())))?,
-                    .ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/full.png".to_string())))?,
+        ];
-            ];
+        let left_moving_tiles = [
+            SpriteAtlas::get_tile(&atlas, "pacman/left_a.png")
+                .ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/left_a.png".to_string())))?,
+            SpriteAtlas::get_tile(&atlas, "pacman/left_b.png")
+                .ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/left_b.png".to_string())))?,
+            SpriteAtlas::get_tile(&atlas, "pacman/full.png")
+                .ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/full.png".to_string())))?,
+        ];
+        let right_moving_tiles = [
+            SpriteAtlas::get_tile(&atlas, "pacman/right_a.png")
+                .ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/right_a.png".to_string())))?,
+            SpriteAtlas::get_tile(&atlas, "pacman/right_b.png")
+                .ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/right_b.png".to_string())))?,
+            SpriteAtlas::get_tile(&atlas, "pacman/full.png")
+                .ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/full.png".to_string())))?,
+        ];
 
-            let stopped_tiles = smallvec![SpriteAtlas::get_tile(&atlas, &format!("{moving_prefix}_b.png"))
+        let moving_tiles = DirectionalTiles::new(
-                .ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound(format!("{moving_prefix}_b.png"))))?];
+            TileSequence::new(&up_moving_tiles),
+            TileSequence::new(&down_moving_tiles),
+            TileSequence::new(&left_moving_tiles),
+            TileSequence::new(&right_moving_tiles),
+        );
 
-            textures[direction.as_usize()] = Some(AnimatedTexture::new(moving_tiles, 0.08)?);
+        let up_stopped_tile = SpriteAtlas::get_tile(&atlas, "pacman/up_b.png")
-            stopped_textures[direction.as_usize()] = Some(AnimatedTexture::new(stopped_tiles, 0.1)?);
+            .ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/up_b.png".to_string())))?;
-        }
+        let down_stopped_tile = SpriteAtlas::get_tile(&atlas, "pacman/down_b.png")
+            .ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/down_b.png".to_string())))?;
+        let left_stopped_tile = SpriteAtlas::get_tile(&atlas, "pacman/left_b.png")
+            .ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/left_b.png".to_string())))?;
+        let right_stopped_tile = SpriteAtlas::get_tile(&atlas, "pacman/right_b.png")
+            .ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/right_b.png".to_string())))?;
+
+        let stopped_tiles = DirectionalTiles::new(
+            TileSequence::new(&[up_stopped_tile]),
+            TileSequence::new(&[down_stopped_tile]),
+            TileSequence::new(&[left_stopped_tile]),
+            TileSequence::new(&[right_stopped_tile]),
+        );
 
         let player = PlayerBundle {
             player: PlayerControlled,
@@ -181,7 +213,7 @@ impl Game {
                 node: map.start_positions.pacman,
             },
             velocity: Velocity {
-                speed: 1.15,
+                speed: constants::mechanics::PLAYER_SPEED,
                 direction: Direction::Left,
             },
             movement_modifiers: MovementModifiers::default(),
@@ -191,13 +223,10 @@ impl Game {
                     .ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/full.png".to_string())))?,
                 layer: 0,
             },
-            directional_animated: DirectionalAnimated {
+            directional_animation: DirectionalAnimation::new(moving_tiles, stopped_tiles, 5),
-                textures,
-                stopped_textures,
-            },
             entity_type: EntityType::Player,
             collider: Collider {
-                size: constants::CELL_SIZE as f32 * 1.375,
+                size: constants::collider::PLAYER_GHOST_SIZE,
             },
             pacman_collider: PacmanCollider,
         };
@@ -220,7 +249,10 @@ impl Game {
         world.insert_resource(DebugState::default());
         world.insert_resource(AudioState::default());
         world.insert_resource(CursorPosition::default());
-        world.insert_resource(StartupSequence::new(60 * 3, 60));
+        world.insert_resource(StartupSequence::new(
+            constants::startup::STARTUP_FRAMES,
+            constants::startup::STARTUP_TICKS_PER_FRAME,
+        ));
 
         world.insert_non_send_resource(atlas);
         world.insert_non_send_resource(event_pump);
@@ -247,17 +279,18 @@ impl Game {
         let ghost_movement_system = profile(SystemId::Ghost, ghost_movement_system);
         let collision_system = profile(SystemId::Collision, collision_system);
         let ghost_collision_system = profile(SystemId::GhostCollision, ghost_collision_system);
-        let vulnerable_tick_system = profile(SystemId::Ghost, systems::vulnerable_tick_system);
+
         let item_system = profile(SystemId::Item, item_system);
         let audio_system = profile(SystemId::Audio, audio_system);
         let blinking_system = profile(SystemId::Blinking, blinking_system);
         let directional_render_system = profile(SystemId::DirectionalRender, directional_render_system);
+        let linear_render_system = profile(SystemId::LinearRender, linear_render_system);
         let dirty_render_system = profile(SystemId::DirtyRender, dirty_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 unified_ghost_state_system = profile(SystemId::GhostStateAnimation, ghost_state_system);
 
         let forced_dirty_system = |mut dirty: ResMut<RenderDirty>| {
             dirty.0 = true;
@@ -275,13 +308,13 @@ impl Game {
             player_tunnel_slowdown_system,
             ghost_movement_system,
             profile(SystemId::EatenGhost, eaten_ghost_system),
-            vulnerable_tick_system,
+            unified_ghost_state_system,
-            ghost_state_animation_system,
             (collision_system, ghost_collision_system, item_system).chain(),
             audio_system,
             blinking_system,
             (
                 directional_render_system,
+                linear_render_system,
                 dirty_render_system,
                 render_system,
                 hud_render_system,
@@ -303,16 +336,16 @@ impl Game {
             .ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("maze/energizer.png".to_string())))?;
 
         // Build a list of item entities to spawn from the map
-        let nodes: Vec<(usize, EntityType, AtlasTile, f32)> = world
+        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::Pellet => Some((*id, EntityType::Pellet, pellet_sprite, constants::collider::PELLET_SIZE)),
                 MapTile::PowerPellet => Some((
                     *id,
                     EntityType::PowerPellet,
                     energizer_sprite,
-                    constants::CELL_SIZE as f32 * 0.95,
+                    constants::collider::POWER_PELLET_SIZE,
                 )),
                 _ => None,
             })
@@ -330,7 +363,7 @@ impl Game {
 
             // Make power pellets blink
             if item_type == EntityType::PowerPellet {
-                item.insert((Frozen, Blinking::new(0.2)));
+                item.insert((Frozen, Blinking::new(constants::ui::POWER_PELLET_BLINK_RATE)));
             }
         }
 
@@ -358,7 +391,7 @@ 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 animations = *world.resource::<GhostAnimations>().get_normal(&ghost_type).unwrap();
                 let atlas = world.non_send_resource::<SpriteAtlas>();
 
                 GhostBundle {
@@ -379,12 +412,14 @@ impl Game {
                         )?,
                         layer: 0,
                     },
-                    directional_animated: animations.normal().unwrap().clone(),
+                    directional_animation: animations,
                     entity_type: EntityType::Ghost,
                     collider: Collider {
-                        size: crate::constants::CELL_SIZE as f32 * 1.375,
+                        size: constants::collider::PLAYER_GHOST_SIZE,
                     },
                     ghost_collider: GhostCollider,
+                    ghost_state: GhostState::Normal,
+                    last_animation_state: LastAnimationState(GhostAnimation::Normal),
                 }
             };
 
@@ -395,103 +430,144 @@ impl Game {
     }
 
     fn create_ghost_animations(atlas: &SpriteAtlas) -> GameResult<GhostAnimations> {
-        let mut animations = std::collections::HashMap::new();
+        // Eaten (eyes) animations - single tile per direction
+        let up_eye = atlas
+            .get_tile("ghost/eyes/up.png")
+            .ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("ghost/eyes/up.png".to_string())))?;
+        let down_eye = atlas
+            .get_tile("ghost/eyes/down.png")
+            .ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("ghost/eyes/down.png".to_string())))?;
+        let left_eye = atlas
+            .get_tile("ghost/eyes/left.png")
+            .ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("ghost/eyes/left.png".to_string())))?;
+        let right_eye = atlas
+            .get_tile("ghost/eyes/right.png")
+            .ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("ghost/eyes/right.png".to_string())))?;
+
+        let eyes_tiles = DirectionalTiles::new(
+            TileSequence::new(&[up_eye]),
+            TileSequence::new(&[down_eye]),
+            TileSequence::new(&[left_eye]),
+            TileSequence::new(&[right_eye]),
+        );
+        let eyes = DirectionalAnimation::new(eyes_tiles, eyes_tiles, animation::GHOST_EATEN_SPEED);
+
+        let mut animations = HashMap::new();
 
         for ghost_type in [Ghost::Blinky, Ghost::Pinky, Ghost::Inky, Ghost::Clyde] {
-            // Normal animations
+            // Normal animations - create directional tiles for each direction
-            let mut normal_textures = [None, None, None, None];
+            let up_tiles = [
-            for direction in Direction::DIRECTIONS {
+                atlas
-                let dir_str = direction.as_ref();
+                    .get_tile(&format!("ghost/{}/up_a.png", ghost_type.as_str()))
-                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/{}/up_a.png",
-                            ghost_type.as_str(),
+                            ghost_type.as_str()
-                            dir_str
                         )))
-                    })?;
+                    })?,
-                let tile_b = atlas
+                atlas
-                    .get_tile(&format!("ghost/{}/{}_b.png", ghost_type.as_str(), dir_str))
+                    .get_tile(&format!("ghost/{}/up_b.png", ghost_type.as_str()))
                     .ok_or_else(|| {
                         GameError::Texture(TextureError::AtlasTileNotFound(format!(
-                            "ghost/{}/{}_b.png",
+                            "ghost/{}/up_b.png",
-                            ghost_type.as_str(),
+                            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 down_tiles = [
-            }
+                atlas
-            let normal = DirectionalAnimated {
+                    .get_tile(&format!("ghost/{}/down_a.png", ghost_type.as_str()))
-                textures: normal_textures.clone(),
+                    .ok_or_else(|| {
-                stopped_textures: normal_textures,
+                        GameError::Texture(TextureError::AtlasTileNotFound(format!(
-            };
+                            "ghost/{}/down_a.png",
+                            ghost_type.as_str()
+                        )))
+                    })?,
+                atlas
+                    .get_tile(&format!("ghost/{}/down_b.png", ghost_type.as_str()))
+                    .ok_or_else(|| {
+                        GameError::Texture(TextureError::AtlasTileNotFound(format!(
+                            "ghost/{}/down_b.png",
+                            ghost_type.as_str()
+                        )))
+                    })?,
+            ];
+            let left_tiles = [
+                atlas
+                    .get_tile(&format!("ghost/{}/left_a.png", ghost_type.as_str()))
+                    .ok_or_else(|| {
+                        GameError::Texture(TextureError::AtlasTileNotFound(format!(
+                            "ghost/{}/left_a.png",
+                            ghost_type.as_str()
+                        )))
+                    })?,
+                atlas
+                    .get_tile(&format!("ghost/{}/left_b.png", ghost_type.as_str()))
+                    .ok_or_else(|| {
+                        GameError::Texture(TextureError::AtlasTileNotFound(format!(
+                            "ghost/{}/left_b.png",
+                            ghost_type.as_str()
+                        )))
+                    })?,
+            ];
+            let right_tiles = [
+                atlas
+                    .get_tile(&format!("ghost/{}/right_a.png", ghost_type.as_str()))
+                    .ok_or_else(|| {
+                        GameError::Texture(TextureError::AtlasTileNotFound(format!(
+                            "ghost/{}/right_a.png",
+                            ghost_type.as_str()
+                        )))
+                    })?,
+                atlas
+                    .get_tile(&format!("ghost/{}/right_b.png", ghost_type.as_str()))
+                    .ok_or_else(|| {
+                        GameError::Texture(TextureError::AtlasTileNotFound(format!(
+                            "ghost/{}/right_b.png",
+                            ghost_type.as_str()
+                        )))
+                    })?,
+            ];
 
-            // Eaten (eyes) animations
+            let normal_moving = DirectionalTiles::new(
-            let mut eaten_textures = [None, None, None, None];
+                TileSequence::new(&up_tiles),
-            for direction in Direction::DIRECTIONS {
+                TileSequence::new(&down_tiles),
-                let dir_str = direction.as_ref();
+                TileSequence::new(&left_tiles),
-                let tile = atlas
+                TileSequence::new(&right_tiles),
-                    .get_tile(&format!("ghost/eyes/{}.png", dir_str))
+            );
-                    .ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound(format!("ghost/eyes/{}.png", dir_str))))?;
+            let normal = DirectionalAnimation::new(normal_moving, normal_moving, animation::GHOST_NORMAL_SPEED);
-                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(
+            animations.insert(ghost_type, normal);
-                ghost_type,
+        }
-                GhostAnimationSet::new(
+
-                    normal,
+        let (frightened, frightened_flashing) = {
-                    DirectionalAnimated::default(), // Placeholder for frightened
+            // Load frightened animation tiles (same for all ghosts)
-                    DirectionalAnimated::default(), // Placeholder for frightened_flashing
+            let frightened_blue_a = atlas
-                    eaten,
+                .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())))?;
+
+            (
+                LinearAnimation::new(
+                    TileSequence::new(&[frightened_blue_a, frightened_blue_b]),
+                    animation::GHOST_NORMAL_SPEED,
                 ),
-            );
+                LinearAnimation::new(
-        }
+                    TileSequence::new(&[frightened_blue_a, frightened_white_a, frightened_blue_b, frightened_white_b]),
+                    animation::GHOST_FRIGHTENED_SPEED,
+                ),
+            )
+        };
 
-        // Frightened animations (same for all ghosts)
+        Ok(GhostAnimations::new(animations, eyes, frightened, frightened_flashing))
-        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.

src/main.rs

@@ -1,9 +1,8 @@
+// Note: This disables the console window on Windows. We manually re-attach to the parent terminal or process later on.
 #![windows_subsystem = "windows"]
 
 use crate::{app::App, constants::LOOP_TIME};
 use tracing::info;
-use tracing_error::ErrorLayer;
-use tracing_subscriber::layer::SubscriberExt;
 
 mod app;
 mod asset;
@@ -23,14 +22,22 @@ mod texture;
 /// This function initializes SDL, the window, the game state, and then enters
 /// the main game loop.
 pub fn main() {
-    // Setup tracing
+    // Setup buffered tracing subscriber that will buffer logs until console is ready
-    let subscriber = tracing_subscriber::fmt()
+    let switchable_writer = platform::tracing_buffer::setup_switchable_subscriber();
-        .with_ansi(cfg!(not(target_os = "emscripten")))
-        .with_max_level(tracing::Level::DEBUG)
-        .finish()
-        .with(ErrorLayer::default());
 
-    tracing::subscriber::set_global_default(subscriber).expect("Could not set global default");
+    // Log early to show buffering is working
+    tracing::debug!("Tracing subscriber initialized with buffering - logs will be buffered until console is ready");
+
+    // Initialize platform-specific console
+    tracing::debug!("Starting console initialization...");
+    platform::get_platform().init_console().expect("Could not initialize console");
+    tracing::debug!("Console initialization completed");
+
+    // Now that console is initialized, flush buffered logs and switch to direct output
+    tracing::debug!("Switching to direct logging mode and flushing buffer...");
+    if let Err(e) = switchable_writer.switch_to_direct_mode() {
+        tracing::warn!("Failed to flush buffered logs to console: {}", e);
+    }
 
     let mut app = App::new().expect("Could not create app");
 

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.x as i32 * CELL_SIZE as i32) as f32,
-            (start_pos.y * 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.x as i32 * CELL_SIZE as i32) as f32,
-                        (new_position.y * 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>,
+        grid_to_node: &HashMap<I8Vec2, NodeId>,
-        house_door: &[Option<IVec2>; 2],
+        house_door: &[Option<I8Vec2>; 2],
-    ) -> GameResult<(usize, usize, usize, usize)> {
+    ) -> 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>,
+        grid_to_node: &HashMap<I8Vec2, NodeId>,
-        tunnel_ends: &[Option<IVec2>; 2],
+        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,4 +1,4 @@
-use glam::IVec2;
+use glam::I8Vec2;
 use strum_macros::AsRefStr;
 
 /// The four cardinal directions.
@@ -28,8 +28,8 @@ impl Direction {
         }
     }
 
-    /// Returns the direction as an IVec2.
+    /// Returns the direction as an I8Vec2.
-    pub fn as_ivec2(self) -> IVec2 {
+    pub fn as_ivec2(self) -> I8Vec2 {
         self.into()
     }
 
@@ -45,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::Up => -I8Vec2::Y,
-            Direction::Down => IVec2::Y,
+            Direction::Down => I8Vec2::Y,
-            Direction::Left => -IVec2::X,
+            Direction::Left => -I8Vec2::X,
-            Direction::Right => IVec2::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 from_pos = self.nodes[from as usize].position;
-                    let to_pos = self.nodes[to].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/buffered_writer.rs

@@ -0,0 +1,55 @@
+//! Buffered writer for tracing logs that can store logs before console attachment.
+
+use parking_lot::Mutex;
+use std::io::{self, Write};
+use std::sync::Arc;
+
+/// A thread-safe buffered writer that stores logs in memory until flushed.
+#[derive(Clone)]
+pub struct BufferedWriter {
+    buffer: Arc<Mutex<Vec<u8>>>,
+}
+
+impl BufferedWriter {
+    /// Creates a new buffered writer.
+    pub fn new() -> Self {
+        Self {
+            buffer: Arc::new(Mutex::new(Vec::new())),
+        }
+    }
+
+    /// Flushes all buffered content to the provided writer and clears the buffer.
+    pub fn flush_to<W: Write>(&self, mut writer: W) -> io::Result<()> {
+        let mut buffer = self.buffer.lock();
+        if !buffer.is_empty() {
+            writer.write_all(&buffer)?;
+            writer.flush()?;
+            buffer.clear();
+        }
+        Ok(())
+    }
+
+    /// Returns the current buffer size in bytes.
+    pub fn buffer_size(&self) -> usize {
+        self.buffer.lock().len()
+    }
+}
+
+impl Write for BufferedWriter {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        let mut buffer = self.buffer.lock();
+        buffer.extend_from_slice(buf);
+        Ok(buf.len())
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        // For buffered writer, flush is a no-op since we're storing in memory
+        Ok(())
+    }
+}
+
+impl Default for BufferedWriter {
+    fn default() -> Self {
+        Self::new()
+    }
+}

src/platform/desktop.rs

@@ -6,6 +6,7 @@ use std::time::Duration;
 use crate::asset::Asset;
 use crate::error::{AssetError, PlatformError};
 use crate::platform::CommonPlatform;
+use tracing::{debug, info, warn};
 
 /// Desktop platform implementation.
 pub struct Platform;
@@ -24,6 +25,29 @@ impl CommonPlatform for Platform {
     }
 
     fn init_console(&self) -> Result<(), PlatformError> {
+        #[cfg(windows)]
+        {
+            use windows::Win32::System::Console::GetConsoleWindow;
+
+            // Check if we already have a console window
+            if unsafe { !GetConsoleWindow().0.is_null() } {
+                debug!("Already have a console window");
+                return Ok(());
+            } else {
+                debug!("No existing console window found");
+            }
+
+            if let Some(file_type) = Self::is_output_setup()? {
+                debug!(r#type = file_type, "Existing output detected");
+            } else {
+                debug!("No existing output detected");
+
+                // Try to attach to parent console for direct cargo run
+                Self::attach_to_parent_console()?;
+                info!("Successfully attached to parent console");
+            }
+        }
+
         Ok(())
     }
 
@@ -42,3 +66,102 @@ impl CommonPlatform for Platform {
         }
     }
 }
+
+#[cfg(windows)]
+impl Platform {
+    /// Check if the output stream has been setup by a parent process
+    fn is_output_setup() -> Result<Option<&'static str>, PlatformError> {
+        use windows::Win32::Storage::FileSystem::{
+            GetFileType, FILE_TYPE_CHAR, FILE_TYPE_DISK, FILE_TYPE_PIPE, FILE_TYPE_REMOTE, FILE_TYPE_UNKNOWN,
+        };
+
+        use windows_sys::Win32::{
+            Foundation::INVALID_HANDLE_VALUE,
+            System::Console::{GetStdHandle, STD_OUTPUT_HANDLE},
+        };
+
+        // Get the process's standard output handle, check if it's invalid
+        let handle = match unsafe { GetStdHandle(STD_OUTPUT_HANDLE) } {
+            INVALID_HANDLE_VALUE => {
+                return Err(PlatformError::ConsoleInit("Invalid handle".to_string()));
+            }
+            handle => handle,
+        };
+
+        // Identify the file type of the handle and whether it's 'well known' (i.e. we trust it to be a reasonable output destination)
+        let (well_known, file_type) = match unsafe {
+            use windows::Win32::Foundation::HANDLE;
+            GetFileType(HANDLE(handle))
+        } {
+            FILE_TYPE_PIPE => (true, "pipe"),
+            FILE_TYPE_CHAR => (true, "char"),
+            FILE_TYPE_DISK => (true, "disk"),
+            FILE_TYPE_UNKNOWN => (false, "unknown"),
+            FILE_TYPE_REMOTE => (false, "remote"),
+            unexpected => {
+                warn!("Unexpected file type: {unexpected:?}");
+                (false, "unknown")
+            }
+        };
+
+        debug!("File type: {file_type:?}, well known: {well_known}");
+
+        // If it's anything recognizable and valid, assume that a parent process has setup an output stream
+        Ok(well_known.then_some(file_type))
+    }
+
+    /// Try to attach to parent console
+    fn attach_to_parent_console() -> Result<(), PlatformError> {
+        use windows::{
+            core::PCSTR,
+            Win32::{
+                Foundation::{GENERIC_READ, GENERIC_WRITE},
+                Storage::FileSystem::{CreateFileA, FILE_FLAGS_AND_ATTRIBUTES, FILE_SHARE_READ, FILE_SHARE_WRITE, OPEN_EXISTING},
+                System::Console::{
+                    AttachConsole, FreeConsole, SetStdHandle, ATTACH_PARENT_PROCESS, STD_ERROR_HANDLE, STD_OUTPUT_HANDLE,
+                },
+            },
+        };
+
+        // Attach the process to the parent's console
+        unsafe { AttachConsole(ATTACH_PARENT_PROCESS) }
+            .map_err(|e| PlatformError::ConsoleInit(format!("Failed to attach to parent console: {:?}", e)))?;
+
+        let handle = unsafe {
+            let pcstr = PCSTR::from_raw(c"CONOUT$".as_ptr() as *const u8);
+            CreateFileA::<PCSTR>(
+                pcstr,
+                (GENERIC_READ | GENERIC_WRITE).0,
+                FILE_SHARE_READ | FILE_SHARE_WRITE,
+                None,
+                OPEN_EXISTING,
+                FILE_FLAGS_AND_ATTRIBUTES(0),
+                None,
+            )
+        }
+        .map_err(|e| PlatformError::ConsoleInit(format!("Failed to create console handle: {:?}", e)))?;
+
+        // Set the console's output and then error handles
+        if let Some(handle_error) = unsafe { SetStdHandle(STD_OUTPUT_HANDLE, handle) }
+            .map_err(|e| PlatformError::ConsoleInit(format!("Failed to set console output handle: {:?}", e)))
+            .and_then(|_| {
+                unsafe { SetStdHandle(STD_ERROR_HANDLE, handle) }
+                    .map_err(|e| PlatformError::ConsoleInit(format!("Failed to set console error handle: {:?}", e)))
+            })
+            .err()
+        {
+            // If either set handle call fails, free the console
+            unsafe { FreeConsole() }
+                // Free the console if the SetStdHandle calls fail
+                .map_err(|free_error| {
+                    PlatformError::ConsoleInit(format!(
+                        "Failed to free console after SetStdHandle failed: {free_error:?} ({handle_error:?})"
+                    ))
+                })
+                // And then return the original error if the FreeConsole call succeeds
+                .and(Err(handle_error))?;
+        }
+
+        Ok(())
+    }
+}

src/platform/mod.rs

@@ -10,6 +10,9 @@ mod desktop;
 #[cfg(target_os = "emscripten")]
 mod emscripten;
 
+pub mod buffered_writer;
+pub mod tracing_buffer;
+
 /// Cross-platform abstraction layer providing unified APIs for platform-specific operations.
 pub trait CommonPlatform {
     /// Platform-specific sleep function (required due to Emscripten's non-standard sleep requirements).

src/platform/tracing_buffer.rs

@@ -0,0 +1,91 @@
+//! Buffered tracing setup for handling logs before console attachment.
+
+use crate::platform::buffered_writer::BufferedWriter;
+use std::io;
+use tracing::Level;
+use tracing_error::ErrorLayer;
+use tracing_subscriber::fmt::MakeWriter;
+use tracing_subscriber::layer::SubscriberExt;
+
+/// A writer that can switch between buffering and direct output.
+#[derive(Clone, Default)]
+pub struct SwitchableWriter {
+    buffered_writer: BufferedWriter,
+    direct_mode: std::sync::Arc<parking_lot::Mutex<bool>>,
+}
+
+impl SwitchableWriter {
+    pub fn switch_to_direct_mode(&self) -> io::Result<()> {
+        // Get buffer size before flushing for debug logging
+        let buffer_size = self.buffered_writer.buffer_size();
+
+        // First flush any buffered content
+        self.buffered_writer.flush_to(io::stdout())?;
+
+        // Switch to direct mode
+        *self.direct_mode.lock() = true;
+
+        // Log how much was buffered (this will now go directly to stdout)
+        tracing::debug!("Flushed {} bytes of buffered logs to console", buffer_size);
+
+        Ok(())
+    }
+}
+
+impl io::Write for SwitchableWriter {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        if *self.direct_mode.lock() {
+            io::stdout().write(buf)
+        } else {
+            self.buffered_writer.clone().write(buf)
+        }
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        if *self.direct_mode.lock() {
+            io::stdout().flush()
+        } else {
+            // For buffered mode, flush is a no-op
+            Ok(())
+        }
+    }
+}
+
+/// A make writer that uses the switchable writer.
+#[derive(Clone)]
+pub struct SwitchableMakeWriter {
+    writer: SwitchableWriter,
+}
+
+impl SwitchableMakeWriter {
+    pub fn new(writer: SwitchableWriter) -> Self {
+        Self { writer }
+    }
+}
+
+impl<'a> MakeWriter<'a> for SwitchableMakeWriter {
+    type Writer = SwitchableWriter;
+
+    fn make_writer(&'a self) -> Self::Writer {
+        self.writer.clone()
+    }
+}
+
+/// Sets up a switchable tracing subscriber that can transition from buffered to direct output.
+///
+/// Returns the switchable writer that can be used to control the behavior.
+pub fn setup_switchable_subscriber() -> SwitchableWriter {
+    let switchable_writer = SwitchableWriter::default();
+    let make_writer = SwitchableMakeWriter::new(switchable_writer.clone());
+
+    let _subscriber = tracing_subscriber::fmt()
+        .with_ansi(cfg!(not(target_os = "emscripten")))
+        .with_max_level(Level::DEBUG)
+        .with_writer(make_writer)
+        .finish()
+        .with(ErrorLayer::default());
+
+    tracing::subscriber::set_global_default(_subscriber).expect("Could not set global default switchable subscriber");
+
+    switchable_writer
+}

src/systems/collision.rs

@@ -2,13 +2,13 @@ use bevy_ecs::component::Component;
 use bevy_ecs::entity::Entity;
 use bevy_ecs::event::{EventReader, EventWriter};
 use bevy_ecs::query::With;
-use bevy_ecs::system::{Commands, Query, Res, ResMut};
+use bevy_ecs::system::{Query, Res, ResMut};
 
 use crate::error::GameError;
 use crate::events::GameEvent;
 use crate::map::builder::Map;
 use crate::systems::movement::Position;
-use crate::systems::{AudioEvent, Eaten, Ghost, PlayerControlled, ScoreResource, Vulnerable};
+use crate::systems::{AudioEvent, Ghost, GhostState, PlayerControlled, ScoreResource};
 
 #[derive(Component)]
 pub struct Collider {
@@ -108,12 +108,11 @@ pub fn collision_system(
 }
 
 pub fn ghost_collision_system(
-    mut commands: Commands,
     mut collision_events: EventReader<GameEvent>,
     mut score: ResMut<ScoreResource>,
     pacman_query: Query<(), With<PlayerControlled>>,
     ghost_query: Query<(Entity, &Ghost), With<GhostCollider>>,
-    vulnerable_query: Query<Entity, With<Vulnerable>>,
+    mut ghost_state_query: Query<&mut GhostState>,
     mut events: EventWriter<AudioEvent>,
 ) {
     for event in collision_events.read() {
@@ -127,23 +126,25 @@ pub fn ghost_collision_system(
                 continue;
             };
 
-            // Check if the ghost is vulnerable
+            // Check if the ghost is frightened
             if let Ok((ghost_ent, _ghost_type)) = ghost_query.get(ghost_entity) {
-                // Check if ghost has Vulnerable component
+                if let Ok(mut ghost_state) = ghost_state_query.get_mut(ghost_ent) {
-                if vulnerable_query.get(ghost_ent).is_ok() {
+                    // Check if ghost is in frightened state
-                    // Pac-Man eats the ghost
+                    if matches!(*ghost_state, GhostState::Frightened { .. }) {
-                    // Add score (200 points per ghost eaten)
+                        // Pac-Man eats the ghost
-                    score.0 += 200;
+                        // Add score (200 points per ghost eaten)
+                        score.0 += 200;
 
-                    // Remove the ghost
+                        // Set ghost state to Eyes
-                    commands.entity(ghost_ent).remove::<Vulnerable>().insert(Eaten);
+                        *ghost_state = GhostState::Eyes;
 
-                    // Play eat sound
+                        // Play eat sound
-                    events.write(AudioEvent::PlayEat);
+                        events.write(AudioEvent::PlayEat);
-                } else {
+                    } else {
-                    // Pac-Man dies (this would need a death system)
+                        // Pac-Man dies (this would need a death system)
-                    // For now, just log it
+                        // For now, just log it
-                    tracing::warn!("Pac-Man collided with ghost while not vulnerable!");
+                        tracing::warn!("Pac-Man collided with ghost while not frightened!");
+                    }
                 }
             }
         }

src/systems/components.rs

@@ -1,3 +1,5 @@
+use std::collections::HashMap;
+
 use bevy_ecs::{bundle::Bundle, component::Component, resource::Resource};
 use bitflags::bitflags;
 
@@ -7,9 +9,11 @@ use crate::{
         movement::{BufferedDirection, Position, Velocity},
         Collider, GhostCollider, ItemCollider, PacmanCollider,
     },
-    texture::{animated::AnimatedTexture, sprite::AtlasTile},
+    texture::{
+        animated::{DirectionalTiles, TileSequence},
+        sprite::AtlasTile,
+    },
 };
-use micromap::Map;
 
 /// A tag component for entities that are controlled by the player.
 #[derive(Default, Component)]
@@ -96,30 +100,46 @@ pub struct Renderable {
     pub layer: u8,
 }
 
-/// A component for entities that have a directional animated texture.
+/// Directional animation component with shared timing across all directions
-#[derive(Component, Clone, Default)]
+#[derive(Component, Clone, Copy)]
-pub struct DirectionalAnimated {
+pub struct DirectionalAnimation {
-    pub textures: [Option<AnimatedTexture>; 4],
+    pub moving_tiles: DirectionalTiles,
-    pub stopped_textures: [Option<AnimatedTexture>; 4],
+    pub stopped_tiles: DirectionalTiles,
+    pub current_frame: usize,
+    pub time_bank: u16,
+    pub frame_duration: u16,
 }
 
-impl DirectionalAnimated {
+impl DirectionalAnimation {
-    pub fn from_animation(animation: AnimatedTexture) -> Self {
+    /// Creates a new directional animation with the given tiles and frame duration
-        // Create 4 copies of the animation - necessary for independent state per direction
+    pub fn new(moving_tiles: DirectionalTiles, stopped_tiles: DirectionalTiles, frame_duration: u16) -> Self {
-        // This is initialization-time only, so the cloning cost is acceptable
         Self {
-            textures: [
+            moving_tiles,
-                Some(animation.clone()),
+            stopped_tiles,
-                Some(animation.clone()),
+            current_frame: 0,
-                Some(animation.clone()),
+            time_bank: 0,
-                Some(animation.clone()),
+            frame_duration,
-            ],
+        }
-            stopped_textures: [
+    }
-                Some(animation.clone()),
+}
-                Some(animation.clone()),
+
-                Some(animation.clone()),
+/// Linear animation component for non-directional animations (frightened ghosts)
-                Some(animation),
+#[derive(Component, Clone, Copy)]
-            ],
+pub struct LinearAnimation {
+    pub tiles: TileSequence,
+    pub current_frame: usize,
+    pub time_bank: u16,
+    pub frame_duration: u16,
+}
+
+impl LinearAnimation {
+    /// Creates a new linear animation with the given tiles and frame duration
+    pub fn new(tiles: TileSequence, frame_duration: u16) -> Self {
+        Self {
+            tiles,
+            current_frame: 0,
+            time_bank: 0,
+            frame_duration,
         }
     }
 }
@@ -170,10 +190,75 @@ pub struct Frozen;
 #[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 enum GhostState {
-    pub remaining_ticks: u32,
+    /// Normal ghost behavior - chasing Pac-Man
+    Normal,
+    /// Frightened state after power pellet - ghost can be eaten
+    Frightened {
+        remaining_ticks: u32,
+        flash: bool,
+        remaining_flash_ticks: u32,
+    },
+    /// Eyes state - ghost has been eaten and is returning to ghost house
+    Eyes,
+}
+
+/// Component to track the last animation state for efficient change detection
+#[derive(Component, Debug, Clone, Copy, PartialEq)]
+pub struct LastAnimationState(pub GhostAnimation);
+
+impl GhostState {
+    /// Creates a new frightened state with the specified duration
+    pub fn new_frightened(total_ticks: u32, flash_start_ticks: u32) -> Self {
+        Self::Frightened {
+            remaining_ticks: total_ticks,
+            flash: false,
+            remaining_flash_ticks: flash_start_ticks, // Time until flashing starts
+        }
+    }
+
+    /// Ticks the ghost state, returning true if the state changed.
+    pub fn tick(&mut self) -> bool {
+        if let GhostState::Frightened {
+            remaining_ticks,
+            flash,
+            remaining_flash_ticks,
+        } = self
+        {
+            // Transition out of frightened state
+            if *remaining_ticks == 0 {
+                *self = GhostState::Normal;
+                return true;
+            }
+
+            *remaining_ticks -= 1;
+
+            if *remaining_flash_ticks > 0 {
+                *remaining_flash_ticks = remaining_flash_ticks.saturating_sub(1);
+                if *remaining_flash_ticks == 0 {
+                    *flash = true;
+                    true
+                } else {
+                    false
+                }
+            } else {
+                false
+            }
+        } else {
+            false
+        }
+    }
+
+    /// Returns the appropriate animation state for this ghost state
+    pub fn animation_state(&self) -> GhostAnimation {
+        match self {
+            GhostState::Normal => GhostAnimation::Normal,
+            GhostState::Eyes => GhostAnimation::Eyes,
+            GhostState::Frightened { flash: false, .. } => GhostAnimation::Frightened { flash: false },
+            GhostState::Frightened { flash: true, .. } => GhostAnimation::Frightened { flash: true },
+        }
+    }
 }
 
 /// Enumeration of different ghost animation states.
@@ -189,58 +274,6 @@ pub enum GhostAnimation {
     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
@@ -248,9 +281,50 @@ impl GhostAnimationSet {
 /// 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.
+/// contains the normal directional animation for each ghost type.
 #[derive(Resource)]
-pub struct GhostAnimations(pub std::collections::HashMap<Ghost, GhostAnimationSet>);
+pub struct GhostAnimations {
+    pub normal: HashMap<Ghost, DirectionalAnimation>,
+    pub eyes: DirectionalAnimation,
+    pub frightened: LinearAnimation,
+    pub frightened_flashing: LinearAnimation,
+}
+
+impl GhostAnimations {
+    /// Creates a new GhostAnimations resource with the provided data.
+    pub fn new(
+        normal: HashMap<Ghost, DirectionalAnimation>,
+        eyes: DirectionalAnimation,
+        frightened: LinearAnimation,
+        frightened_flashing: LinearAnimation,
+    ) -> Self {
+        Self {
+            normal,
+            eyes,
+            frightened,
+            frightened_flashing,
+        }
+    }
+
+    /// Gets the normal directional animation for the specified ghost type.
+    pub fn get_normal(&self, ghost_type: &Ghost) -> Option<&DirectionalAnimation> {
+        self.normal.get(ghost_type)
+    }
+
+    /// Gets the eyes animation (shared across all ghosts).
+    pub fn eyes(&self) -> &DirectionalAnimation {
+        &self.eyes
+    }
+
+    /// Gets the frightened animations (shared across all ghosts).
+    pub fn frightened(&self, flash: bool) -> &LinearAnimation {
+        if flash {
+            &self.frightened_flashing
+        } else {
+            &self.frightened
+        }
+    }
+}
 
 #[derive(Bundle)]
 pub struct PlayerBundle {
@@ -259,7 +333,7 @@ pub struct PlayerBundle {
     pub velocity: Velocity,
     pub buffered_direction: BufferedDirection,
     pub sprite: Renderable,
-    pub directional_animated: DirectionalAnimated,
+    pub directional_animation: DirectionalAnimation,
     pub entity_type: EntityType,
     pub collider: Collider,
     pub movement_modifiers: MovementModifiers,
@@ -281,8 +355,10 @@ pub struct GhostBundle {
     pub position: Position,
     pub velocity: Velocity,
     pub sprite: Renderable,
-    pub directional_animated: DirectionalAnimated,
+    pub directional_animation: DirectionalAnimation,
     pub entity_type: EntityType,
     pub collider: Collider,
     pub ghost_collider: GhostCollider,
+    pub ghost_state: GhostState,
+    pub last_animation_state: LastAnimationState,
 }

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::{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};
@@ -185,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

src/systems/ghost.rs

@@ -1,4 +1,4 @@
-use crate::systems::components::Frozen;
+use crate::systems::components::{DirectionalAnimation, Frozen, GhostAnimation, GhostState, LastAnimationState, LinearAnimation};
 use crate::{
     map::{
         builder::Map,
@@ -11,15 +11,9 @@ use crate::{
     },
 };
 
-use bevy_ecs::{
+use crate::systems::GhostAnimations;
-    query::Added,
+use bevy_ecs::query::Without;
-    removal_detection::RemovedComponents,
+use bevy_ecs::system::{Commands, Query, Res};
-    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;
@@ -36,7 +30,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();
@@ -77,58 +71,6 @@ 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:
@@ -140,11 +82,13 @@ pub fn ghost_state_animation_system(
 pub fn eaten_ghost_system(
     map: Res<Map>,
     delta_time: Res<DeltaTime>,
-    animations: Res<GhostAnimations>,
+    mut eaten_ghosts: Query<(&Ghost, &mut Position, &mut Velocity, &mut GhostState)>,
-    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() {
+    for (ghost_type, mut position, mut velocity, mut ghost_state) in eaten_ghosts.iter_mut() {
+        // Only process ghosts that are in Eyes state
+        if !matches!(*ghost_state, GhostState::Eyes) {
+            continue;
+        }
         // 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
@@ -159,8 +103,11 @@ pub fn eaten_ghost_system(
                     velocity.direction = direction;
                     *position = Position::Moving {
                         from: current_node,
-                        to: map.graph.adjacency_list[current_node].get(direction).unwrap().target,
+                        to: map.graph.adjacency_list[current_node as usize].get(direction).unwrap().target,
-                        remaining_distance: map.graph.adjacency_list[current_node].get(direction).unwrap().distance,
+                        remaining_distance: map.graph.adjacency_list[current_node as usize]
+                            .get(direction)
+                            .unwrap()
+                            .distance,
                     };
                 }
             }
@@ -169,13 +116,8 @@ pub fn eaten_ghost_system(
                 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
+                        // Respawn the ghost - set state back to normal
-                        commands.entity(entity).remove::<Eaten>();
+                        *ghost_state = GhostState::Normal;
-                        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,
@@ -186,8 +128,8 @@ pub fn eaten_ghost_system(
                             velocity.direction = next_direction;
                             *position = Position::Moving {
                                 from: to,
-                                to: map.graph.adjacency_list[to].get(next_direction).unwrap().target,
+                                to: map.graph.adjacency_list[to as usize].get(next_direction).unwrap().target,
-                                remaining_distance: map.graph.adjacency_list[to].get(next_direction).unwrap().distance,
+                                remaining_distance: map.graph.adjacency_list[to as usize].get(next_direction).unwrap().distance,
                             };
                         }
                     }
@@ -202,7 +144,11 @@ pub fn eaten_ghost_system(
 
 /// 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: usize, target_node: usize) -> Option<Direction> {
+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;
 
@@ -224,7 +170,7 @@ fn find_direction_to_target(map: &Map, from_node: usize, target_node: usize) ->
 
     // Return first available direction towards target
     for direction in preferred_dirs {
-        if let Some(edge) = map.graph.adjacency_list[from_node].get(direction) {
+        if let Some(edge) = map.graph.adjacency_list[from_node as usize].get(direction) {
             if edge.traversal_flags.contains(TraversalFlags::GHOST) {
                 return Some(direction);
             }
@@ -233,3 +179,41 @@ fn find_direction_to_target(map: &Map, from_node: usize, target_node: usize) ->
 
     None
 }
+
+/// Unified system that manages ghost state transitions and animations with component swapping
+pub fn ghost_state_system(
+    mut commands: Commands,
+    animations: Res<GhostAnimations>,
+    mut ghosts: Query<(bevy_ecs::entity::Entity, &Ghost, &mut GhostState, &mut LastAnimationState)>,
+) {
+    for (entity, ghost_type, mut ghost_state, mut last_animation_state) in ghosts.iter_mut() {
+        // Tick the ghost state to handle internal transitions (like flashing)
+        let _ = ghost_state.tick();
+
+        // Only update animation if the animation state actually changed
+        let current_animation_state = ghost_state.animation_state();
+        if last_animation_state.0 != current_animation_state {
+            match current_animation_state {
+                GhostAnimation::Frightened { flash } => {
+                    // Remove DirectionalAnimation, add LinearAnimation
+                    commands
+                        .entity(entity)
+                        .remove::<DirectionalAnimation>()
+                        .insert(*animations.frightened(flash));
+                }
+                GhostAnimation::Normal => {
+                    // Remove LinearAnimation, add DirectionalAnimation
+                    commands
+                        .entity(entity)
+                        .remove::<LinearAnimation>()
+                        .insert(*animations.get_normal(ghost_type).unwrap());
+                }
+                GhostAnimation::Eyes => {
+                    // Remove LinearAnimation, add DirectionalAnimation (eyes animation)
+                    commands.entity(entity).remove::<LinearAnimation>().insert(*animations.eyes());
+                }
+            }
+            last_animation_state.0 = current_animation_state;
+        }
+    }
+}

src/systems/item.rs

@@ -6,8 +6,9 @@ use bevy_ecs::{
 };
 
 use crate::{
+    constants::animation::FRIGHTENED_FLASH_START_TICKS,
     events::GameEvent,
-    systems::{AudioEvent, EntityType, GhostCollider, ItemCollider, PacmanCollider, ScoreResource, Vulnerable},
+    systems::{AudioEvent, EntityType, GhostCollider, GhostState, ItemCollider, PacmanCollider, ScoreResource},
 };
 
 /// Determines if a collision between two entity types should be handled by the item system.
@@ -27,7 +28,7 @@ pub fn item_system(
     mut score: ResMut<ScoreResource>,
     pacman_query: Query<Entity, With<PacmanCollider>>,
     item_query: Query<(Entity, &EntityType), With<ItemCollider>>,
-    ghost_query: Query<Entity, With<GhostCollider>>,
+    mut ghost_query: Query<&mut GhostState, With<GhostCollider>>,
     mut events: EventWriter<AudioEvent>,
 ) {
     for event in collision_events.read() {
@@ -54,16 +55,16 @@ pub fn item_system(
                         events.write(AudioEvent::PlayEat);
                     }
 
-                    // Make ghosts vulnerable when power pellet is collected
+                    // Make ghosts frightened when power pellet is collected
                     if *entity_type == EntityType::PowerPellet {
                         // Convert seconds to frames (assumes 60 FPS)
-                        let total_ticks = 60 * 5;
+                        let total_ticks = 60 * 5; // 5 seconds total
 
-                        // Add Vulnerable component to all ghosts
+                        // Set all ghosts to frightened state, except those in Eyes state
-                        for ghost_entity in ghost_query.iter() {
+                        for mut ghost_state in ghost_query.iter_mut() {
-                            commands.entity(ghost_entity).insert(Vulnerable {
+                            if !matches!(*ghost_state, GhostState::Eyes) {
-                                remaining_ticks: total_ticks,
+                                *ghost_state = GhostState::new_frightened(total_ticks, FRIGHTENED_FLASH_START_TICKS);
-                            });
+                            }
                         }
                     }
                 }

src/systems/mod.rs

@@ -16,7 +16,6 @@ pub mod player;
 pub mod profiling;
 pub mod render;
 pub mod stage;
-pub mod vulnerable;
 
 pub use self::audio::*;
 pub use self::blinking::*;
@@ -31,4 +30,3 @@ pub use self::player::*;
 pub use self::profiling::*;
 pub use self::render::*;
 pub use self::stage::*;
-pub use self::vulnerable::*;

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 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))?;
+                let to_node = graph.get_node(*to).ok_or(EntityError::NodeNotFound(*to as usize))?;
-                let edge = graph
+                let edge = graph.find_edge(*from, *to).ok_or(EntityError::EdgeNotFound {
-                    .find_edge(*from, *to)
+                    from: *from as usize,
-                    .ok_or(EntityError::EdgeNotFound { from: *from, to: *to })?;
+                    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/profiling.rs

@@ -25,6 +25,7 @@ pub enum SystemId {
     Audio,
     Blinking,
     DirectionalRender,
+    LinearRender,
     DirtyRender,
     HudRender,
     Render,

src/systems/render.rs

@@ -2,8 +2,8 @@ use crate::constants::CANVAS_SIZE;
 use crate::error::{GameError, TextureError};
 use crate::map::builder::Map;
 use crate::systems::{
-    DebugState, DebugTextureResource, DeltaTime, DirectionalAnimated, Position, Renderable, ScoreResource, StartupSequence,
+    DebugState, DebugTextureResource, DeltaTime, DirectionalAnimation, LinearAnimation, Position, Renderable, ScoreResource,
-    Velocity,
+    StartupSequence, Velocity,
 };
 use crate::texture::sprite::SpriteAtlas;
 use crate::texture::text::TextTexture;
@@ -37,35 +37,64 @@ pub fn dirty_render_system(
     }
 }
 
-/// Updates the directional animated texture of an entity.
+/// Updates directional animated entities with synchronized timing across directions.
 ///
-/// This runs before the render system so it can update the sprite based on the current direction of travel, as well as whether the entity is moving.
+/// This runs before the render system to update sprites based on current direction and movement state.
+/// All directions share the same frame timing to ensure perfect synchronization.
 pub fn directional_render_system(
     dt: Res<DeltaTime>,
-    mut renderables: Query<(&Position, &Velocity, &mut DirectionalAnimated, &mut Renderable)>,
+    mut query: Query<(&Position, &Velocity, &mut DirectionalAnimation, &mut Renderable)>,
-    mut errors: EventWriter<GameError>,
 ) {
-    for (position, velocity, mut texture, mut renderable) in renderables.iter_mut() {
+    let ticks = (dt.0 * 60.0).round() as u16; // Convert from seconds to ticks at 60 ticks/sec
-        let stopped = matches!(position, Position::Stopped { .. });
-        let current_direction = velocity.direction;
 
-        let texture = if stopped {
+    for (position, velocity, mut anim, mut renderable) in query.iter_mut() {
-            texture.stopped_textures[current_direction.as_usize()].as_mut()
+        let stopped = matches!(position, Position::Stopped { .. });
+
+        // Only tick animation when moving to preserve stopped frame
+        if !stopped {
+            // Tick shared animation state
+            anim.time_bank += ticks;
+            while anim.time_bank >= anim.frame_duration {
+                anim.time_bank -= anim.frame_duration;
+                anim.current_frame += 1;
+            }
+        }
+
+        // Get tiles for current direction and movement state
+        let tiles = if stopped {
+            anim.stopped_tiles.get(velocity.direction)
         } else {
-            texture.textures[current_direction.as_usize()].as_mut()
+            anim.moving_tiles.get(velocity.direction)
         };
 
-        if let Some(texture) = texture {
+        if !tiles.is_empty() {
-            if !stopped {
+            let new_tile = tiles.get_tile(anim.current_frame);
-                texture.tick(dt.0);
+            if renderable.sprite != new_tile {
-            }
+                renderable.sprite = new_tile;
-            let new_tile = *texture.current_tile();
+            }
+        }
+    }
+}
+
+/// Updates linear animated entities (used for non-directional animations like frightened ghosts).
+///
+/// This system handles entities that use LinearAnimation component for simple frame cycling.
+pub fn linear_render_system(dt: Res<DeltaTime>, mut query: Query<(&mut LinearAnimation, &mut Renderable)>) {
+    let ticks = (dt.0 * 60.0).round() as u16; // Convert from seconds to ticks at 60 ticks/sec
+
+    for (mut anim, mut renderable) in query.iter_mut() {
+        // Tick animation
+        anim.time_bank += ticks;
+        while anim.time_bank >= anim.frame_duration {
+            anim.time_bank -= anim.frame_duration;
+            anim.current_frame += 1;
+        }
+
+        if !anim.tiles.is_empty() {
+            let new_tile = anim.tiles.get_tile(anim.current_frame);
             if renderable.sprite != new_tile {
                 renderable.sprite = new_tile;
             }
-        } else {
-            errors.write(TextureError::RenderFailed("Entity has no texture".to_string()).into());
-            continue;
         }
     }
 }
@@ -97,7 +126,7 @@ pub fn hud_render_system(
             errors.write(TextureError::RenderFailed(format!("Failed to render lives text: {}", e)).into());
         }
 
-        // Render score text in yellow (Pac-Man's color)
+        // 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
@@ -106,6 +135,14 @@ pub fn hud_render_system(
             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,

src/systems/vulnerable.rs

@@ -1,33 +0,0 @@
-use bevy_ecs::{
-    query::With,
-    system::{Commands, Query, Res},
-};
-
-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,
-    animations: Res<GhostAnimations>,
-    mut vulnerable_query: Query<(bevy_ecs::entity::Entity, &mut Vulnerable, &Ghost), With<GhostCollider>>,
-) {
-    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,83 +1,73 @@
-use smallvec::SmallVec;
+use crate::map::direction::Direction;
-
-use crate::error::{AnimatedTextureError, GameError, GameResult, TextureError};
 use crate::texture::sprite::AtlasTile;
 
-/// Frame-based animation system for cycling through multiple sprite tiles.
+/// Fixed-size tile sequence that avoids heap allocation
-///
+#[derive(Clone, Copy, Debug)]
-/// Manages automatic frame progression based on elapsed time.
+pub struct TileSequence {
-/// Uses a time banking system to ensure consistent animation speed regardless of frame rate variations.
+    tiles: [AtlasTile; 4], // Fixed array, max 4 frames
-#[derive(Debug, Clone)]
+    count: usize,          // Actual number of frames used
-pub struct AnimatedTexture {
-    /// Sequence of sprite tiles that make up the animation frames
-    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
-    current_frame: usize,
-    /// Accumulated time since the last frame change (for smooth timing)
-    time_bank: f32,
 }
 
-impl AnimatedTexture {
+impl TileSequence {
-    pub fn new(tiles: SmallVec<[AtlasTile; 4]>, frame_duration: f32) -> GameResult<Self> {
+    /// Creates a new tile sequence from a slice of tiles
-        if frame_duration <= 0.0 {
+    pub fn new(tiles: &[AtlasTile]) -> Self {
-            return Err(GameError::Texture(TextureError::Animated(
+        let mut tile_array = [AtlasTile {
-                AnimatedTextureError::InvalidFrameDuration(frame_duration),
+            pos: glam::U16Vec2::ZERO,
-            )));
+            size: glam::U16Vec2::ZERO,
-        }
+            color: None,
+        }; 4];
 
-        Ok(Self {
+        let count = tiles.len().min(4);
-            tiles,
+        tile_array[..count].copy_from_slice(&tiles[..count]);
-            frame_duration,
-            current_frame: 0,
-            time_bank: 0.0,
-        })
-    }
 
-    /// Advances the animation by the specified time delta with automatic frame cycling.
+        Self {
-    ///
+            tiles: tile_array,
-    /// Accumulates time in the time bank and progresses through frames when enough
+            count,
-    /// time has elapsed. Supports frame rates independent of game frame rate by
-    /// potentially advancing multiple frames in a single call if `dt` is large.
-    /// Animation loops automatically when reaching the final frame.
-    ///
-    /// # Arguments
-    ///
-    /// * `dt` - Time elapsed since the last tick (typically frame delta time)
-    pub fn tick(&mut self, dt: f32) {
-        self.time_bank += dt;
-        while self.time_bank >= self.frame_duration {
-            self.time_bank -= self.frame_duration;
-            self.current_frame = (self.current_frame + 1) % self.tiles.len();
         }
     }
 
-    pub fn current_tile(&self) -> &AtlasTile {
+    /// Returns the tile at the given frame index, wrapping if necessary
-        &self.tiles[self.current_frame]
+    pub fn get_tile(&self, frame: usize) -> AtlasTile {
+        if self.count == 0 {
+            // Return a default empty tile if no tiles
+            AtlasTile {
+                pos: glam::U16Vec2::ZERO,
+                size: glam::U16Vec2::ZERO,
+                color: None,
+            }
+        } else {
+            self.tiles[frame % self.count]
+        }
     }
 
-    /// Returns the current frame index.
+    /// Returns true if this sequence has no tiles
-    #[allow(dead_code)]
+    pub fn is_empty(&self) -> bool {
-    pub fn current_frame(&self) -> usize {
+        self.count == 0
-        self.current_frame
+    }
-    }
+}
-
+
-    /// Returns the time bank.
+/// Type-safe directional tile storage with named fields
-    #[allow(dead_code)]
+#[derive(Clone, Copy, Debug)]
-    pub fn time_bank(&self) -> f32 {
+pub struct DirectionalTiles {
-        self.time_bank
+    pub up: TileSequence,
-    }
+    pub down: TileSequence,
-
+    pub left: TileSequence,
-    /// Returns the frame duration.
+    pub right: TileSequence,
-    #[allow(dead_code)]
+}
-    pub fn frame_duration(&self) -> f32 {
+
-        self.frame_duration
+impl DirectionalTiles {
-    }
+    /// Creates a new DirectionalTiles with different sequences per direction
-
+    pub fn new(up: TileSequence, down: TileSequence, left: TileSequence, right: TileSequence) -> Self {
-    /// Returns the number of tiles in the animation.
+        Self { up, down, left, right }
-    #[allow(dead_code)]
+    }
-    pub fn tiles_len(&self) -> usize {
+
-        self.tiles.len()
+    /// Gets the tile sequence for the given direction
+    pub fn get(&self, direction: Direction) -> &TileSequence {
+        match direction {
+            Direction::Up => &self.up,
+            Direction::Down => &self.down,
+            Direction::Left => &self.left,
+            Direction::Right => &self.right,
+        }
     }
 }

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 pos: U16Vec2,
-    pub y: u16,
+    pub size: U16Vec2,
-    pub width: u16,
-    pub height: u16,
 }
 
 #[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),
+            pos: frame.pos,
-            size: U16Vec2::new(frame.width, frame.height),
+            size: frame.size,
             color: None,
         })
     }

tests/animated.rs

@@ -1,63 +1,57 @@
-use glam::U16Vec2;
+// use glam::U16Vec2;
-use pacman::error::{AnimatedTextureError, GameError, TextureError};
+// use pacman::error::{AnimatedTextureError, GameError, TextureError};
-use pacman::texture::animated::AnimatedTexture;
+// use pacman::texture::sprite::AtlasTile;
-use pacman::texture::sprite::AtlasTile;
+// use sdl2::pixels::Color;
-use sdl2::pixels::Color;
+// use smallvec::smallvec;
-use smallvec::smallvec;
 
-fn mock_atlas_tile(id: u32) -> AtlasTile {
+// fn mock_atlas_tile(id: u32) -> AtlasTile {
-    AtlasTile {
+//     AtlasTile {
-        pos: U16Vec2::new(0, 0),
+//         pos: U16Vec2::new(0, 0),
-        size: U16Vec2::new(16, 16),
+//         size: U16Vec2::new(16, 16),
-        color: Some(Color::RGB(id as u8, 0, 0)),
+//         color: Some(Color::RGB(id as u8, 0, 0)),
-    }
+//     }
-}
+// }
 
-#[test]
+// #[test]
-fn test_animated_texture_creation_errors() {
+// fn test_animated_texture_creation_errors() {
-    let tiles = smallvec![mock_atlas_tile(1), mock_atlas_tile(2)];
+//     let tiles = smallvec![mock_atlas_tile(1), mock_atlas_tile(2)];
 
-    assert!(matches!(
+//     assert!(matches!(
-        AnimatedTexture::new(tiles.clone(), 0.0).unwrap_err(),
+//         AnimatedTexture::new(tiles.clone(), 0).unwrap_err(),
-        GameError::Texture(TextureError::Animated(AnimatedTextureError::InvalidFrameDuration(0.0)))
+//         GameError::Texture(TextureError::Animated(AnimatedTextureError::InvalidFrameDuration(0)))
-    ));
+//     ));
+// }
 
-    assert!(matches!(
+// #[test]
-        AnimatedTexture::new(tiles, -0.1).unwrap_err(),
+// fn test_animated_texture_advancement() {
-        GameError::Texture(TextureError::Animated(AnimatedTextureError::InvalidFrameDuration(-0.1)))
+//     let tiles = smallvec![mock_atlas_tile(1), mock_atlas_tile(2), mock_atlas_tile(3)];
-    ));
+//     let mut texture = AnimatedTexture::new(tiles, 10).unwrap();
-}
 
-#[test]
+//     assert_eq!(texture.current_frame(), 0);
-fn test_animated_texture_advancement() {
-    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);
+//     texture.tick(25);
+//     assert_eq!(texture.current_frame(), 2);
+//     assert_eq!(texture.time_bank(), 5);
+// }
 
-    texture.tick(0.25);
+// #[test]
-    assert_eq!(texture.current_frame(), 2);
+// fn test_animated_texture_wrap_around() {
-    assert!((texture.time_bank() - 0.05).abs() < 0.001);
+//     let tiles = smallvec![mock_atlas_tile(1), mock_atlas_tile(2)];
-}
+//     let mut texture = AnimatedTexture::new(tiles, 10).unwrap();
 
-#[test]
+//     texture.tick(10);
-fn test_animated_texture_wrap_around() {
+//     assert_eq!(texture.current_frame(), 1);
-    let tiles = smallvec![mock_atlas_tile(1), mock_atlas_tile(2)];
-    let mut texture = AnimatedTexture::new(tiles, 0.1).unwrap();
 
-    texture.tick(0.1);
+//     texture.tick(10);
-    assert_eq!(texture.current_frame(), 1);
+//     assert_eq!(texture.current_frame(), 0);
+// }
 
-    texture.tick(0.1);
+// #[test]
-    assert_eq!(texture.current_frame(), 0);
+// fn test_animated_texture_single_frame() {
-}
+//     let tiles = smallvec![mock_atlas_tile(1)];
+//     let mut texture = AnimatedTexture::new(tiles, 10).unwrap();
 
-#[test]
+//     texture.tick(10);
-fn test_animated_texture_single_frame() {
+//     assert_eq!(texture.current_frame(), 0);
-    let tiles = smallvec![mock_atlas_tile(1)];
+//     assert_eq!(texture.current_tile().color.unwrap().r, 1);
-    let mut texture = AnimatedTexture::new(tiles, 0.1).unwrap();
+// }
-
-    texture.tick(0.1);
-    assert_eq!(texture.current_frame(), 0);
-    assert_eq!(texture.current_tile().color.unwrap().r, 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::Up, -I8Vec2::Y),
-        (Direction::Down, IVec2::Y),
+        (Direction::Down, I8Vec2::Y),
-        (Direction::Left, -IVec2::X),
+        (Direction::Left, -I8Vec2::X),
-        (Direction::Right, IVec2::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/error.rs

@@ -1,6 +1,5 @@
 use pacman::error::{
-    AnimatedTextureError, AssetError, EntityError, GameError, GameResult, IntoGameError, MapError, OptionExt, ParseError,
+    AssetError, EntityError, GameError, GameResult, IntoGameError, MapError, OptionExt, ParseError, ResultExt, TextureError,
-    ResultExt, TextureError,
 };
 use std::io;
 
@@ -46,13 +45,6 @@ fn test_game_error_from_io_error() {
     assert!(matches!(game_error, GameError::Io(_)));
 }
 
-#[test]
-fn test_texture_error_from_animated_error() {
-    let animated_error = AnimatedTextureError::InvalidFrameDuration(-1.0);
-    let texture_error: TextureError = animated_error.into();
-    assert!(matches!(texture_error, TextureError::Animated(_)));
-}
-
 #[test]
 fn test_asset_error_from_io_error() {
     let io_error = io::Error::new(io::ErrorKind::PermissionDenied, "Permission denied");
@@ -78,12 +70,6 @@ fn test_entity_error_display() {
     assert_eq!(error.to_string(), "Edge not found: from 1 to 2");
 }
 
-#[test]
-fn test_animated_texture_error_display() {
-    let error = AnimatedTextureError::InvalidFrameDuration(0.0);
-    assert_eq!(error.to_string(), "Frame duration must be positive, got 0");
-}
-
 #[test]
 fn test_into_game_error_trait() {
     let result: Result<i32, io::Error> = Err(io::Error::new(io::ErrorKind::Other, "test error"));
@@ -146,13 +132,3 @@ fn test_result_ext_error() {
         panic!("Expected InvalidState error");
     }
 }
-
-#[test]
-fn test_error_chain_conversions() {
-    // Test that we can convert through multiple levels
-    let animated_error = AnimatedTextureError::InvalidFrameDuration(-5.0);
-    let texture_error: TextureError = animated_error.into();
-    let game_error: GameError = texture_error.into();
-
-    assert!(matches!(game_error, GameError::Texture(TextureError::Animated(_))));
-}

tests/item.rs

@@ -4,8 +4,8 @@ use pacman::{
     events::GameEvent,
     map::builder::Map,
     systems::{
-        is_valid_item_collision, item_system, AudioEvent, AudioState, EntityType, ItemCollider, PacmanCollider, Position,
+        is_valid_item_collision, item_system, AudioEvent, AudioState, EntityType, Ghost, GhostCollider, GhostState, ItemCollider,
-        ScoreResource,
+        PacmanCollider, Position, ScoreResource,
     },
 };
 
@@ -75,6 +75,18 @@ fn spawn_test_item(world: &mut World, item_type: EntityType) -> Entity {
     world.spawn((Position::Stopped { node: 1 }, item_type, ItemCollider)).id()
 }
 
+fn spawn_test_ghost(world: &mut World, ghost_state: GhostState) -> Entity {
+    world
+        .spawn((
+            Position::Stopped { node: 2 },
+            Ghost::Blinky,
+            EntityType::Ghost,
+            GhostCollider,
+            ghost_state,
+        ))
+        .id()
+}
+
 fn send_collision_event(world: &mut World, entity1: Entity, entity2: Entity) {
     let mut events = world.resource_mut::<Events<GameEvent>>();
     events.send(GameEvent::Collision(entity1, entity2));
@@ -251,3 +263,40 @@ fn test_item_system_preserves_existing_score() {
     let score = world.resource::<ScoreResource>();
     assert_eq!(score.0, 110);
 }
+
+#[test]
+fn test_power_pellet_does_not_affect_ghosts_in_eyes_state() {
+    let mut world = create_test_world();
+    let pacman = spawn_test_pacman(&mut world);
+    let power_pellet = spawn_test_item(&mut world, EntityType::PowerPellet);
+
+    // Spawn a ghost in Eyes state (returning to ghost house)
+    let eyes_ghost = spawn_test_ghost(&mut world, GhostState::Eyes);
+
+    // Spawn a ghost in Normal state
+    let normal_ghost = spawn_test_ghost(&mut world, GhostState::Normal);
+
+    send_collision_event(&mut world, pacman, power_pellet);
+
+    world.run_system_once(item_system).expect("System should run successfully");
+
+    // Check that the power pellet was collected and score updated
+    let score = world.resource::<ScoreResource>();
+    assert_eq!(score.0, 50);
+
+    // Check that the power pellet was despawned
+    let power_pellet_count = world
+        .query::<&EntityType>()
+        .iter(&world)
+        .filter(|&entity_type| matches!(entity_type, EntityType::PowerPellet))
+        .count();
+    assert_eq!(power_pellet_count, 0);
+
+    // Check that the Eyes ghost state was not changed
+    let eyes_ghost_state = world.entity(eyes_ghost).get::<GhostState>().unwrap();
+    assert!(matches!(*eyes_ghost_state, GhostState::Eyes));
+
+    // Check that the Normal ghost state was changed to Frightened
+    let normal_ghost_state = world.entity(normal_ghost).get::<GhostState>().unwrap();
+    assert!(matches!(*normal_ghost_state, GhostState::Frightened { .. }));
+}

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)
+        let expected_pos = Vec2::new(
-            + Vec2::splat(CELL_SIZE as f32 / 2.0);
+            (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/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!(close_enough(*avg, Duration::from_millis(10)), "avg: {:?}", avg);
-    assert!(std_dev.as_millis() > 0);
+    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!(
-    assert!(total_std.as_millis() > 0);
+        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,
+            pos: U16Vec2::new(10, 20),
-            y: 20,
+            size: U16Vec2::new(32, 64),
-            width: 32,
-            height: 64,
         },
     );
 
@@ -38,19 +36,15 @@ fn test_sprite_atlas_multiple_tiles() {
     frames.insert(
         "tile1".to_string(),
         MapperFrame {
-            x: 0,
+            pos: U16Vec2::new(0, 0),
-            y: 0,
+            size: U16Vec2::new(32, 32),
-            width: 32,
-            height: 32,
         },
     );
     frames.insert(
         "tile2".to_string(),
         MapperFrame {
-            x: 32,
+            pos: U16Vec2::new(32, 0),
-            y: 0,
+            size: U16Vec2::new(64, 64),
-            width: 64,
-            height: 64,
         },
     );
 

tests/tracing_buffer.rs

@@ -0,0 +1,19 @@
+use pacman::platform::tracing_buffer::SwitchableWriter;
+use std::io::Write;
+
+#[test]
+fn test_switchable_writer_buffering() {
+    let mut writer = SwitchableWriter::default();
+
+    // Write some data while in buffered mode
+    writer.write_all(b"Hello, ").unwrap();
+    writer.write_all(b"world!").unwrap();
+    writer.write_all(b"This is buffered content.\n").unwrap();
+
+    // Switch to direct mode (this should flush to stdout and show buffer size)
+    // In a real test we can't easily capture stdout, so we'll just verify it doesn't panic
+    writer.switch_to_direct_mode().unwrap();
+
+    // Write more data in direct mode
+    writer.write_all(b"Direct output after flush\n").unwrap();
+}