feat: enhance profiling with tick-based timing management and zero-padding for skipped frames

Cargo.lock

@@ -301,6 +301,15 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "deranged"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d630bccd429a5bb5a64b5e94f693bfc48c9f8566418fda4c494cc94f911f87cc"
+dependencies = [
+ "powerfmt",
+]
+
 [[package]]
 name = "derive_more"
 version = "1.0.0"
@@ -561,6 +570,12 @@ dependencies = [
  "windows-sys 0.52.0",
 ]
 
+[[package]]
+name = "num-conv"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9"
+
 [[package]]
 name = "num-traits"
 version = "0.2.19"
@@ -608,6 +623,7 @@ dependencies = [
  "strum_macros",
  "thiserror",
  "thousands",
+ "time",
  "tracing",
  "tracing-error",
  "tracing-subscriber",
@@ -722,6 +738,12 @@ dependencies = [
  "portable-atomic",
 ]
 
+[[package]]
+name = "powerfmt"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
+
 [[package]]
 name = "ppv-lite86"
 version = "0.2.21"
@@ -1032,6 +1054,36 @@ dependencies = [
  "once_cell",
 ]
 
+[[package]]
+name = "time"
+version = "0.3.43"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "83bde6f1ec10e72d583d91623c939f623002284ef622b87de38cfd546cbf2031"
+dependencies = [
+ "deranged",
+ "num-conv",
+ "powerfmt",
+ "serde",
+ "time-core",
+ "time-macros",
+]
+
+[[package]]
+name = "time-core"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "40868e7c1d2f0b8d73e4a8c7f0ff63af4f6d19be117e90bd73eb1d62cf831c6b"
+
+[[package]]
+name = "time-macros"
+version = "0.2.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "30cfb0125f12d9c277f35663a0a33f8c30190f4e4574868a330595412d34ebf3"
+dependencies = [
+ "num-conv",
+ "time-core",
+]
+
 [[package]]
 name = "toml_datetime"
 version = "0.6.11"

Cargo.toml

@@ -24,6 +24,7 @@ pathfinding = "4.14"
 tracing = { version = "0.1.41", features = ["max_level_debug", "release_max_level_debug"]}
 tracing-error = "0.2.0"
 tracing-subscriber = {version = "0.3.20", features = ["env-filter"]}
+time = { version = "0.3.43", features = ["formatting", "macros"] }
 thiserror = "2.0.16"
 anyhow = "1.0"
 smallvec = "1.15.1"

src/app.rs

@@ -4,6 +4,7 @@ use std::time::{Duration, Instant};
 use crate::error::{GameError, GameResult};
 
 use crate::constants::{CANVAS_SIZE, LOOP_TIME, SCALE};
+use crate::formatter;
 use crate::game::Game;
 use crate::platform;
 use sdl2::pixels::PixelFormatEnum;
@@ -12,10 +13,6 @@ use sdl2::{AudioSubsystem, Sdl};
 use tracing::debug;
 
 /// Main application wrapper that manages SDL initialization, window lifecycle, and the game loop.
-///
-/// Handles platform-specific setup, maintains consistent frame timing, and delegates
-/// game logic to the contained `Game` instance. The app manages focus state to
-/// optimize CPU usage when the window loses focus.
 pub struct App {
     pub game: Game,
     last_tick: Instant,
@@ -28,19 +25,15 @@ 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,
-    /// window creation with proper scaling, and canvas configuration. All SDL
-    /// resources are leaked to maintain 'static lifetimes required by the game architecture.
-    ///
     /// # Errors
     ///
     /// Returns `GameError::Sdl` if any SDL initialization step fails, or propagates
     /// errors from `Game::new()` during game state setup.
     pub fn new() -> GameResult<Self> {
         let sdl_context = sdl2::init().map_err(|e| GameError::Sdl(e.to_string()))?;
+        let ttf_context = sdl2::ttf::init().map_err(|e| GameError::Sdl(e.to_string()))?;
         let video_subsystem = sdl_context.video().map_err(|e| GameError::Sdl(e.to_string()))?;
         let audio_subsystem = sdl_context.audio().map_err(|e| GameError::Sdl(e.to_string()))?;
-        // TTF context is initialized within Game::new where it is leaked for font usage
         let event_pump = sdl_context.event_pump().map_err(|e| GameError::Sdl(e.to_string()))?;
 
         let window = video_subsystem
@@ -102,8 +95,7 @@ impl App {
 
         let texture_creator = canvas.texture_creator();
 
-        let game = Game::new(canvas, texture_creator, event_pump)?;
-        // game.audio.set_mute(cfg!(debug_assertions));
+        let game = Game::new(canvas, ttf_context, texture_creator, event_pump)?;
 
         Ok(App {
             game,
@@ -131,6 +123,9 @@ impl App {
             let dt = self.last_tick.elapsed().as_secs_f32();
             self.last_tick = start;
 
+            // Increment the global tick counter for tracing
+            formatter::increment_tick();
+
             let exit = self.game.tick(dt);
 
             if exit {

src/formatter.rs

@@ -0,0 +1,94 @@
+//! Custom tracing formatter with tick counter integration
+
+use std::fmt;
+use std::sync::atomic::{AtomicU64, Ordering};
+use time::macros::format_description;
+use time::{format_description::FormatItem, OffsetDateTime};
+use tracing::{Event, Subscriber};
+use tracing_subscriber::fmt::format::Writer;
+use tracing_subscriber::fmt::{FmtContext, FormatEvent, FormatFields};
+use tracing_subscriber::registry::LookupSpan;
+
+/// Global atomic counter for tracking game ticks
+static TICK_COUNTER: AtomicU64 = AtomicU64::new(0);
+
+/// Maximum value for tick counter display (16-bit hex)
+const TICK_DISPLAY_MASK: u64 = 0xFFFF;
+
+/// Cached format description for timestamps
+/// Uses 3 subsecond digits on Emscripten, 5 otherwise for better performance
+#[cfg(target_os = "emscripten")]
+const TIMESTAMP_FORMAT: &[FormatItem<'static>] = format_description!("[hour]:[minute]:[second].[subsecond digits:3]");
+
+#[cfg(not(target_os = "emscripten"))]
+const TIMESTAMP_FORMAT: &[FormatItem<'static>] = format_description!("[hour]:[minute]:[second].[subsecond digits:5]");
+
+/// A custom formatter that includes both timestamp and tick counter in hexadecimal
+///
+/// This formatter provides:
+/// - High-precision timestamps (HH:MM:SS.mmm on Emscripten, HH:MM:SS.mmmmm otherwise)
+/// - Hexadecimal tick counter for frame correlation
+/// - Standard log level and target information
+///
+/// Performance considerations:
+/// - Timestamp format is cached at compile time
+/// - Tick counter access is atomic and very fast
+/// - Combined formatting operations for efficiency
+pub struct CustomFormatter;
+
+impl<S, N> FormatEvent<S, N> for CustomFormatter
+where
+    S: Subscriber + for<'a> LookupSpan<'a>,
+    N: for<'a> FormatFields<'a> + 'static,
+{
+    fn format_event(&self, ctx: &FmtContext<'_, S, N>, mut writer: Writer<'_>, event: &Event<'_>) -> fmt::Result {
+        // Format timestamp using cached format description
+        let now = OffsetDateTime::now_utc();
+        let formatted_time = now.format(&TIMESTAMP_FORMAT).map_err(|e| {
+            // Preserve the original error information for debugging
+            eprintln!("Failed to format timestamp: {}", e);
+            fmt::Error
+        })?;
+
+        // Get tick count and format everything together
+        let tick_count = get_tick_count();
+        let metadata = event.metadata();
+
+        // Combined formatting: timestamp, tick counter, level, and target in one write
+        write!(
+            writer,
+            "{} 0x{:04X} {:5} {}: ",
+            formatted_time,
+            tick_count & TICK_DISPLAY_MASK,
+            metadata.level(),
+            metadata.target()
+        )?;
+
+        // Format the fields (the actual log message)
+        ctx.field_format().format_fields(writer.by_ref(), event)?;
+
+        writeln!(writer)
+    }
+}
+
+/// Increment the global tick counter by 1
+///
+/// This should be called once per game tick/frame from the main game loop
+pub fn increment_tick() {
+    TICK_COUNTER.fetch_add(1, Ordering::Relaxed);
+}
+
+/// Get the current tick count
+///
+/// Returns the current value of the global tick counter
+pub fn get_tick_count() -> u64 {
+    TICK_COUNTER.load(Ordering::Relaxed)
+}
+
+/// Reset the tick counter to 0
+///
+/// This can be used for testing or when restarting the game
+#[allow(dead_code)]
+pub fn reset_tick_counter() {
+    TICK_COUNTER.store(0, Ordering::Relaxed);
+}

src/game.rs

@@ -5,18 +5,19 @@ include!(concat!(env!("OUT_DIR"), "/atlas_data.rs"));
 use std::collections::HashMap;
 
 use crate::constants::{self, animation, MapTile, CANVAS_SIZE};
-use crate::error::{GameError, GameResult, TextureError};
+use crate::error::{GameError, GameResult};
 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::profiling::{SystemId, Timing};
 use crate::systems::render::touch_ui_render_system;
 use crate::systems::render::RenderDirty;
 use crate::systems::{
     self, combined_render_system, ghost_collision_system, present_system, Hidden, LinearAnimation, MovementModifiers, NodeId,
+    TouchState,
 };
 use crate::systems::{
     audio_system, blinking_system, collision_system, directional_render_system, dirty_render_system, eaten_ghost_system,
@@ -28,13 +29,13 @@ use crate::systems::{
 };
 use crate::texture::animated::{DirectionalTiles, TileSequence};
 use crate::texture::sprite::AtlasTile;
+use crate::texture::sprites::{FrightenedColor, GameSprite, GhostSprite, MazeSprite, PacmanSprite};
 use bevy_ecs::event::EventRegistry;
 use bevy_ecs::observer::Trigger;
 use bevy_ecs::schedule::common_conditions::resource_changed;
 use bevy_ecs::schedule::{Condition, IntoScheduleConfigs, Schedule, SystemSet};
 use bevy_ecs::system::{Local, ResMut};
 use bevy_ecs::world::World;
-use glam::UVec2;
 use sdl2::event::EventType;
 use sdl2::image::LoadTexture;
 use sdl2::render::{BlendMode, Canvas, ScaleMode, TextureCreator};
@@ -88,10 +89,55 @@ impl Game {
     /// errors, or entity initialization issues.
     pub fn new(
         mut canvas: Canvas<Window>,
+        ttf_context: sdl2::ttf::Sdl2TtfContext,
         texture_creator: TextureCreator<WindowContext>,
         mut event_pump: EventPump,
     ) -> GameResult<Game> {
-        // Disable uninteresting events
+        Self::disable_sdl_events(&mut event_pump);
+
+        let (backbuffer, mut map_texture, debug_texture, ttf_atlas) =
+            Self::setup_textures_and_fonts(&mut canvas, &texture_creator, ttf_context)?;
+
+        let audio = crate::audio::Audio::new();
+
+        let (mut atlas, map_tiles) = Self::load_atlas_and_map_tiles(&texture_creator)?;
+        canvas
+            .with_texture_canvas(&mut map_texture, |map_canvas| {
+                MapRenderer::render_map(map_canvas, &mut atlas, &map_tiles);
+            })
+            .map_err(|e| GameError::Sdl(e.to_string()))?;
+
+        let map = Map::new(constants::RAW_BOARD)?;
+
+        let (player_animation, player_start_sprite) = Self::create_player_animations(&atlas)?;
+        let player_bundle = Self::create_player_bundle(&map, player_animation, player_start_sprite);
+
+        let mut world = World::default();
+        let mut schedule = Schedule::default();
+
+        Self::setup_ecs(&mut world);
+        Self::insert_resources(
+            &mut world,
+            map,
+            audio,
+            atlas,
+            event_pump,
+            canvas,
+            backbuffer,
+            map_texture,
+            debug_texture,
+            ttf_atlas,
+        )?;
+        Self::configure_schedule(&mut schedule);
+
+        world.spawn(player_bundle).insert((Frozen, Hidden));
+        Self::spawn_ghosts(&mut world)?;
+        Self::spawn_items(&mut world)?;
+
+        Ok(Game { world, schedule })
+    }
+
+    fn disable_sdl_events(event_pump: &mut EventPump) {
         for event_type in [
             EventType::JoyAxisMotion,
             EventType::JoyBallMotion,
@@ -109,9 +155,6 @@ impl Game {
             EventType::ControllerTouchpadDown,
             EventType::ControllerTouchpadMotion,
             EventType::ControllerTouchpadUp,
-            // EventType::FingerDown,  // Enable for touch controls
-            // EventType::FingerUp,    // Enable for touch controls
-            // EventType::FingerMotion, // Enable for touch controls
             EventType::DollarGesture,
             EventType::DollarRecord,
             EventType::MultiGesture,
@@ -128,11 +171,7 @@ impl Game {
             EventType::TextInput,
             EventType::TextEditing,
             EventType::Display,
-            // EventType::Window,
             EventType::MouseWheel,
-            // EventType::MouseMotion,
-            // EventType::MouseButtonDown,  // Enable for desktop touch testing
-            // EventType::MouseButtonUp,    // Enable for desktop touch testing
             EventType::AppDidEnterBackground,
             EventType::AppWillEnterForeground,
             EventType::AppWillEnterBackground,
@@ -144,8 +183,18 @@ impl Game {
         ] {
             event_pump.disable_event(event_type);
         }
+    }
 
-        let ttf_context = Box::leak(Box::new(sdl2::ttf::init().map_err(|e| GameError::Sdl(e.to_string()))?));
+    fn setup_textures_and_fonts(
+        canvas: &mut Canvas<Window>,
+        texture_creator: &TextureCreator<WindowContext>,
+        ttf_context: sdl2::ttf::Sdl2TtfContext,
+    ) -> GameResult<(
+        sdl2::render::Texture,
+        sdl2::render::Texture,
+        sdl2::render::Texture,
+        crate::texture::ttf::TtfAtlas,
+    )> {
         let mut backbuffer = texture_creator
             .create_texture_target(None, CANVAS_SIZE.x, CANVAS_SIZE.y)
             .map_err(|e| GameError::Sdl(e.to_string()))?;
@@ -156,31 +205,26 @@ impl Game {
             .map_err(|e| GameError::Sdl(e.to_string()))?;
         map_texture.set_scale_mode(ScaleMode::Nearest);
 
-        // Create debug texture at output resolution for crisp debug rendering
         let output_size = constants::LARGE_CANVAS_SIZE;
         let mut debug_texture = texture_creator
             .create_texture_target(Some(sdl2::pixels::PixelFormatEnum::ARGB8888), output_size.x, output_size.y)
             .map_err(|e| GameError::Sdl(e.to_string()))?;
-
-        // Debug texture is copied over the backbuffer, it requires transparency abilities
         debug_texture.set_blend_mode(BlendMode::Blend);
         debug_texture.set_scale_mode(ScaleMode::Nearest);
 
-        // Create debug text atlas for efficient debug rendering
         let font_data: &'static [u8] = get_asset_bytes(Asset::Font)?.to_vec().leak();
         let font_asset = RWops::from_bytes(font_data).map_err(|_| GameError::Sdl("Failed to load font".to_string()))?;
         let debug_font = ttf_context
             .load_font_from_rwops(font_asset, constants::ui::DEBUG_FONT_SIZE)
             .map_err(|e| GameError::Sdl(e.to_string()))?;
 
-        let mut ttf_atlas = crate::texture::ttf::TtfAtlas::new(&texture_creator, &debug_font)?;
-        // Populate the atlas with actual character data
-        ttf_atlas.populate_atlas(&mut canvas, &texture_creator, &debug_font)?;
+        let mut ttf_atlas = crate::texture::ttf::TtfAtlas::new(texture_creator, &debug_font)?;
+        ttf_atlas.populate_atlas(canvas, texture_creator, &debug_font)?;
 
-        // Initialize audio system
-        let audio = crate::audio::Audio::new();
+        Ok((backbuffer, map_texture, debug_texture, ttf_atlas))
+    }
 
-        // Load atlas and create map texture
+    fn load_atlas_and_map_tiles(texture_creator: &TextureCreator<WindowContext>) -> GameResult<(SpriteAtlas, Vec<AtlasTile>)> {
         let atlas_bytes = get_asset_bytes(Asset::AtlasImage)?;
         let atlas_texture = texture_creator.load_texture_bytes(&atlas_bytes).map_err(|e| {
             if e.to_string().contains("format") || e.to_string().contains("unsupported") {
@@ -195,57 +239,44 @@ impl Game {
         let atlas_mapper = AtlasMapper {
             frames: ATLAS_FRAMES.into_iter().map(|(k, v)| (k.to_string(), *v)).collect(),
         };
-        let mut atlas = SpriteAtlas::new(atlas_texture, atlas_mapper);
+        let atlas = SpriteAtlas::new(atlas_texture, atlas_mapper);
 
-        // Create map tiles
         let mut map_tiles = Vec::with_capacity(35);
         for i in 0..35 {
-            let tile_name = format!("maze/tiles/{}.png", i);
-            let tile = atlas.get_tile(&tile_name).unwrap();
+            let tile_name = GameSprite::Maze(MazeSprite::Tile(i)).to_path();
+            let tile = atlas.get_tile(&tile_name)?;
             map_tiles.push(tile);
         }
 
-        // Render map to texture
-        canvas
-            .with_texture_canvas(&mut map_texture, |map_canvas| {
-                MapRenderer::render_map(map_canvas, &mut atlas, &map_tiles);
-            })
-            .map_err(|e| GameError::Sdl(e.to_string()))?;
+        Ok((atlas, map_tiles))
+    }
 
-        let map = Map::new(constants::RAW_BOARD)?;
-
-        // Create directional animated textures for Pac-Man
+    fn create_player_animations(atlas: &SpriteAtlas) -> GameResult<(DirectionalAnimation, AtlasTile)> {
         let up_moving_tiles = [
-            SpriteAtlas::get_tile(&atlas, "pacman/up_a.png")
-                .ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/up_a.png".to_string())))?,
-            SpriteAtlas::get_tile(&atlas, "pacman/up_b.png")
-                .ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/up_b.png".to_string())))?,
-            SpriteAtlas::get_tile(&atlas, "pacman/full.png")
-                .ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/full.png".to_string())))?,
+            SpriteAtlas::get_tile(atlas, &GameSprite::Pacman(PacmanSprite::Moving(Direction::Up, 0)).to_path())?,
+            SpriteAtlas::get_tile(atlas, &GameSprite::Pacman(PacmanSprite::Moving(Direction::Up, 1)).to_path())?,
+            SpriteAtlas::get_tile(atlas, &GameSprite::Pacman(PacmanSprite::Full).to_path())?,
         ];
         let down_moving_tiles = [
-            SpriteAtlas::get_tile(&atlas, "pacman/down_a.png")
-                .ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/down_a.png".to_string())))?,
-            SpriteAtlas::get_tile(&atlas, "pacman/down_b.png")
-                .ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/down_b.png".to_string())))?,
-            SpriteAtlas::get_tile(&atlas, "pacman/full.png")
-                .ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/full.png".to_string())))?,
+            SpriteAtlas::get_tile(atlas, &GameSprite::Pacman(PacmanSprite::Moving(Direction::Down, 0)).to_path())?,
+            SpriteAtlas::get_tile(atlas, &GameSprite::Pacman(PacmanSprite::Moving(Direction::Down, 1)).to_path())?,
+            SpriteAtlas::get_tile(atlas, &GameSprite::Pacman(PacmanSprite::Full).to_path())?,
         ];
         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())))?,
+            SpriteAtlas::get_tile(atlas, &GameSprite::Pacman(PacmanSprite::Moving(Direction::Left, 0)).to_path())?,
+            SpriteAtlas::get_tile(atlas, &GameSprite::Pacman(PacmanSprite::Moving(Direction::Left, 1)).to_path())?,
+            SpriteAtlas::get_tile(atlas, &GameSprite::Pacman(PacmanSprite::Full).to_path())?,
         ];
         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())))?,
+            SpriteAtlas::get_tile(
+                atlas,
+                &GameSprite::Pacman(PacmanSprite::Moving(Direction::Right, 0)).to_path(),
+            )?,
+            SpriteAtlas::get_tile(
+                atlas,
+                &GameSprite::Pacman(PacmanSprite::Moving(Direction::Right, 1)).to_path(),
+            )?,
+            SpriteAtlas::get_tile(atlas, &GameSprite::Pacman(PacmanSprite::Full).to_path())?,
         ];
 
         let moving_tiles = DirectionalTiles::new(
@@ -255,14 +286,16 @@ impl Game {
             TileSequence::new(&right_moving_tiles),
         );
 
-        let up_stopped_tile = SpriteAtlas::get_tile(&atlas, "pacman/up_b.png")
-            .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 up_stopped_tile =
+            SpriteAtlas::get_tile(atlas, &GameSprite::Pacman(PacmanSprite::Moving(Direction::Up, 1)).to_path())?;
+        let down_stopped_tile =
+            SpriteAtlas::get_tile(atlas, &GameSprite::Pacman(PacmanSprite::Moving(Direction::Down, 1)).to_path())?;
+        let left_stopped_tile =
+            SpriteAtlas::get_tile(atlas, &GameSprite::Pacman(PacmanSprite::Moving(Direction::Left, 1)).to_path())?;
+        let right_stopped_tile = SpriteAtlas::get_tile(
+            atlas,
+            &GameSprite::Pacman(PacmanSprite::Moving(Direction::Right, 1)).to_path(),
+        )?;
 
         let stopped_tiles = DirectionalTiles::new(
             TileSequence::new(&[up_stopped_tile]),
@@ -271,7 +304,14 @@ impl Game {
             TileSequence::new(&[right_stopped_tile]),
         );
 
-        let player = PlayerBundle {
+        let player_animation = DirectionalAnimation::new(moving_tiles, stopped_tiles, 5);
+        let player_start_sprite = SpriteAtlas::get_tile(atlas, &GameSprite::Pacman(PacmanSprite::Full).to_path())?;
+
+        Ok((player_animation, player_start_sprite))
+    }
+
+    fn create_player_bundle(map: &Map, player_animation: DirectionalAnimation, player_start_sprite: AtlasTile) -> PlayerBundle {
+        PlayerBundle {
             player: PlayerControlled,
             position: Position::Stopped {
                 node: map.start_positions.pacman,
@@ -283,54 +323,22 @@ impl Game {
             movement_modifiers: MovementModifiers::default(),
             buffered_direction: BufferedDirection::None,
             sprite: Renderable {
-                sprite: SpriteAtlas::get_tile(&atlas, "pacman/full.png")
-                    .ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/full.png".to_string())))?,
+                sprite: player_start_sprite,
                 layer: 0,
             },
-            directional_animation: DirectionalAnimation::new(moving_tiles, stopped_tiles, 5),
+            directional_animation: player_animation,
             entity_type: EntityType::Player,
             collider: Collider {
                 size: constants::collider::PLAYER_GHOST_SIZE,
             },
             pacman_collider: PacmanCollider,
-        };
+        }
+    }
 
-        let mut world = World::default();
-        let mut schedule = Schedule::default();
-
-        EventRegistry::register_event::<GameError>(&mut world);
-        EventRegistry::register_event::<GameEvent>(&mut world);
-        EventRegistry::register_event::<AudioEvent>(&mut world);
-
-        let scale =
-            (UVec2::from(canvas.output_size().unwrap()).as_vec2() / UVec2::from(canvas.logical_size()).as_vec2()).min_element();
-
-        world.insert_resource(BatchedLinesResource::new(&map, scale));
-        world.insert_resource(Self::create_ghost_animations(&atlas)?);
-        world.insert_resource(map);
-        world.insert_resource(GlobalState { exit: false });
-        world.insert_resource(ScoreResource(0));
-        world.insert_resource(SystemTimings::default());
-        world.insert_resource(Bindings::default());
-        world.insert_resource(DeltaTime(0f32));
-        world.insert_resource(RenderDirty::default());
-        world.insert_resource(DebugState::default());
-        world.insert_resource(AudioState::default());
-        world.insert_resource(CursorPosition::default());
-        world.insert_resource(systems::input::TouchState::default());
-        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);
-        world.insert_non_send_resource::<&mut Canvas<Window>>(Box::leak(Box::new(canvas)));
-        world.insert_non_send_resource(BackbufferResource(backbuffer));
-        world.insert_non_send_resource(MapTextureResource(map_texture));
-        world.insert_non_send_resource(DebugTextureResource(debug_texture));
-        world.insert_non_send_resource(TtfAtlasResource(ttf_atlas));
-        world.insert_non_send_resource(AudioResource(audio));
+    fn setup_ecs(world: &mut World) {
+        EventRegistry::register_event::<GameError>(world);
+        EventRegistry::register_event::<GameEvent>(world);
+        EventRegistry::register_event::<AudioEvent>(world);
 
         world.add_observer(
             |event: Trigger<GameEvent>, mut state: ResMut<GlobalState>, _score: ResMut<ScoreResource>| {
@@ -339,7 +347,53 @@ impl Game {
                 }
             },
         );
+    }
 
+    #[allow(clippy::too_many_arguments)]
+    fn insert_resources(
+        world: &mut World,
+        map: Map,
+        audio: crate::audio::Audio,
+        atlas: SpriteAtlas,
+        event_pump: EventPump,
+        canvas: Canvas<Window>,
+        backbuffer: sdl2::render::Texture,
+        map_texture: sdl2::render::Texture,
+        debug_texture: sdl2::render::Texture,
+        ttf_atlas: crate::texture::ttf::TtfAtlas,
+    ) -> GameResult<()> {
+        world.insert_non_send_resource(atlas);
+        world.insert_resource(Self::create_ghost_animations(world.non_send_resource::<SpriteAtlas>())?);
+
+        world.insert_resource(BatchedLinesResource::new(&map, constants::LARGE_SCALE));
+        world.insert_resource(map);
+        world.insert_resource(GlobalState { exit: false });
+        world.insert_resource(ScoreResource(0));
+        world.insert_resource(SystemTimings::default());
+        world.insert_resource(Timing::default());
+        world.insert_resource(Bindings::default());
+        world.insert_resource(DeltaTime(0f32));
+        world.insert_resource(RenderDirty::default());
+        world.insert_resource(DebugState::default());
+        world.insert_resource(AudioState::default());
+        world.insert_resource(CursorPosition::default());
+        world.insert_resource(TouchState::default());
+        world.insert_resource(StartupSequence::new(
+            constants::startup::STARTUP_FRAMES,
+            constants::startup::STARTUP_TICKS_PER_FRAME,
+        ));
+
+        world.insert_non_send_resource(event_pump);
+        world.insert_non_send_resource::<&mut Canvas<Window>>(Box::leak(Box::new(canvas)));
+        world.insert_non_send_resource(BackbufferResource(backbuffer));
+        world.insert_non_send_resource(MapTextureResource(map_texture));
+        world.insert_non_send_resource(DebugTextureResource(debug_texture));
+        world.insert_non_send_resource(TtfAtlasResource(ttf_atlas));
+        world.insert_non_send_resource(AudioResource(audio));
+        Ok(())
+    }
+
+    fn configure_schedule(schedule: &mut Schedule) {
         let input_system = profile(SystemId::Input, systems::input::input_system);
         let player_control_system = profile(SystemId::PlayerControls, systems::player_control_system);
         let player_movement_system = profile(SystemId::PlayerMovement, systems::player_movement_system);
@@ -394,19 +448,18 @@ impl Game {
             )
                 .chain(),
         ));
+    }
 
-        // Spawn player and attach initial state bundle
-        world.spawn(player).insert((Frozen, Hidden));
+    fn spawn_items(world: &mut World) -> GameResult<()> {
+        let pellet_sprite = SpriteAtlas::get_tile(
+            world.non_send_resource::<SpriteAtlas>(),
+            &GameSprite::Maze(MazeSprite::Pellet).to_path(),
+        )?;
+        let energizer_sprite = SpriteAtlas::get_tile(
+            world.non_send_resource::<SpriteAtlas>(),
+            &GameSprite::Maze(MazeSprite::Energizer).to_path(),
+        )?;
 
-        // Spawn ghosts
-        Self::spawn_ghosts(&mut world)?;
-
-        let pellet_sprite = SpriteAtlas::get_tile(world.non_send_resource::<SpriteAtlas>(), "maze/pellet.png")
-            .ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("maze/pellet.png".to_string())))?;
-        let energizer_sprite = SpriteAtlas::get_tile(world.non_send_resource::<SpriteAtlas>(), "maze/energizer.png")
-            .ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("maze/energizer.png".to_string())))?;
-
-        // Build a list of item entities to spawn from the map
         let nodes: Vec<(NodeId, EntityType, AtlasTile, f32)> = world
             .resource::<Map>()
             .iter_nodes()
@@ -422,7 +475,6 @@ impl Game {
             })
             .collect();
 
-        // Construct and spawn the item entities
         for (id, item_type, sprite, size) in nodes {
             let mut item = world.spawn(ItemBundle {
                 position: Position::Stopped { node: id },
@@ -432,13 +484,11 @@ impl Game {
                 item_collider: ItemCollider,
             });
 
-            // Make power pellets blink
             if item_type == EntityType::PowerPellet {
                 item.insert((Frozen, Blinking::new(constants::ui::POWER_PELLET_BLINK_RATE)));
             }
         }
-
-        Ok(Game { world, schedule })
+        Ok(())
     }
 
     /// Creates and spawns all four ghosts with unique AI personalities and directional animations.
@@ -464,6 +514,7 @@ impl Game {
             let ghost = {
                 let animations = *world.resource::<GhostAnimations>().get_normal(&ghost_type).unwrap();
                 let atlas = world.non_send_resource::<SpriteAtlas>();
+                let sprite_path = GameSprite::Ghost(GhostSprite::Normal(ghost_type, Direction::Left, 0)).to_path();
 
                 GhostBundle {
                     ghost: ghost_type,
@@ -473,14 +524,7 @@ impl Game {
                         direction: Direction::Left,
                     },
                     sprite: Renderable {
-                        sprite: SpriteAtlas::get_tile(atlas, &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()
-                                )))
-                            },
-                        )?,
+                        sprite: SpriteAtlas::get_tile(atlas, &sprite_path)?,
                         layer: 0,
                     },
                     directional_animation: animations,
@@ -502,18 +546,10 @@ impl Game {
 
     fn create_ghost_animations(atlas: &SpriteAtlas) -> GameResult<GhostAnimations> {
         // 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 up_eye = atlas.get_tile(&GameSprite::Ghost(GhostSprite::Eyes(Direction::Up)).to_path())?;
+        let down_eye = atlas.get_tile(&GameSprite::Ghost(GhostSprite::Eyes(Direction::Down)).to_path())?;
+        let left_eye = atlas.get_tile(&GameSprite::Ghost(GhostSprite::Eyes(Direction::Left)).to_path())?;
+        let right_eye = atlas.get_tile(&GameSprite::Ghost(GhostSprite::Eyes(Direction::Right)).to_path())?;
 
         let eyes_tiles = DirectionalTiles::new(
             TileSequence::new(&[up_eye]),
@@ -528,76 +564,20 @@ impl Game {
         for ghost_type in [Ghost::Blinky, Ghost::Pinky, Ghost::Inky, Ghost::Clyde] {
             // Normal animations - create directional tiles for each direction
             let up_tiles = [
-                atlas
-                    .get_tile(&format!("ghost/{}/up_a.png", ghost_type.as_str()))
-                    .ok_or_else(|| {
-                        GameError::Texture(TextureError::AtlasTileNotFound(format!(
-                            "ghost/{}/up_a.png",
-                            ghost_type.as_str()
-                        )))
-                    })?,
-                atlas
-                    .get_tile(&format!("ghost/{}/up_b.png", ghost_type.as_str()))
-                    .ok_or_else(|| {
-                        GameError::Texture(TextureError::AtlasTileNotFound(format!(
-                            "ghost/{}/up_b.png",
-                            ghost_type.as_str()
-                        )))
-                    })?,
+                atlas.get_tile(&GameSprite::Ghost(GhostSprite::Normal(ghost_type, Direction::Up, 0)).to_path())?,
+                atlas.get_tile(&GameSprite::Ghost(GhostSprite::Normal(ghost_type, Direction::Up, 1)).to_path())?,
             ];
             let down_tiles = [
-                atlas
-                    .get_tile(&format!("ghost/{}/down_a.png", ghost_type.as_str()))
-                    .ok_or_else(|| {
-                        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()
-                        )))
-                    })?,
+                atlas.get_tile(&GameSprite::Ghost(GhostSprite::Normal(ghost_type, Direction::Down, 0)).to_path())?,
+                atlas.get_tile(&GameSprite::Ghost(GhostSprite::Normal(ghost_type, Direction::Down, 1)).to_path())?,
             ];
             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()
-                        )))
-                    })?,
+                atlas.get_tile(&GameSprite::Ghost(GhostSprite::Normal(ghost_type, Direction::Left, 0)).to_path())?,
+                atlas.get_tile(&GameSprite::Ghost(GhostSprite::Normal(ghost_type, Direction::Left, 1)).to_path())?,
             ];
             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()
-                        )))
-                    })?,
+                atlas.get_tile(&GameSprite::Ghost(GhostSprite::Normal(ghost_type, Direction::Right, 0)).to_path())?,
+                atlas.get_tile(&GameSprite::Ghost(GhostSprite::Normal(ghost_type, Direction::Right, 1)).to_path())?,
             ];
 
             let normal_moving = DirectionalTiles::new(
@@ -613,18 +593,14 @@ impl Game {
 
         let (frightened, frightened_flashing) = {
             // Load frightened animation tiles (same for all ghosts)
-            let frightened_blue_a = atlas
-                .get_tile("ghost/frightened/blue_a.png")
-                .ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("ghost/frightened/blue_a.png".to_string())))?;
-            let frightened_blue_b = atlas
-                .get_tile("ghost/frightened/blue_b.png")
-                .ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("ghost/frightened/blue_b.png".to_string())))?;
-            let frightened_white_a = atlas
-                .get_tile("ghost/frightened/white_a.png")
-                .ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("ghost/frightened/white_a.png".to_string())))?;
-            let frightened_white_b = atlas
-                .get_tile("ghost/frightened/white_b.png")
-                .ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("ghost/frightened/white_b.png".to_string())))?;
+            let frightened_blue_a =
+                atlas.get_tile(&GameSprite::Ghost(GhostSprite::Frightened(FrightenedColor::Blue, 0)).to_path())?;
+            let frightened_blue_b =
+                atlas.get_tile(&GameSprite::Ghost(GhostSprite::Frightened(FrightenedColor::Blue, 1)).to_path())?;
+            let frightened_white_a =
+                atlas.get_tile(&GameSprite::Ghost(GhostSprite::Frightened(FrightenedColor::White, 0)).to_path())?;
+            let frightened_white_b =
+                atlas.get_tile(&GameSprite::Ghost(GhostSprite::Frightened(FrightenedColor::White, 1)).to_path())?;
 
             (
                 LinearAnimation::new(
@@ -659,8 +635,21 @@ impl Game {
     pub fn tick(&mut self, dt: f32) -> bool {
         self.world.insert_resource(DeltaTime(dt));
 
-        // Run all systems
+        // Note: We don't need to read the current tick here since we increment it after running systems
+
+        // Measure total frame time including all systems
+        let start = std::time::Instant::now();
         self.schedule.run(&mut self.world);
+        let total_duration = start.elapsed();
+
+        // Increment tick counter and record the total timing
+        if let (Some(timings), Some(timing)) = (
+            self.world.get_resource::<systems::profiling::SystemTimings>(),
+            self.world.get_resource::<Timing>(),
+        ) {
+            let new_tick = timing.increment_tick();
+            timings.add_total_timing(total_duration, new_tick);
+        }
 
         let state = self
             .world

src/lib.rs

@@ -6,6 +6,7 @@ pub mod audio;
 pub mod constants;
 pub mod error;
 pub mod events;
+pub mod formatter;
 pub mod game;
 pub mod map;
 pub mod platform;

src/main.rs

@@ -11,6 +11,7 @@ mod constants;
 
 mod error;
 mod events;
+mod formatter;
 mod game;
 mod map;
 mod platform;

src/platform/buffered_writer.rs

@@ -1,57 +0,0 @@
-#![allow(dead_code)]
-
-//! 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/emscripten.rs

@@ -2,6 +2,7 @@
 
 use crate::asset::Asset;
 use crate::error::{AssetError, PlatformError};
+use crate::formatter::CustomFormatter;
 use rand::{rngs::SmallRng, SeedableRng};
 use sdl2::rwops::RWops;
 use std::borrow::Cow;
@@ -33,8 +34,7 @@ pub fn init_console() -> Result<(), PlatformError> {
             fmt::layer()
                 .with_writer(|| EmscriptenConsoleWriter)
                 .with_ansi(false)
-                .without_time()
-                .with_target(false),
+                .event_format(CustomFormatter),
         )
         .with(EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("debug")));
 

src/platform/mod.rs

@@ -1,7 +1,5 @@
 //! Platform abstraction layer for cross-platform functionality.
 
-#[cfg(not(target_os = "emscripten"))]
-pub mod buffered_writer;
 #[cfg(not(target_os = "emscripten"))]
 mod desktop;
 #[cfg(not(target_os = "emscripten"))]

src/platform/tracing_buffer.rs

@@ -1,14 +1,66 @@
 #![allow(dead_code)]
-
 //! Buffered tracing setup for handling logs before console attachment.
 
-use crate::platform::buffered_writer::BufferedWriter;
+use crate::formatter::CustomFormatter;
+use parking_lot::Mutex;
 use std::io;
+use std::io::Write;
+use std::sync::Arc;
 use tracing::{debug, Level};
 use tracing_error::ErrorLayer;
 use tracing_subscriber::fmt::MakeWriter;
 use tracing_subscriber::layer::SubscriberExt;
 
+/// 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()
+    }
+}
+
 /// A writer that can switch between buffering and direct output.
 #[derive(Clone, Default)]
 pub struct SwitchableWriter {
@@ -90,6 +142,7 @@ pub fn setup_switchable_subscriber() -> SwitchableWriter {
     let _subscriber = tracing_subscriber::fmt()
         .with_ansi(cfg!(not(target_os = "emscripten")))
         .with_max_level(Level::DEBUG)
+        .event_format(CustomFormatter)
         .with_writer(make_writer)
         .finish()
         .with(ErrorLayer::default());

src/systems/debug.rs

@@ -152,11 +152,12 @@ fn transform_position_with_offset(pos: Vec2, scale: f32) -> IVec2 {
 fn render_timing_display(
     canvas: &mut Canvas<Window>,
     timings: &SystemTimings,
+    current_tick: u64,
     text_renderer: &TtfRenderer,
     atlas: &mut TtfAtlas,
 ) {
     // Format timing information using the formatting module
-    let lines = timings.format_timing_display();
+    let lines = timings.format_timing_display(current_tick);
     let line_height = text_renderer.text_height(atlas) as i32 + 2; // Add 2px line spacing
     let padding = 10;
 
@@ -208,6 +209,7 @@ pub fn debug_render_system(
     batched_lines: &Res<BatchedLinesResource>,
     debug_state: &Res<DebugState>,
     timings: &Res<SystemTimings>,
+    timing: &Res<crate::systems::profiling::Timing>,
     map: &Res<Map>,
     colliders: &Query<(&Collider, &Position)>,
     cursor: &Res<CursorPosition>,
@@ -329,5 +331,8 @@ pub fn debug_render_system(
     }
 
     // Render timing information in the top-left corner
-    render_timing_display(canvas, timings, &text_renderer, &mut ttf_atlas.0);
+    // Use previous tick since current tick is incomplete (frame is still running)
+    let current_tick = timing.get_current_tick();
+    let previous_tick = current_tick.saturating_sub(1);
+    render_timing_display(canvas, timings, previous_tick, &text_renderer, &mut ttf_atlas.0);
 }

src/systems/input.rs

@@ -12,7 +12,6 @@ use sdl2::{
     EventPump,
 };
 use smallvec::{smallvec, SmallVec};
-use tracing::{debug, info};
 
 use crate::systems::components::DeltaTime;
 use crate::{
@@ -298,19 +297,15 @@ pub fn input_system(
                     simple_key_events.push(SimpleKeyEvent::KeyUp(key));
                 }
             }
-            Event::Window { win_event, .. } => match win_event {
-                WindowEvent::Resized(w, h) => {
-                    info!("Window resized to {}x{}", w, h);
+            Event::Window { win_event, .. } => {
+                if let WindowEvent::Resized(w, h) = win_event {
+                    tracing::info!(width = w, height = h, event = ?win_event, "Window Resized");
                 }
-                _ => {
-                    debug!("Window event: {:?}", win_event);
-                }
-            },
-            Event::RenderTargetsReset { .. } => {
-                // No-op
             }
+            // Despite disabling this event, it's still received, so we ignore it explicitly.
+            Event::RenderTargetsReset { .. } => {}
             _ => {
-                tracing::warn!("Unhandled event, consider disabling: {:?}", event);
+                tracing::warn!(event = ?event, "Unhandled Event");
             }
         }
     }

src/systems/profiling.rs

@@ -1,11 +1,11 @@
 use bevy_ecs::system::IntoSystem;
 use bevy_ecs::{resource::Resource, system::System};
 use circular_buffer::CircularBuffer;
-use micromap::Map;
 use num_width::NumberWidth;
 use parking_lot::Mutex;
 use smallvec::SmallVec;
 use std::fmt::Display;
+use std::sync::atomic::{AtomicU64, Ordering};
 use std::time::Duration;
 use strum::{EnumCount, IntoEnumIterator};
 use strum_macros::{EnumCount, EnumIter, IntoStaticStr};
@@ -16,8 +16,127 @@ const MAX_SYSTEMS: usize = SystemId::COUNT;
 /// The number of durations to keep in the circular buffer.
 const TIMING_WINDOW_SIZE: usize = 30;
 
+/// A timing buffer that tracks durations and automatically inserts zero durations for skipped ticks.
+#[derive(Debug, Default)]
+pub struct TimingBuffer {
+    /// Circular buffer storing timing durations
+    buffer: CircularBuffer<TIMING_WINDOW_SIZE, Duration>,
+    /// The last tick when this buffer was updated
+    last_tick: u64,
+}
+
+impl TimingBuffer {
+    /// Adds a timing duration for the current tick.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `current_tick` is less than `last_tick`, indicating time went backwards.
+    pub fn add_timing(&mut self, duration: Duration, current_tick: u64) {
+        if current_tick < self.last_tick {
+            panic!(
+                "Time went backwards: current_tick ({}) < last_tick ({})",
+                current_tick, self.last_tick
+            );
+        }
+
+        // Insert zero durations for any skipped ticks (but not the current tick)
+        if current_tick > self.last_tick {
+            let skipped_ticks = current_tick - self.last_tick - 1;
+            for _ in 0..skipped_ticks {
+                self.buffer.push_back(Duration::ZERO);
+            }
+        }
+
+        // Add the actual timing
+        self.buffer.push_back(duration);
+        self.last_tick = current_tick;
+    }
+
+    /// Gets statistics for this timing buffer.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `current_tick` is less than `last_tick`, indicating time went backwards.
+    pub fn get_stats(&mut self, current_tick: u64) -> (Duration, Duration) {
+        // Insert zero durations for any skipped ticks since last update (but not the current tick)
+        if current_tick > self.last_tick {
+            let skipped_ticks = current_tick - self.last_tick - 1;
+            for _ in 0..skipped_ticks {
+                self.buffer.push_back(Duration::ZERO);
+            }
+            self.last_tick = current_tick;
+        }
+
+        // Calculate statistics using Welford's algorithm
+        let mut sample_count = 0u16;
+        let mut running_mean = 0.0;
+        let mut sum_squared_diff = 0.0;
+
+        let skip = self.last_tick.saturating_sub(current_tick);
+        for duration in self.buffer.iter().skip(skip as usize) {
+            let duration_secs = duration.as_secs_f32();
+            sample_count += 1;
+
+            let diff_from_mean = duration_secs - running_mean;
+            running_mean += diff_from_mean / sample_count as f32;
+
+            let diff_from_new_mean = duration_secs - running_mean;
+            sum_squared_diff += diff_from_mean * diff_from_new_mean;
+        }
+
+        if sample_count > 0 {
+            let variance = if sample_count > 1 {
+                sum_squared_diff / (sample_count - 1) as f32
+            } else {
+                0.0
+            };
+
+            (
+                Duration::from_secs_f32(running_mean),
+                Duration::from_secs_f32(variance.sqrt()),
+            )
+        } else {
+            (Duration::ZERO, Duration::ZERO)
+        }
+    }
+}
+
+/// A resource that tracks the current game tick using an atomic counter.
+/// This ensures thread-safe access to the tick counter across systems.
+#[derive(Resource, Debug)]
+pub struct Timing {
+    /// Atomic counter for the current game tick
+    current_tick: AtomicU64,
+}
+
+impl Timing {
+    /// Creates a new Timing resource starting at tick 0
+    pub fn new() -> Self {
+        Self {
+            current_tick: AtomicU64::new(0),
+        }
+    }
+
+    /// Gets the current tick value
+    pub fn get_current_tick(&self) -> u64 {
+        self.current_tick.load(Ordering::Relaxed)
+    }
+
+    /// Increments the tick counter and returns the new value
+    pub fn increment_tick(&self) -> u64 {
+        self.current_tick.fetch_add(1, Ordering::Relaxed) + 1
+    }
+}
+
+impl Default for Timing {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 #[derive(EnumCount, EnumIter, IntoStaticStr, Debug, PartialEq, Eq, Hash, Copy, Clone)]
 pub enum SystemId {
+    Total,
     Input,
     PlayerControls,
     Ghost,
@@ -42,33 +161,24 @@ pub enum SystemId {
 
 impl Display for SystemId {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        // Use strum_macros::IntoStaticStr to get the static string
         write!(f, "{}", Into::<&'static str>::into(self).to_ascii_lowercase())
     }
 }
 
 #[derive(Resource, Debug)]
 pub struct SystemTimings {
-    /// Map of system names to a queue of durations, using a circular buffer.
-    ///
-    /// Uses a RwLock to allow multiple readers for the HashMap, and a Mutex on the circular buffer for exclusive access.
-    /// This is probably overkill, but it's fun to play with.
-    ///
-    /// Also, we use a micromap::Map as the number of systems is generally quite small.
-    /// Just make sure to set the capacity appropriately, or it will panic.
-    ///
-    /// Pre-populated with all SystemId variants during initialization to avoid runtime allocations
-    /// and allow systems to have default zero timings when they don't submit data.
-    pub timings: Map<SystemId, Mutex<CircularBuffer<TIMING_WINDOW_SIZE, Duration>>, MAX_SYSTEMS>,
+    /// Statically sized map of system names to timing buffers.
+    pub timings: micromap::Map<SystemId, Mutex<TimingBuffer>, MAX_SYSTEMS>,
 }
 
 impl Default for SystemTimings {
     fn default() -> Self {
-        let mut timings = Map::new();
+        let mut timings = micromap::Map::new();
 
         // Pre-populate with all SystemId variants to avoid runtime allocations
-        // and provide default zero timings for systems that don't submit data
         for id in SystemId::iter() {
-            timings.insert(id, Mutex::new(CircularBuffer::new()));
+            timings.insert(id, Mutex::new(TimingBuffer::default()));
         }
 
         Self { timings }
@@ -76,94 +186,61 @@ impl Default for SystemTimings {
 }
 
 impl SystemTimings {
-    pub fn add_timing(&self, id: SystemId, duration: Duration) {
+    pub fn add_timing(&self, id: SystemId, duration: Duration, current_tick: u64) {
         // Since all SystemId variants are pre-populated, we can use a simple read lock
-        let queue = self
+        let buffer = self
             .timings
             .get(&id)
             .expect("SystemId not found in pre-populated map - this is a bug");
-        queue.lock().push_back(duration);
+        buffer.lock().add_timing(duration, current_tick);
     }
 
-    pub fn get_stats(&self) -> Map<SystemId, (Duration, Duration), MAX_SYSTEMS> {
-        let mut stats = Map::new();
+    /// Add timing for the Total system (total frame time including scheduler.run)
+    pub fn add_total_timing(&self, duration: Duration, current_tick: u64) {
+        self.add_timing(SystemId::Total, duration, current_tick);
+    }
+
+    pub fn get_stats(&self, current_tick: u64) -> micromap::Map<SystemId, (Duration, Duration), MAX_SYSTEMS> {
+        let mut stats = micromap::Map::new();
 
         // Iterate over all SystemId variants to ensure every system has an entry
         for id in SystemId::iter() {
-            let queue = self
+            let buffer = self
                 .timings
                 .get(&id)
                 .expect("SystemId not found in pre-populated map - this is a bug");
 
-            let queue_guard = queue.lock();
-            if queue_guard.is_empty() {
-                // Return zero timing for systems that haven't submitted any data
-                stats.insert(id, (Duration::ZERO, Duration::ZERO));
-                continue;
-            }
-
-            let durations: Vec<f64> = queue_guard.iter().map(|d| d.as_secs_f64() * 1000.0).collect();
-            let count = durations.len() as f64;
-
-            let sum: f64 = durations.iter().sum();
-            let mean = sum / count;
-
-            let variance = durations.iter().map(|x| (x - mean).powi(2)).sum::<f64>() / (count - 1.0).max(1.0);
-            let std_dev = variance.sqrt();
-
-            stats.insert(
-                id,
-                (
-                    Duration::from_secs_f64(mean / 1000.0),
-                    Duration::from_secs_f64(std_dev / 1000.0),
-                ),
-            );
+            let (average, standard_deviation) = buffer.lock().get_stats(current_tick);
+            stats.insert(id, (average, standard_deviation));
         }
 
         stats
     }
 
-    pub fn get_total_stats(&self) -> (Duration, Duration) {
-        let duration_sums = {
-            self.timings
-                .iter()
-                .map(|(_, queue)| queue.lock().iter().sum::<Duration>())
-                .collect::<Vec<_>>()
-        };
+    pub fn format_timing_display(&self, current_tick: u64) -> SmallVec<[String; SystemId::COUNT]> {
+        let stats = self.get_stats(current_tick);
 
-        let mean = duration_sums.iter().sum::<Duration>() / duration_sums.len() as u32;
-        let variance = duration_sums
-            .iter()
-            .map(|x| {
-                let diff_secs = x.as_secs_f64() - mean.as_secs_f64();
-                diff_secs * diff_secs
-            })
-            .sum::<f64>()
-            / (duration_sums.len() - 1).max(1) as f64;
-        let std_dev_secs = variance.sqrt();
-
-        (mean, Duration::from_secs_f64(std_dev_secs))
-    }
-
-    pub fn format_timing_display(&self) -> SmallVec<[String; SystemId::COUNT]> {
-        let stats = self.get_stats();
-        let (total_avg, total_std) = self.get_total_stats();
+        // Get the Total system metrics instead of averaging all systems
+        let (total_avg, total_std) = stats
+            .get(&SystemId::Total)
+            .copied()
+            .unwrap_or((Duration::ZERO, Duration::ZERO));
 
         let effective_fps = match 1.0 / total_avg.as_secs_f64() {
-            f if f > 100.0 => (f as u32).separate_with_commas(),
+            f if f > 100.0 => format!("{:>5} FPS", (f as u32).separate_with_commas()),
             f if f < 10.0 => format!("{:.1} FPS", f),
-            f => format!("{:.0} FPS", f),
+            f => format!("{:5.0} FPS", f),
         };
 
         // Collect timing data for formatting
         let mut timing_data = vec![(effective_fps, total_avg, total_std)];
 
-        // Sort the stats by average duration
-        let mut sorted_stats: Vec<_> = stats.iter().collect();
+        // Sort the stats by average duration, excluding the Total system
+        let mut sorted_stats: Vec<_> = stats.iter().filter(|(id, _)| **id != SystemId::Total).collect();
         sorted_stats.sort_by(|a, b| b.1 .0.cmp(&a.1 .0));
 
-        // Add the top 5 most expensive systems
-        for (name, (avg, std_dev)) in sorted_stats.iter().take(7) {
+        // Add the top 7 most expensive systems (excluding Total)
+        for (name, (avg, std_dev)) in sorted_stats.iter().take(9) {
             timing_data.push((name.to_string(), *avg, *std_dev));
         }
 
@@ -188,8 +265,9 @@ where
         system.run((), world);
         let duration = start.elapsed();
 
-        if let Some(timings) = world.get_resource::<SystemTimings>() {
-            timings.add_timing(id, duration);
+        if let (Some(timings), Some(timing)) = (world.get_resource::<SystemTimings>(), world.get_resource::<Timing>()) {
+            let current_tick = timing.get_current_tick();
+            timings.add_timing(id, duration, current_tick);
         }
     }
 }

src/systems/render.rs

@@ -317,6 +317,7 @@ pub fn combined_render_system(
     batched_lines: Res<BatchedLinesResource>,
     debug_state: Res<DebugState>,
     timings: Res<SystemTimings>,
+    timing: Res<crate::systems::profiling::Timing>,
     map: Res<Map>,
     dirty: Res<RenderDirty>,
     renderables: Query<(Entity, &Renderable, &Position), Without<Hidden>>,
@@ -367,6 +368,7 @@ pub fn combined_render_system(
                 &batched_lines,
                 &debug_state,
                 &timings,
+                &timing,
                 &map,
                 &colliders,
                 &cursor,
@@ -381,11 +383,13 @@ pub fn combined_render_system(
     }
 
     // Record timings for each system independently
+    let current_tick = timing.get_current_tick();
+
     if let Some(duration) = render_duration {
-        timings.add_timing(SystemId::Render, duration);
+        timings.add_timing(SystemId::Render, duration, current_tick);
     }
     if let Some(duration) = debug_render_duration {
-        timings.add_timing(SystemId::DebugRender, duration);
+        timings.add_timing(SystemId::DebugRender, duration, current_tick);
     }
 }
 

src/texture/mod.rs

@@ -1,5 +1,6 @@
 pub mod animated;
 pub mod blinking;
 pub mod sprite;
+pub mod sprites;
 pub mod text;
 pub mod ttf;

src/texture/sprite.rs

@@ -20,7 +20,8 @@ pub struct MapperFrame {
     pub size: U16Vec2,
 }
 
-#[derive(Copy, Clone, Debug, PartialEq)]
+/// A single tile within a sprite atlas, defined by its position and size.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
 pub struct AtlasTile {
     pub pos: U16Vec2,
     pub size: U16Vec2,
@@ -89,9 +90,11 @@ pub struct SpriteAtlas {
 
 impl SpriteAtlas {
     pub fn new(texture: Texture, mapper: AtlasMapper) -> Self {
+        let tiles = mapper.frames.into_iter().collect();
+
         Self {
             texture,
-            tiles: mapper.frames,
+            tiles,
             default_color: None,
             last_modulation: None,
         }
@@ -103,11 +106,15 @@ impl SpriteAtlas {
     /// for the named sprite, or `None` if the sprite name is not found in the
     /// atlas. The returned tile can be used for immediate rendering or stored
     /// for repeated use in animations and entity sprites.
-    pub fn get_tile(&self, name: &str) -> Option<AtlasTile> {
-        self.tiles.get(name).map(|frame| AtlasTile {
+    pub fn get_tile(&self, name: &str) -> Result<AtlasTile, TextureError> {
+        let frame = self
+            .tiles
+            .get(name)
+            .ok_or_else(|| TextureError::AtlasTileNotFound(name.to_string()))?;
+        Ok(AtlasTile {
             pos: frame.pos,
             size: frame.size,
-            color: None,
+            color: self.default_color,
         })
     }
 

src/texture/sprites.rs

@@ -0,0 +1,104 @@
+//! A structured representation of all sprite assets in the game.
+//!
+//! This module provides a set of enums to represent every sprite, allowing for
+//! type-safe access to asset paths and avoiding the use of raw strings.
+//! The `GameSprite` enum is the main entry point, and its `to_path` method
+//! generates the correct path for a given sprite in the texture atlas.
+
+use crate::map::direction::Direction;
+use crate::systems::components::Ghost;
+
+/// Represents the different sprites for Pac-Man.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum PacmanSprite {
+    /// A moving Pac-Man sprite for a given direction and animation frame.
+    Moving(Direction, u8),
+    /// The full, closed-mouth Pac-Man sprite.
+    Full,
+}
+
+/// Represents the color of a frightened ghost.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum FrightenedColor {
+    Blue,
+    White,
+}
+
+/// Represents the different sprites for ghosts.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum GhostSprite {
+    /// The normal appearance of a ghost for a given type, direction, and animation frame.
+    Normal(Ghost, Direction, u8),
+    /// The frightened appearance of a ghost, with a specific color and animation frame.
+    Frightened(FrightenedColor, u8),
+    /// The "eyes only" appearance of a ghost after being eaten.
+    Eyes(Direction),
+}
+
+/// Represents the different sprites for the maze and collectibles.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum MazeSprite {
+    /// A specific tile of the maze.
+    Tile(u8),
+    /// A standard pellet.
+    Pellet,
+    /// An energizer/power pellet.
+    Energizer,
+}
+
+/// A top-level enum that encompasses all game sprites.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum GameSprite {
+    Pacman(PacmanSprite),
+    Ghost(GhostSprite),
+    Maze(MazeSprite),
+}
+
+impl GameSprite {
+    /// Generates the asset path for the sprite.
+    ///
+    /// This path corresponds to the filename in the texture atlas JSON file.
+    pub fn to_path(self) -> String {
+        match self {
+            GameSprite::Pacman(sprite) => match sprite {
+                PacmanSprite::Moving(dir, frame) => {
+                    let frame_char = match frame {
+                        0 => 'a',
+                        1 => 'b',
+                        _ => panic!("Invalid animation frame"),
+                    };
+                    format!("pacman/{}_{}.png", dir.as_ref().to_lowercase(), frame_char)
+                }
+                PacmanSprite::Full => "pacman/full.png".to_string(),
+            },
+            GameSprite::Ghost(sprite) => match sprite {
+                GhostSprite::Normal(ghost, dir, frame) => {
+                    let frame_char = match frame {
+                        0 => 'a',
+                        1 => 'b',
+                        _ => panic!("Invalid animation frame"),
+                    };
+                    format!("ghost/{}/{}_{}.png", ghost.as_str(), dir.as_ref().to_lowercase(), frame_char)
+                }
+                GhostSprite::Frightened(color, frame) => {
+                    let frame_char = match frame {
+                        0 => 'a',
+                        1 => 'b',
+                        _ => panic!("Invalid animation frame"),
+                    };
+                    let color_str = match color {
+                        FrightenedColor::Blue => "blue",
+                        FrightenedColor::White => "white",
+                    };
+                    format!("ghost/frightened/{}_{}.png", color_str, frame_char)
+                }
+                GhostSprite::Eyes(dir) => format!("ghost/eyes/{}.png", dir.as_ref().to_lowercase()),
+            },
+            GameSprite::Maze(sprite) => match sprite {
+                MazeSprite::Tile(index) => format!("maze/tiles/{}.png", index),
+                MazeSprite::Pellet => "maze/pellet.png".to_string(),
+                MazeSprite::Energizer => "maze/energizer.png".to_string(),
+            },
+        }
+    }
+}

src/texture/text.rs

@@ -60,10 +60,7 @@ use sdl2::pixels::Color;
 use sdl2::render::{Canvas, RenderTarget};
 use std::collections::HashMap;
 
-use crate::{
-    error::{GameError, TextureError},
-    texture::sprite::{AtlasTile, SpriteAtlas},
-};
+use crate::texture::sprite::{AtlasTile, SpriteAtlas};
 
 /// Converts a character to its tile name in the atlas.
 fn char_to_tile_name(c: char) -> Option<String> {
@@ -122,9 +119,7 @@ impl TextTexture {
         }
 
         if let Some(tile_name) = char_to_tile_name(c) {
-            let tile = atlas
-                .get_tile(&tile_name)
-                .ok_or(GameError::Texture(TextureError::AtlasTileNotFound(tile_name)))?;
+            let tile = atlas.get_tile(&tile_name)?;
             self.char_map.insert(c, tile);
             Ok(self.char_map.get(&c))
         } else {

tests/profiling.rs

@@ -22,33 +22,26 @@ macro_rules! assert_close {
 fn test_timing_statistics() {
     let timings = SystemTimings::default();
 
-    // 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));
+    // Add consecutive timing measurements (no skipped ticks to avoid zero padding)
+    timings.add_timing(SystemId::PlayerControls, Duration::from_millis(10), 1);
+    timings.add_timing(SystemId::PlayerControls, Duration::from_millis(12), 2);
+    timings.add_timing(SystemId::PlayerControls, Duration::from_millis(8), 3);
 
-    // 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));
+    // Add consecutive timing measurements for another system
+    timings.add_timing(SystemId::Blinking, Duration::from_millis(3), 1);
+    timings.add_timing(SystemId::Blinking, Duration::from_millis(2), 2);
+    timings.add_timing(SystemId::Blinking, Duration::from_millis(1), 3);
 
     {
-        let stats = timings.get_stats();
+        let stats = timings.get_stats(3);
         let (avg, std_dev) = stats.get(&SystemId::PlayerControls).unwrap();
 
         assert_close!(*avg, Duration::from_millis(10), "PlayerControls average timing");
         assert_close!(*std_dev, Duration::from_millis(2), "PlayerControls standard deviation timing");
     }
 
-    {
-        let (total_avg, total_std) = timings.get_total_stats();
-        assert_close!(total_avg, Duration::from_millis(2), "Total average timing across all systems");
-        assert_close!(
-            total_std,
-            Duration::from_millis(7),
-            "Total standard deviation timing across all systems"
-        );
-    }
+    // Note: get_total_stats() was removed as we now use the Total system directly
+    // This test now focuses on individual system statistics
 }
 
 #[test]
@@ -56,9 +49,9 @@ fn test_default_zero_timing_for_unused_systems() {
     let timings = SystemTimings::default();
 
     // Add timing data for only one system
-    timings.add_timing(SystemId::PlayerControls, Duration::from_millis(5));
+    timings.add_timing(SystemId::PlayerControls, Duration::from_millis(5), 1);
 
-    let stats = timings.get_stats();
+    let stats = timings.get_stats(1);
 
     // Verify all SystemId variants are present in the stats
     let expected_count = SystemId::iter().count();
@@ -69,9 +62,9 @@ fn test_default_zero_timing_for_unused_systems() {
     assert_close!(*avg, Duration::from_millis(5), "System with data should have correct timing");
     assert_close!(*std_dev, Duration::ZERO, "Single measurement should have zero std dev");
 
-    // Verify that all other systems have zero timing
+    // Verify that all other systems have zero timing (excluding Total which is special)
     for id in SystemId::iter() {
-        if id != SystemId::PlayerControls {
+        if id != SystemId::PlayerControls && id != SystemId::Total {
             let (avg, std_dev) = stats.get(&id).unwrap();
             assert_close!(
                 *avg,
@@ -93,12 +86,13 @@ fn test_pre_populated_timing_entries() {
 
     // Verify that we can add timing to any SystemId without panicking
     // (this would fail with the old implementation if the entry didn't exist)
+    // Use the same tick for all systems to avoid zero-padding
     for id in SystemId::iter() {
-        timings.add_timing(id, Duration::from_nanos(1));
+        timings.add_timing(id, Duration::from_nanos(1), 1);
     }
 
     // Verify all systems now have non-zero timing
-    let stats = timings.get_stats();
+    let stats = timings.get_stats(1);
     for id in SystemId::iter() {
         let (avg, _) = stats.get(&id).unwrap();
         assert!(
@@ -108,3 +102,24 @@ fn test_pre_populated_timing_entries() {
         );
     }
 }
+
+#[test]
+fn test_total_system_timing() {
+    let timings = SystemTimings::default();
+
+    // Add some timing data to the Total system
+    timings.add_total_timing(Duration::from_millis(16), 1);
+    timings.add_total_timing(Duration::from_millis(18), 2);
+    timings.add_total_timing(Duration::from_millis(14), 3);
+
+    let stats = timings.get_stats(3);
+    let (avg, std_dev) = stats.get(&SystemId::Total).unwrap();
+
+    // Should have 16ms average (16+18+14)/3 = 16ms
+    assert_close!(*avg, Duration::from_millis(16), "Total system average timing");
+    // Should have some standard deviation
+    assert!(
+        *std_dev > Duration::ZERO,
+        "Total system should have non-zero std dev with multiple measurements"
+    );
+}