feat: measure total system timings using threading indifferent method, padded formatting

You have no idea how much pain this has been causing me.

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"

Justfile

@@ -3,7 +3,7 @@ set windows-shell := ["powershell.exe", "-NoLogo", "-Command"]
 
 # Regex to exclude files from coverage report, double escapes for Justfile + CLI
 # You can use src\\\\..., but the filename alone is acceptable too
-coverage_exclude_pattern := "src\\\\app.rs|audio.rs|src\\\\error.rs|platform\\\\emscripten.rs"
+coverage_exclude_pattern := "src\\\\app\\.rs|audio\\.rs|src\\\\error\\.rs|platform\\\\emscripten\\.rs|bin\\\\.+\\.rs|main\\.rs|platform\\\\desktop\\.rs|platform\\\\tracing_buffer\\.rs|platform\\\\buffered_writer\\.rs|systems\\\\debug\\.rs|systems\\\\profiling\\.rs"
 
 binary_extension := if os() == "windows" { ".exe" } else { "" }
 
@@ -40,5 +40,6 @@ samply:
     samply record ./target/profile/pacman{{ binary_extension }}
 
 # Build the project for Emscripten
-web:
+web *args:
-    bun run web.build.ts
+    bun run web.build.ts {{args}};
+    caddy file-server --root dist

src/app.rs

@@ -1,11 +1,16 @@
+use std::collections::HashMap;
 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;
+use sdl2::render::RendererInfo;
 use sdl2::{AudioSubsystem, Sdl};
+use tracing::debug;
 
 /// Main application wrapper that manages SDL initialization, window lifecycle, and the game loop.
 ///
@@ -50,15 +55,51 @@ impl App {
             .build()
             .map_err(|e| GameError::Sdl(e.to_string()))?;
 
+        #[derive(Debug)]
+        struct DriverDetail {
+            info: RendererInfo,
+            index: usize,
+        }
+
+        let drivers: HashMap<&'static str, DriverDetail> = sdl2::render::drivers()
+            .enumerate()
+            .map(|(index, d)| (d.name, DriverDetail { info: d, index }))
+            .collect::<HashMap<_, _>>();
+
+        let get_driver =
+            |name: &'static str| -> Option<u32> { drivers.get(name.to_lowercase().as_str()).map(|d| d.index as u32) };
+
+        {
+            let mut names = drivers.keys().collect::<Vec<_>>();
+            names.sort_by_key(|k| get_driver(k));
+            debug!("Drivers: {names:?}")
+        }
+
+        // Count the number of times each pixel format is supported by each driver
+        let pixel_format_counts: HashMap<PixelFormatEnum, usize> = drivers
+            .values()
+            .flat_map(|d| d.info.texture_formats.iter())
+            .fold(HashMap::new(), |mut counts, format| {
+                *counts.entry(*format).or_insert(0) += 1;
+                counts
+            });
+
+        debug!("Pixel format counts: {pixel_format_counts:?}");
+
+        let index = get_driver("direct3d");
+        debug!("Driver index: {index:?}");
+
         let mut canvas = window
             .into_canvas()
             .accelerated()
+            // .index(index)
             .build()
             .map_err(|e| GameError::Sdl(e.to_string()))?;
 
         canvas
             .set_logical_size(CANVAS_SIZE.x, CANVAS_SIZE.y)
             .map_err(|e| GameError::Sdl(e.to_string()))?;
+        debug!("Renderer: {:?}", canvas.info());
 
         let texture_creator = canvas.texture_creator();
 
@@ -91,6 +132,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/bin/aspect_demo.rs

@@ -0,0 +1,130 @@
+use std::time::{Duration, Instant};
+
+use sdl2::event::Event;
+use sdl2::keyboard::Keycode;
+use sdl2::pixels::Color;
+use sdl2::rect::Rect;
+
+// A self-contained SDL2 demo showing how to keep a consistent aspect ratio
+// with letterboxing/pillarboxing in a resizable window.
+//
+// This uses SDL2's logical size feature, which automatically sets a viewport
+// to preserve the target aspect ratio and adds black bars as needed.
+// We also clear the full window to black and then clear the logical viewport
+// to a content color, so bars remain visibly black.
+
+const LOGICAL_WIDTH: u32 = 320; // target content width
+const LOGICAL_HEIGHT: u32 = 180; // target content height (16:9)
+
+fn main() -> Result<(), String> {
+    // Initialize SDL2
+    let sdl = sdl2::init()?;
+    let video = sdl.video()?;
+
+    // Create a resizable window
+    let window = video
+        .window("SDL2 Aspect Ratio Demo", 960, 540)
+        .resizable()
+        .position_centered()
+        .build()
+        .map_err(|e| e.to_string())?;
+
+    let mut canvas = window.into_canvas().build().map_err(|e| e.to_string())?;
+
+    // Set the desired logical (virtual) resolution. SDL will letterbox/pillarbox
+    // as needed to preserve this aspect ratio when the window is resized.
+    canvas
+        .set_logical_size(LOGICAL_WIDTH, LOGICAL_HEIGHT)
+        .map_err(|e| e.to_string())?;
+    // Optional: uncomment to enforce integer scaling only (more retro look)
+    // canvas.set_integer_scale(true)?;
+
+    let mut events = sdl.event_pump()?;
+
+    let mut running = true;
+    let start = Instant::now();
+    let mut last_log = Instant::now();
+
+    while running {
+        for event in events.poll_iter() {
+            match event {
+                Event::Quit { .. }
+                | Event::KeyDown {
+                    keycode: Some(Keycode::Escape),
+                    ..
+                } => {
+                    running = false;
+                }
+                Event::Window { win_event, .. } => {
+                    // Periodically log window size and the computed viewport
+                    // to demonstrate how letterboxing/pillarboxing behaves.
+                    use sdl2::event::WindowEvent;
+                    match win_event {
+                        WindowEvent::Resized(_, _)
+                        | WindowEvent::SizeChanged(_, _)
+                        | WindowEvent::Maximized
+                        | WindowEvent::Restored => {
+                            if last_log.elapsed() > Duration::from_millis(250) {
+                                let out_size = canvas.output_size()?;
+                                let viewport = canvas.viewport();
+                                println!(
+                                    "window={}x{}, viewport x={}, y={}, w={}, h={}",
+                                    out_size.0,
+                                    out_size.1,
+                                    viewport.x(),
+                                    viewport.y(),
+                                    viewport.width(),
+                                    viewport.height()
+                                );
+                                last_log = Instant::now();
+                            }
+                        }
+                        _ => {}
+                    }
+                }
+                _ => {}
+            }
+        }
+
+        // 1) Clear the entire window to black (no viewport) so the bars are black
+        canvas.set_viewport(None);
+        canvas.set_draw_color(Color::RGB(0, 0, 0));
+        canvas.clear();
+
+        // 2) Re-apply logical size so SDL sets a viewport that preserves aspect
+        //    ratio. Clearing now only affects the letterboxed content area.
+        canvas
+            .set_logical_size(LOGICAL_WIDTH, LOGICAL_HEIGHT)
+            .map_err(|e| e.to_string())?;
+
+        // Fill the content area with a background color to differentiate from bars
+        canvas.set_draw_color(Color::RGB(30, 30, 40));
+        canvas.clear();
+
+        // Draw a simple grid to visualize scaling clearly
+        canvas.set_draw_color(Color::RGB(60, 60, 90));
+        let step = 20i32;
+        for x in (0..=LOGICAL_WIDTH as i32).step_by(step as usize) {
+            let _ = canvas.draw_line(sdl2::rect::Point::new(x, 0), sdl2::rect::Point::new(x, LOGICAL_HEIGHT as i32));
+        }
+        for y in (0..=LOGICAL_HEIGHT as i32).step_by(step as usize) {
+            let _ = canvas.draw_line(sdl2::rect::Point::new(0, y), sdl2::rect::Point::new(LOGICAL_WIDTH as i32, y));
+        }
+
+        // Draw a border around the logical content area
+        canvas.set_draw_color(Color::RGB(200, 200, 220));
+        let border = Rect::new(0, 0, LOGICAL_WIDTH, LOGICAL_HEIGHT);
+        canvas.draw_rect(border)?;
+
+        // Draw a moving box to demonstrate dynamic content staying within aspect
+        let elapsed_ms = start.elapsed().as_millis() as i32;
+        let t = (elapsed_ms / 8) % LOGICAL_WIDTH as i32;
+        let box_rect = Rect::new(t - 10, (LOGICAL_HEIGHT as i32 / 2) - 10, 20, 20);
+        canvas.set_draw_color(Color::RGB(255, 140, 0));
+        canvas.fill_rect(box_rect).ok();
+
+        canvas.present();
+    }
+
+    Ok(())
+}

src/constants.rs

@@ -49,6 +49,13 @@ pub const CANVAS_SIZE: UVec2 = UVec2::new(
     (BOARD_CELL_SIZE.y + BOARD_CELL_OFFSET.y) * CELL_SIZE,
 );
 
+pub const LARGE_SCALE: f32 = 2.6;
+
+pub const LARGE_CANVAS_SIZE: UVec2 = UVec2::new(
+    (((BOARD_CELL_SIZE.x + BOARD_CELL_OFFSET.x) * CELL_SIZE) as f32 * LARGE_SCALE) as u32,
+    (((BOARD_CELL_SIZE.y + BOARD_CELL_OFFSET.y) * CELL_SIZE) as f32 * LARGE_SCALE) as u32,
+);
+
 /// Collider size constants for different entity types
 pub mod collider {
     use super::CELL_SIZE;

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

@@ -13,6 +13,7 @@ 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::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,
@@ -108,9 +109,9 @@ impl Game {
             EventType::ControllerTouchpadDown,
             EventType::ControllerTouchpadMotion,
             EventType::ControllerTouchpadUp,
-            EventType::FingerDown,
+            // EventType::FingerDown,  // Enable for touch controls
-            EventType::FingerUp,
+            // EventType::FingerUp,    // Enable for touch controls
-            EventType::FingerMotion,
+            // EventType::FingerMotion, // Enable for touch controls
             EventType::DollarGesture,
             EventType::DollarRecord,
             EventType::MultiGesture,
@@ -127,12 +128,11 @@ impl Game {
             EventType::TextInput,
             EventType::TextEditing,
             EventType::Display,
-            EventType::Window,
+            // EventType::Window,
             EventType::MouseWheel,
             // EventType::MouseMotion,
-            EventType::MouseButtonDown,
+            // EventType::MouseButtonDown,  // Enable for desktop touch testing
-            EventType::MouseButtonUp,
+            // EventType::MouseButtonUp,    // Enable for desktop touch testing
-            EventType::MouseButtonDown,
             EventType::AppDidEnterBackground,
             EventType::AppWillEnterForeground,
             EventType::AppWillEnterBackground,
@@ -157,9 +157,9 @@ impl Game {
         map_texture.set_scale_mode(ScaleMode::Nearest);
 
         // Create debug texture at output resolution for crisp debug rendering
-        let output_size = canvas.output_size().unwrap();
+        let output_size = constants::LARGE_CANVAS_SIZE;
         let mut debug_texture = texture_creator
-            .create_texture_target(None, output_size.0, output_size.1)
+            .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
@@ -317,6 +317,7 @@ impl Game {
         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,
@@ -388,6 +389,7 @@ impl Game {
                 dirty_render_system,
                 combined_render_system,
                 hud_render_system,
+                touch_ui_render_system,
                 present_system,
             )
                 .chain(),
@@ -657,8 +659,15 @@ impl Game {
     pub fn tick(&mut self, dt: f32) -> bool {
         self.world.insert_resource(DeltaTime(dt));
 
-        // Run all 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();
+
+        // Record the total timing
+        if let Some(timings) = self.world.get_resource::<systems::profiling::SystemTimings>() {
+            timings.add_total_timing(total_duration);
+        }
 
         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

@@ -2,7 +2,7 @@
 #![windows_subsystem = "windows"]
 
 use crate::{app::App, constants::LOOP_TIME};
-use tracing::{debug, info, warn};
+use tracing::info;
 
 mod app;
 mod asset;
@@ -11,6 +11,7 @@ mod constants;
 
 mod error;
 mod events;
+mod formatter;
 mod game;
 mod map;
 mod platform;
@@ -22,19 +23,9 @@ mod texture;
 /// This function initializes SDL, the window, the game state, and then enters
 /// the main game loop.
 pub fn main() {
-    if platform::requires_console() {
+    // On Windows, this connects output streams to the console dynamically
-        // Setup buffered tracing subscriber that will buffer logs until console is ready
+    // On Emscripten, this connects the subscriber to the browser console
-        let switchable_writer = platform::tracing_buffer::setup_switchable_subscriber();
+    platform::init_console().expect("Could not initialize console");
-
-        // Initialize platform-specific console
-        platform::init_console().expect("Could not initialize console");
-
-        // Now that console is initialized, flush buffered logs and switch to direct output
-        debug!("Switching to direct logging mode and flushing buffer...");
-        if let Err(error) = switchable_writer.switch_to_direct_mode() {
-            warn!("Failed to flush buffered logs to console: {error:?}");
-        }
-    }
 
     let mut app = App::new().expect("Could not create app");
 

src/platform/buffered_writer.rs

@@ -1,55 +0,0 @@
-//! 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

@@ -20,9 +20,13 @@ pub fn sleep(duration: Duration, focused: bool) {
 pub fn init_console() -> Result<(), PlatformError> {
     #[cfg(windows)]
     {
+        use crate::platform::tracing_buffer::setup_switchable_subscriber;
         use tracing::{debug, info};
         use windows::Win32::System::Console::GetConsoleWindow;
 
+        // Setup buffered tracing subscriber that will buffer logs until console is ready
+        let switchable_writer = setup_switchable_subscriber();
+
         // Check if we already have a console window
         if unsafe { !GetConsoleWindow().0.is_null() } {
             debug!("Already have a console window");
@@ -40,15 +44,19 @@ pub fn init_console() -> Result<(), PlatformError> {
             attach_to_parent_console()?;
             info!("Successfully attached to parent console");
         }
+
+        // Now that console is initialized, flush buffered logs and switch to direct output
+        debug!("Switching to direct logging mode and flushing buffer...");
+        if let Err(error) = switchable_writer.switch_to_direct_mode() {
+            use tracing::warn;
+
+            warn!("Failed to flush buffered logs to console: {error:?}");
+        }
     }
 
     Ok(())
 }
 
-pub fn requires_console() -> bool {
-    cfg!(windows)
-}
-
 pub fn get_asset_bytes(asset: Asset) -> Result<Cow<'static, [u8]>, AssetError> {
     match asset {
         Asset::Wav1 => Ok(Cow::Borrowed(include_bytes!("../../assets/game/sound/waka/1.ogg"))),

src/platform/emscripten.rs

@@ -1,18 +1,22 @@
 //! Emscripten platform implementation.
 
-use std::borrow::Cow;
-use std::time::Duration;
-
 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;
+use std::ffi::CString;
+use std::io::{self, Read, Write};
+use std::time::Duration;
 
 // Emscripten FFI functions
 #[allow(dead_code)]
 extern "C" {
-    fn emscripten_get_now() -> f64;
     fn emscripten_sleep(ms: u32);
     fn emscripten_get_element_css_size(target: *const u8, width: *mut f64, height: *mut f64) -> i32;
+    // Standard C functions that Emscripten redirects to console
+    fn printf(format: *const u8, ...) -> i32;
 }
 
 pub fn sleep(duration: Duration, _focused: bool) {
@@ -22,13 +26,46 @@ pub fn sleep(duration: Duration, _focused: bool) {
 }
 
 pub fn init_console() -> Result<(), PlatformError> {
-    Ok(()) // No-op for Emscripten
+    use tracing_subscriber::{fmt, layer::SubscriberExt, EnvFilter};
+
+    // Set up a custom tracing subscriber that writes directly to emscripten console
+    let subscriber = tracing_subscriber::registry()
+        .with(
+            fmt::layer()
+                .with_writer(|| EmscriptenConsoleWriter)
+                .with_ansi(false)
+                .event_format(CustomFormatter),
+        )
+        .with(EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("debug")));
+
+    tracing::subscriber::set_global_default(subscriber)
+        .map_err(|e| PlatformError::ConsoleInit(format!("Failed to set tracing subscriber: {}", e)))?;
+
+    Ok(())
 }
 
-pub fn requires_console() -> bool {
+/// A writer that outputs to the browser console via printf (redirected by emscripten)
-    false
+struct EmscriptenConsoleWriter;
+
+impl Write for EmscriptenConsoleWriter {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        if let Ok(s) = std::str::from_utf8(buf) {
+            if let Ok(cstr) = CString::new(s.trim_end_matches('\n')) {
+                let format_str = CString::new("%s\n").unwrap();
+                unsafe {
+                    printf(format_str.as_ptr().cast(), cstr.as_ptr());
+                }
+            }
+        }
+        Ok(buf.len())
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
 }
 
+#[allow(dead_code)]
 pub fn get_canvas_size() -> Option<(u32, u32)> {
     let mut width = 0.0;
     let mut height = 0.0;
@@ -43,18 +80,13 @@ pub fn get_canvas_size() -> Option<(u32, u32)> {
 }
 
 pub fn get_asset_bytes(asset: Asset) -> Result<Cow<'static, [u8]>, AssetError> {
-    use sdl2::rwops::RWops;
-    use std::io::Read;
-
     let path = format!("assets/game/{}", asset.path());
     let mut rwops = RWops::from_file(&path, "rb").map_err(|_| AssetError::NotFound(asset.path().to_string()))?;
 
     let len = rwops.len().ok_or_else(|| AssetError::NotFound(asset.path().to_string()))?;
 
     let mut buf = vec![0u8; len];
-    rwops
+    rwops.read_exact(&mut buf).map_err(|e| AssetError::Io(io::Error::other(e)))?;
-        .read_exact(&mut buf)
-        .map_err(|e| AssetError::Io(std::io::Error::other(e)))?;
 
     Ok(Cow::Owned(buf))
 }

src/platform/mod.rs

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

src/platform/tracing_buffer.rs

@@ -1,12 +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 {
@@ -88,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/collision.rs

@@ -142,8 +142,6 @@ pub fn ghost_collision_system(
                         events.write(AudioEvent::PlayEat);
                     } else {
                         // Pac-Man dies (this would need a death system)
-                        // For now, just log it
-                        tracing::warn!("Pac-Man collided with ghost while not frightened!");
                     }
                 }
             }

src/systems/debug.rs

@@ -1,13 +1,13 @@
 //! Debug rendering system
 use std::cmp::Ordering;
 
-use crate::constants::{BOARD_PIXEL_OFFSET, CANVAS_SIZE};
+use crate::constants::{self, BOARD_PIXEL_OFFSET};
 use crate::map::builder::Map;
 use crate::systems::{Collider, CursorPosition, NodeId, Position, SystemTimings};
 use crate::texture::ttf::{TtfAtlas, TtfRenderer};
 use bevy_ecs::resource::Resource;
 use bevy_ecs::system::{Query, Res};
-use glam::{IVec2, UVec2, Vec2};
+use glam::{IVec2, Vec2};
 use sdl2::pixels::Color;
 use sdl2::rect::{Point, Rect};
 use sdl2::render::{Canvas, Texture};
@@ -215,10 +215,6 @@ pub fn debug_render_system(
     if !debug_state.enabled {
         return;
     }
-    let output = UVec2::from(canvas.output_size().unwrap()).as_vec2();
-    let logical = CANVAS_SIZE.as_vec2();
-    let scale = (output / logical).min_element();
-
     // Create debug text renderer
     let text_renderer = TtfRenderer::new(1.0);
 
@@ -251,8 +247,8 @@ pub fn debug_render_system(
                 let pos = position.get_pixel_position(&map.graph).unwrap();
 
                 // Transform position and size using common methods
-                let pos = (pos * scale).as_ivec2();
+                let pos = (pos * constants::LARGE_SCALE).as_ivec2();
-                let size = (collider.size * scale) as u32;
+                let size = (collider.size * constants::LARGE_SCALE) as u32;
 
                 Rect::from_center(Point::from((pos.x, pos.y)), size, size)
             })
@@ -268,7 +264,7 @@ pub fn debug_render_system(
     }
 
     canvas.set_draw_color(Color {
-        a: f32_to_u8(0.6),
+        a: f32_to_u8(0.65),
         ..Color::RED
     });
     canvas.set_blend_mode(sdl2::render::BlendMode::Blend);
@@ -282,8 +278,8 @@ pub fn debug_render_system(
             .nodes()
             .enumerate()
             .filter_map(|(id, node)| {
-                let pos = transform_position_with_offset(node.position, scale);
+                let pos = transform_position_with_offset(node.position, constants::LARGE_SCALE);
-                let size = (2.0 * scale) as u32;
+                let size = (2.0 * constants::LARGE_SCALE) as u32;
                 let rect = Rect::new(pos.x - (size as i32 / 2), pos.y - (size as i32 / 2), size, size);
 
                 // If the node is the one closest to the cursor, draw it immediately
@@ -313,7 +309,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 as NodeId).unwrap();
-        let pos = transform_position_with_offset(node.position, scale);
+        let pos = transform_position_with_offset(node.position, constants::LARGE_SCALE);
 
         let node_id_text = closest_node_id.to_string();
         let text_pos = Vec2::new((pos.x + 10) as f32, (pos.y - 5) as f32);
@@ -325,7 +321,7 @@ pub fn debug_render_system(
                 &node_id_text,
                 text_pos,
                 Color {
-                    a: f32_to_u8(0.4),
+                    a: f32_to_u8(0.9),
                     ..Color::WHITE
                 },
             )

src/systems/input.rs

@@ -6,8 +6,13 @@ use bevy_ecs::{
     system::{NonSendMut, Res, ResMut},
 };
 use glam::Vec2;
-use sdl2::{event::Event, keyboard::Keycode, EventPump};
+use sdl2::{
+    event::{Event, WindowEvent},
+    keyboard::Keycode,
+    EventPump,
+};
 use smallvec::{smallvec, SmallVec};
+use tracing::{debug, info};
 
 use crate::systems::components::DeltaTime;
 use crate::{
@@ -15,6 +20,12 @@ use crate::{
     map::direction::Direction,
 };
 
+// Touch input constants
+const TOUCH_DIRECTION_THRESHOLD: f32 = 10.0;
+const TOUCH_EASING_DISTANCE_THRESHOLD: f32 = 1.0;
+const MAX_TOUCH_MOVEMENT_SPEED: f32 = 100.0;
+const TOUCH_EASING_FACTOR: f32 = 1.5;
+
 #[derive(Resource, Default, Debug, Copy, Clone)]
 pub enum CursorPosition {
     #[default]
@@ -25,6 +36,30 @@ pub enum CursorPosition {
     },
 }
 
+#[derive(Resource, Default, Debug)]
+pub struct TouchState {
+    pub active_touch: Option<TouchData>,
+}
+
+#[derive(Debug, Clone)]
+pub struct TouchData {
+    pub finger_id: i64,
+    pub start_pos: Vec2,
+    pub current_pos: Vec2,
+    pub current_direction: Option<Direction>,
+}
+
+impl TouchData {
+    pub fn new(finger_id: i64, start_pos: Vec2) -> Self {
+        Self {
+            finger_id,
+            start_pos,
+            current_pos: start_pos,
+            current_direction: None,
+        }
+    }
+}
+
 #[derive(Resource, Debug, Clone)]
 pub struct Bindings {
     key_bindings: HashMap<Keycode, GameCommand>,
@@ -125,12 +160,62 @@ pub fn process_simple_key_events(bindings: &mut Bindings, frame_events: &[Simple
     emitted_events
 }
 
+/// Calculates the primary direction from a 2D vector delta
+fn calculate_direction_from_delta(delta: Vec2) -> Direction {
+    if delta.x.abs() > delta.y.abs() {
+        if delta.x > 0.0 {
+            Direction::Right
+        } else {
+            Direction::Left
+        }
+    } else if delta.y > 0.0 {
+        Direction::Down
+    } else {
+        Direction::Up
+    }
+}
+
+/// Updates the touch reference position with easing
+///
+/// This slowly moves the start_pos towards the current_pos, with the speed
+/// decreasing as the distance gets smaller. The maximum movement speed is capped.
+/// Returns the delta vector and its length for reuse by the caller.
+fn update_touch_reference_position(touch_data: &mut TouchData, delta_time: f32) -> (Vec2, f32) {
+    // Calculate the vector from start to current position
+    let delta = touch_data.current_pos - touch_data.start_pos;
+    let distance = delta.length();
+
+    // If there's no significant distance, nothing to do
+    if distance < TOUCH_EASING_DISTANCE_THRESHOLD {
+        return (delta, distance);
+    }
+
+    // Calculate speed based on distance (slower as it gets closer)
+    // The easing function creates a curve where movement slows down as it approaches the target
+    let speed = (distance / TOUCH_EASING_FACTOR).min(MAX_TOUCH_MOVEMENT_SPEED);
+
+    // Calculate movement distance for this frame
+    let movement_amount = speed * delta_time;
+
+    // If the movement would overshoot, just set to target
+    if movement_amount >= distance {
+        touch_data.start_pos = touch_data.current_pos;
+    } else {
+        // Use direct vector scaling instead of normalization
+        let scale_factor = movement_amount / distance;
+        touch_data.start_pos += delta * scale_factor;
+    }
+
+    (delta, distance)
+}
+
 pub fn input_system(
     delta_time: Res<DeltaTime>,
     mut bindings: ResMut<Bindings>,
     mut writer: EventWriter<GameEvent>,
     mut pump: NonSendMut<EventPump>,
     mut cursor: ResMut<CursorPosition>,
+    mut touch_state: ResMut<TouchState>,
 ) {
     let mut cursor_seen = false;
     // Collect all events for this frame.
@@ -159,6 +244,43 @@ pub fn input_system(
                     remaining_time: 0.20,
                 };
                 cursor_seen = true;
+
+                // Handle mouse motion as touch motion for desktop testing
+                if let Some(ref mut touch_data) = touch_state.active_touch {
+                    touch_data.current_pos = Vec2::new(x as f32, y as f32);
+                }
+            }
+            // Handle mouse events as touch for desktop testing
+            Event::MouseButtonDown { x, y, .. } => {
+                let pos = Vec2::new(x as f32, y as f32);
+                touch_state.active_touch = Some(TouchData::new(0, pos)); // Use ID 0 for mouse
+            }
+            Event::MouseButtonUp { .. } => {
+                touch_state.active_touch = None;
+            }
+            // Handle actual touch events for mobile
+            Event::FingerDown { finger_id, x, y, .. } => {
+                // Convert normalized coordinates (0.0-1.0) to screen coordinates
+                let screen_x = x * crate::constants::CANVAS_SIZE.x as f32;
+                let screen_y = y * crate::constants::CANVAS_SIZE.y as f32;
+                let pos = Vec2::new(screen_x, screen_y);
+                touch_state.active_touch = Some(TouchData::new(finger_id, pos));
+            }
+            Event::FingerMotion { finger_id, x, y, .. } => {
+                if let Some(ref mut touch_data) = touch_state.active_touch {
+                    if touch_data.finger_id == finger_id {
+                        let screen_x = x * crate::constants::CANVAS_SIZE.x as f32;
+                        let screen_y = y * crate::constants::CANVAS_SIZE.y as f32;
+                        touch_data.current_pos = Vec2::new(screen_x, screen_y);
+                    }
+                }
+            }
+            Event::FingerUp { finger_id, .. } => {
+                if let Some(ref touch_data) = touch_state.active_touch {
+                    if touch_data.finger_id == finger_id {
+                        touch_state.active_touch = None;
+                    }
+                }
             }
             Event::KeyDown { keycode, repeat, .. } => {
                 if let Some(key) = keycode {
@@ -176,6 +298,17 @@ 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);
+                }
+                _ => {
+                    debug!("Window event: {:?}", win_event);
+                }
+            },
+            Event::RenderTargetsReset { .. } => {
+                // No-op
+            }
             _ => {
                 tracing::warn!("Unhandled event, consider disabling: {:?}", event);
             }
@@ -188,6 +321,25 @@ pub fn input_system(
         writer.write(event);
     }
 
+    // Update touch reference position with easing
+    if let Some(ref mut touch_data) = touch_state.active_touch {
+        // Apply easing to the reference position and get the delta for direction calculation
+        let (delta, distance) = update_touch_reference_position(touch_data, delta_time.0);
+
+        // Check for direction based on updated reference position
+        if distance >= TOUCH_DIRECTION_THRESHOLD {
+            let direction = calculate_direction_from_delta(delta);
+
+            // Only send command if direction has changed
+            if touch_data.current_direction != Some(direction) {
+                touch_data.current_direction = Some(direction);
+                writer.write(GameEvent::Command(GameCommand::MovePlayer(direction)));
+            }
+        } else if touch_data.current_direction.is_some() {
+            touch_data.current_direction = None;
+        }
+    }
+
     if let (false, CursorPosition::Some { remaining_time, .. }) = (cursor_seen, &mut *cursor) {
         *remaining_time -= delta_time.0;
         if *remaining_time <= 0.0 {

src/systems/profiling.rs

@@ -18,6 +18,7 @@ const TIMING_WINDOW_SIZE: usize = 30;
 
 #[derive(EnumCount, EnumIter, IntoStaticStr, Debug, PartialEq, Eq, Hash, Copy, Clone)]
 pub enum SystemId {
+    Total,
     Input,
     PlayerControls,
     Ghost,
@@ -85,6 +86,11 @@ impl SystemTimings {
         queue.lock().push_back(duration);
     }
 
+    /// Add timing for the Total system (total frame time including scheduler.run)
+    pub fn add_total_timing(&self, duration: Duration) {
+        self.add_timing(SystemId::Total, duration);
+    }
+
     pub fn get_stats(&self) -> Map<SystemId, (Duration, Duration), MAX_SYSTEMS> {
         let mut stats = Map::new();
 
@@ -123,47 +129,30 @@ impl SystemTimings {
         stats
     }
 
-    pub fn get_total_stats(&self) -> (Duration, Duration) {
-        let duration_sums = {
-            self.timings
-                .iter()
-                .map(|(_, queue)| queue.lock().iter().sum::<Duration>())
-                .collect::<Vec<_>>()
-        };
-
-        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
+        // Sort the stats by average duration, excluding the Total system
-        let mut sorted_stats: Vec<_> = stats.iter().collect();
+        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
+        // Add the top 7 most expensive systems (excluding Total)
-        for (name, (avg, std_dev)) in sorted_stats.iter().take(7) {
+        for (name, (avg, std_dev)) in sorted_stats.iter().take(9) {
             timing_data.push((name.to_string(), *avg, *std_dev));
         }
 

src/systems/render.rs

@@ -1,6 +1,7 @@
 use crate::constants::CANVAS_SIZE;
 use crate::error::{GameError, TextureError};
 use crate::map::builder::Map;
+use crate::systems::input::TouchState;
 use crate::systems::{
     debug_render_system, BatchedLinesResource, Collider, CursorPosition, DebugState, DebugTextureResource, DeltaTime,
     DirectionalAnimation, LinearAnimation, Position, Renderable, ScoreResource, StartupSequence, SystemId, SystemTimings,
@@ -114,6 +115,79 @@ pub struct MapTextureResource(pub Texture);
 /// A non-send resource for the backbuffer texture. This just wraps the texture with a type so it can be differentiated when exposed as a resource.
 pub struct BackbufferResource(pub Texture);
 
+/// Renders touch UI overlay for mobile/testing.
+pub fn touch_ui_render_system(
+    mut backbuffer: NonSendMut<BackbufferResource>,
+    mut canvas: NonSendMut<&mut Canvas<Window>>,
+    touch_state: Res<TouchState>,
+    mut errors: EventWriter<GameError>,
+) {
+    if let Some(ref touch_data) = touch_state.active_touch {
+        let _ = canvas.with_texture_canvas(&mut backbuffer.0, |canvas| {
+            // Set blend mode for transparency
+            canvas.set_blend_mode(BlendMode::Blend);
+
+            // Draw semi-transparent circle at touch start position
+            canvas.set_draw_color(Color::RGBA(255, 255, 255, 100));
+            let center = Point::new(touch_data.start_pos.x as i32, touch_data.start_pos.y as i32);
+
+            // Draw a simple circle by drawing filled rectangles (basic approach)
+            let radius = 30;
+            for dy in -radius..=radius {
+                for dx in -radius..=radius {
+                    if dx * dx + dy * dy <= radius * radius {
+                        let point = Point::new(center.x + dx, center.y + dy);
+                        if let Err(e) = canvas.draw_point(point) {
+                            errors.write(TextureError::RenderFailed(format!("Touch UI render error: {}", e)).into());
+                            return;
+                        }
+                    }
+                }
+            }
+
+            // Draw direction indicator if we have a direction
+            if let Some(direction) = touch_data.current_direction {
+                canvas.set_draw_color(Color::RGBA(0, 255, 0, 150));
+
+                // Draw arrow indicating direction
+                let arrow_length = 40;
+                let (dx, dy) = match direction {
+                    crate::map::direction::Direction::Up => (0, -arrow_length),
+                    crate::map::direction::Direction::Down => (0, arrow_length),
+                    crate::map::direction::Direction::Left => (-arrow_length, 0),
+                    crate::map::direction::Direction::Right => (arrow_length, 0),
+                };
+
+                let end_point = Point::new(center.x + dx, center.y + dy);
+                if let Err(e) = canvas.draw_line(center, end_point) {
+                    errors.write(TextureError::RenderFailed(format!("Touch arrow render error: {}", e)).into());
+                }
+
+                // Draw arrowhead (simple approach)
+                let arrow_size = 8;
+                match direction {
+                    crate::map::direction::Direction::Up => {
+                        let _ = canvas.draw_line(end_point, Point::new(end_point.x - arrow_size, end_point.y + arrow_size));
+                        let _ = canvas.draw_line(end_point, Point::new(end_point.x + arrow_size, end_point.y + arrow_size));
+                    }
+                    crate::map::direction::Direction::Down => {
+                        let _ = canvas.draw_line(end_point, Point::new(end_point.x - arrow_size, end_point.y - arrow_size));
+                        let _ = canvas.draw_line(end_point, Point::new(end_point.x + arrow_size, end_point.y - arrow_size));
+                    }
+                    crate::map::direction::Direction::Left => {
+                        let _ = canvas.draw_line(end_point, Point::new(end_point.x + arrow_size, end_point.y - arrow_size));
+                        let _ = canvas.draw_line(end_point, Point::new(end_point.x + arrow_size, end_point.y + arrow_size));
+                    }
+                    crate::map::direction::Direction::Right => {
+                        let _ = canvas.draw_line(end_point, Point::new(end_point.x - arrow_size, end_point.y - arrow_size));
+                        let _ = canvas.draw_line(end_point, Point::new(end_point.x - arrow_size, end_point.y + arrow_size));
+                    }
+                }
+            }
+        });
+    }
+}
+
 /// Renders the HUD (score, lives, etc.) on top of the game.
 pub fn hud_render_system(
     mut backbuffer: NonSendMut<BackbufferResource>,

tests/animated.rs

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

tests/blinking.rs

@@ -1,19 +1,10 @@
-use glam::U16Vec2;
 use pacman::texture::blinking::BlinkingTexture;
-use pacman::texture::sprite::AtlasTile;
-use sdl2::pixels::Color;
 
-fn mock_atlas_tile(id: u32) -> AtlasTile {
+mod common;
-    AtlasTile {
-        pos: U16Vec2::new(0, 0),
-        size: U16Vec2::new(16, 16),
-        color: Some(Color::RGB(id as u8, 0, 0)),
-    }
-}
 
 #[test]
 fn test_blinking_texture() {
-    let tile = mock_atlas_tile(1);
+    let tile = common::mock_atlas_tile(1);
     let mut texture = BlinkingTexture::new(tile, 0.5);
 
     assert!(texture.is_on());
@@ -30,7 +21,7 @@ fn test_blinking_texture() {
 
 #[test]
 fn test_blinking_texture_partial_duration() {
-    let tile = mock_atlas_tile(1);
+    let tile = common::mock_atlas_tile(1);
     let mut texture = BlinkingTexture::new(tile, 0.5);
 
     texture.tick(0.625);
@@ -40,7 +31,7 @@ fn test_blinking_texture_partial_duration() {
 
 #[test]
 fn test_blinking_texture_negative_time() {
-    let tile = mock_atlas_tile(1);
+    let tile = common::mock_atlas_tile(1);
     let mut texture = BlinkingTexture::new(tile, 0.5);
 
     texture.tick(-0.1);

tests/collision.rs

@@ -1,73 +1,7 @@
-use bevy_ecs::{entity::Entity, event::Events, system::RunSystemOnce, world::World};
+use bevy_ecs::system::RunSystemOnce;
+use pacman::systems::{check_collision, collision_system, Collider, EntityType, GhostState, Position};
 
-use pacman::{
+mod common;
-    error::GameError,
-    events::GameEvent,
-    map::builder::Map,
-    systems::{
-        check_collision, collision_system, Collider, EntityType, Ghost, GhostCollider, ItemCollider, NodeId, PacmanCollider,
-        Position,
-    },
-};
-
-fn create_test_world() -> World {
-    let mut world = World::new();
-
-    // Add required resources
-    world.insert_resource(Events::<GameEvent>::default());
-    world.insert_resource(Events::<GameError>::default());
-
-    // Add a minimal test map
-    world.insert_resource(create_test_map());
-
-    world
-}
-
-fn create_test_map() -> Map {
-    use pacman::constants::RAW_BOARD;
-    Map::new(RAW_BOARD).expect("Failed to create test map")
-}
-
-fn spawn_test_pacman(world: &mut World) -> Entity {
-    world
-        .spawn((Position::Stopped { node: 0 }, Collider { size: 10.0 }, PacmanCollider))
-        .id()
-}
-
-fn spawn_test_item(world: &mut World) -> Entity {
-    world
-        .spawn((
-            Position::Stopped { node: 0 },
-            Collider { size: 8.0 },
-            ItemCollider,
-            EntityType::Pellet,
-        ))
-        .id()
-}
-
-fn spawn_test_ghost(world: &mut World) -> Entity {
-    world
-        .spawn((
-            Position::Stopped { node: 0 },
-            Collider { size: 12.0 },
-            GhostCollider,
-            Ghost::Blinky,
-            EntityType::Ghost,
-        ))
-        .id()
-}
-
-fn spawn_test_ghost_at_node(world: &mut World, node: usize) -> Entity {
-    world
-        .spawn((
-            Position::Stopped { node: node as NodeId },
-            Collider { size: 12.0 },
-            GhostCollider,
-            Ghost::Blinky,
-            EntityType::Ghost,
-        ))
-        .id()
-}
 
 #[test]
 fn test_collider_collision_detection() {
@@ -81,7 +15,7 @@ fn test_collider_collision_detection() {
 
 #[test]
 fn test_check_collision_helper() {
-    let map = create_test_map();
+    let map = common::create_test_map();
     let pos1 = Position::Stopped { node: 0 };
     let pos2 = Position::Stopped { node: 0 }; // Same position
     let collider1 = Collider { size: 10.0 };
@@ -101,9 +35,9 @@ fn test_check_collision_helper() {
 
 #[test]
 fn test_collision_system_pacman_item() {
-    let mut world = create_test_world();
+    let mut world = common::create_test_world();
-    let _pacman = spawn_test_pacman(&mut world);
+    let _pacman = common::spawn_test_pacman(&mut world, 0);
-    let _item = spawn_test_item(&mut world);
+    let _item = common::spawn_test_item(&mut world, 0, EntityType::Pellet);
 
     // Run collision system - should not panic
     world
@@ -113,9 +47,9 @@ fn test_collision_system_pacman_item() {
 
 #[test]
 fn test_collision_system_pacman_ghost() {
-    let mut world = create_test_world();
+    let mut world = common::create_test_world();
-    let _pacman = spawn_test_pacman(&mut world);
+    let _pacman = common::spawn_test_pacman(&mut world, 0);
-    let _ghost = spawn_test_ghost(&mut world);
+    let _ghost = common::spawn_test_ghost(&mut world, 0, GhostState::Normal);
 
     // Run collision system - should not panic
     world
@@ -125,9 +59,9 @@ fn test_collision_system_pacman_ghost() {
 
 #[test]
 fn test_collision_system_no_collision() {
-    let mut world = create_test_world();
+    let mut world = common::create_test_world();
-    let _pacman = spawn_test_pacman(&mut world);
+    let _pacman = common::spawn_test_pacman(&mut world, 0);
-    let _ghost = spawn_test_ghost_at_node(&mut world, 1); // Different node
+    let _ghost = common::spawn_test_ghost(&mut world, 1, GhostState::Normal); // Different node
 
     // Run collision system - should not panic
     world
@@ -137,10 +71,10 @@ fn test_collision_system_no_collision() {
 
 #[test]
 fn test_collision_system_multiple_entities() {
-    let mut world = create_test_world();
+    let mut world = common::create_test_world();
-    let _pacman = spawn_test_pacman(&mut world);
+    let _pacman = common::spawn_test_pacman(&mut world, 0);
-    let _item = spawn_test_item(&mut world);
+    let _item = common::spawn_test_item(&mut world, 0, EntityType::Pellet);
-    let _ghost = spawn_test_ghost(&mut world);
+    let _ghost = common::spawn_test_ghost(&mut world, 0, GhostState::Normal);
 
     // Run collision system - should not panic
     world

tests/common/mod.rs

@@ -1,12 +1,26 @@
 #![allow(dead_code)]
 
+use bevy_ecs::{entity::Entity, event::Events, world::World};
+use glam::{U16Vec2, Vec2};
 use pacman::{
     asset::{get_asset_bytes, Asset},
+    constants::RAW_BOARD,
+    events::GameEvent,
     game::ATLAS_FRAMES,
-    texture::sprite::{AtlasMapper, SpriteAtlas},
+    map::{
+        builder::Map,
+        direction::Direction,
+        graph::{Graph, Node},
+    },
+    systems::{
+        AudioEvent, AudioState, BufferedDirection, Collider, DebugState, DeltaTime, EntityType, Ghost, GhostCollider, GhostState,
+        GlobalState, ItemCollider, MovementModifiers, PacmanCollider, PlayerControlled, Position, ScoreResource, Velocity,
+    },
+    texture::sprite::{AtlasMapper, AtlasTile, SpriteAtlas},
 };
 use sdl2::{
     image::LoadTexture,
+    pixels::Color,
     render::{Canvas, TextureCreator},
     video::{Window, WindowContext},
     Sdl,
@@ -38,3 +52,122 @@ pub fn create_atlas(canvas: &mut sdl2::render::Canvas<sdl2::video::Window>) -> S
 
     SpriteAtlas::new(texture, atlas_mapper)
 }
+
+/// Creates a simple test graph with 3 connected nodes for testing
+pub fn create_test_graph() -> Graph {
+    let mut graph = Graph::new();
+
+    let node0 = graph.add_node(Node {
+        position: Vec2::new(0.0, 0.0),
+    });
+    let node1 = graph.add_node(Node {
+        position: Vec2::new(16.0, 0.0),
+    });
+    let node2 = graph.add_node(Node {
+        position: Vec2::new(0.0, 16.0),
+    });
+
+    graph.connect(node0, node1, false, None, Direction::Right).unwrap();
+    graph.connect(node0, node2, false, None, Direction::Down).unwrap();
+
+    graph
+}
+
+/// Creates a basic test world with required resources for ECS systems
+pub fn create_test_world() -> World {
+    let mut world = World::new();
+
+    // Add required resources
+    world.insert_resource(Events::<GameEvent>::default());
+    world.insert_resource(Events::<pacman::error::GameError>::default());
+    world.insert_resource(Events::<AudioEvent>::default());
+    world.insert_resource(ScoreResource(0));
+    world.insert_resource(AudioState::default());
+    world.insert_resource(GlobalState { exit: false });
+    world.insert_resource(DebugState::default());
+    world.insert_resource(DeltaTime(1.0 / 60.0)); // 60 FPS
+    world.insert_resource(create_test_map());
+
+    world
+}
+
+/// Creates a test map using the default RAW_BOARD
+pub fn create_test_map() -> Map {
+    Map::new(RAW_BOARD).expect("Failed to create test map")
+}
+
+/// Spawns a test Pac-Man entity at the specified node
+pub fn spawn_test_pacman(world: &mut World, node: usize) -> Entity {
+    world
+        .spawn((
+            Position::Stopped { node: node as u16 },
+            Collider { size: 10.0 },
+            PacmanCollider,
+            EntityType::Player,
+        ))
+        .id()
+}
+
+/// Spawns a controllable test player entity
+pub fn spawn_test_player(world: &mut World, node: usize) -> Entity {
+    world
+        .spawn((
+            PlayerControlled,
+            Position::Stopped { node: node as u16 },
+            Velocity {
+                speed: 1.0,
+                direction: Direction::Right,
+            },
+            BufferedDirection::None,
+            EntityType::Player,
+            MovementModifiers::default(),
+        ))
+        .id()
+}
+
+/// Spawns a test item entity at the specified node
+pub fn spawn_test_item(world: &mut World, node: usize, item_type: EntityType) -> Entity {
+    world
+        .spawn((
+            Position::Stopped { node: node as u16 },
+            Collider { size: 8.0 },
+            ItemCollider,
+            item_type,
+        ))
+        .id()
+}
+
+/// Spawns a test ghost entity at the specified node
+pub fn spawn_test_ghost(world: &mut World, node: usize, ghost_state: GhostState) -> Entity {
+    world
+        .spawn((
+            Position::Stopped { node: node as u16 },
+            Collider { size: 12.0 },
+            GhostCollider,
+            Ghost::Blinky,
+            EntityType::Ghost,
+            ghost_state,
+        ))
+        .id()
+}
+
+/// Sends a game event to the world
+pub fn send_game_event(world: &mut World, event: GameEvent) {
+    let mut events = world.resource_mut::<Events<GameEvent>>();
+    events.send(event);
+}
+
+/// Sends a collision event between two entities
+pub 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));
+}
+
+/// Creates a mock atlas tile for testing
+pub fn mock_atlas_tile(id: u32) -> AtlasTile {
+    AtlasTile {
+        pos: U16Vec2::new(0, 0),
+        size: U16Vec2::new(16, 16),
+        color: Some(Color::RGB(id as u8, 0, 0)),
+    }
+}

tests/events.rs

@@ -1,19 +0,0 @@
-use pacman::events::{GameCommand, GameEvent};
-use pacman::map::direction::Direction;
-
-#[test]
-fn test_game_command_to_game_event_conversion_all_variants() {
-    let commands = vec![
-        GameCommand::Exit,
-        GameCommand::MovePlayer(Direction::Up),
-        GameCommand::ToggleDebug,
-        GameCommand::MuteAudio,
-        GameCommand::ResetLevel,
-        GameCommand::TogglePause,
-    ];
-
-    for command in commands {
-        let event: GameEvent = command.into();
-        assert_eq!(event, GameEvent::Command(command));
-    }
-}

tests/graph.rs

@@ -1,23 +1,7 @@
 use pacman::map::direction::Direction;
 use pacman::map::graph::{Graph, Node, TraversalFlags};
 
-fn create_test_graph() -> Graph {
+mod common;
-    let mut graph = Graph::new();
-    let node1 = graph.add_node(Node {
-        position: glam::Vec2::new(0.0, 0.0),
-    });
-    let node2 = graph.add_node(Node {
-        position: glam::Vec2::new(16.0, 0.0),
-    });
-    let node3 = graph.add_node(Node {
-        position: glam::Vec2::new(0.0, 16.0),
-    });
-
-    graph.connect(node1, node2, false, None, Direction::Right).unwrap();
-    graph.connect(node1, node3, false, None, Direction::Down).unwrap();
-
-    graph
-}
 
 #[test]
 fn test_graph_basic_operations() {
@@ -124,14 +108,14 @@ fn should_error_on_negative_edge_distance() {
 
 #[test]
 fn should_error_on_duplicate_edge_without_replace() {
-    let mut graph = create_test_graph();
+    let mut graph = common::create_test_graph();
     let result = graph.add_edge(0, 1, false, None, Direction::Right, TraversalFlags::ALL);
     assert!(result.is_err());
 }
 
 #[test]
 fn should_allow_replacing_an_edge() {
-    let mut graph = create_test_graph();
+    let mut graph = common::create_test_graph();
     let result = graph.add_edge(0, 1, true, Some(42.0), Direction::Right, TraversalFlags::ALL);
     assert!(result.is_ok());
 
@@ -141,7 +125,7 @@ fn should_allow_replacing_an_edge() {
 
 #[test]
 fn should_find_edge_between_nodes() {
-    let graph = create_test_graph();
+    let graph = common::create_test_graph();
     let edge = graph.find_edge(0, 1);
     assert!(edge.is_some());
     assert_eq!(edge.unwrap().target, 1);

tests/hud.rs

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

tests/item.rs

@@ -1,13 +1,7 @@
-use bevy_ecs::{entity::Entity, event::Events, system::RunSystemOnce, world::World};
+use bevy_ecs::{entity::Entity, system::RunSystemOnce};
+use pacman::systems::{is_valid_item_collision, item_system, EntityType, GhostState, Position, ScoreResource};
 
-use pacman::{
+mod common;
-    events::GameEvent,
-    map::builder::Map,
-    systems::{
-        is_valid_item_collision, item_system, AudioEvent, AudioState, EntityType, Ghost, GhostCollider, GhostState, ItemCollider,
-        PacmanCollider, Position, ScoreResource,
-    },
-};
 
 #[test]
 fn test_calculate_score_for_item() {
@@ -44,62 +38,14 @@ fn test_is_valid_item_collision() {
     assert!(!is_valid_item_collision(EntityType::Player, EntityType::Player));
 }
 
-fn create_test_world() -> World {
-    let mut world = World::new();
-
-    // Add required resources
-    world.insert_resource(ScoreResource(0));
-    world.insert_resource(AudioState::default());
-    world.insert_resource(Events::<GameEvent>::default());
-    world.insert_resource(Events::<AudioEvent>::default());
-    world.insert_resource(Events::<pacman::error::GameError>::default());
-
-    // Add a minimal test map
-    world.insert_resource(create_test_map());
-
-    world
-}
-
-fn create_test_map() -> Map {
-    use pacman::constants::RAW_BOARD;
-    Map::new(RAW_BOARD).expect("Failed to create test map")
-}
-
-fn spawn_test_pacman(world: &mut World) -> Entity {
-    world
-        .spawn((Position::Stopped { node: 0 }, EntityType::Player, PacmanCollider))
-        .id()
-}
-
-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));
-}
-
 #[test]
 fn test_item_system_pellet_collection() {
-    let mut world = create_test_world();
+    let mut world = common::create_test_world();
-    let pacman = spawn_test_pacman(&mut world);
+    let pacman = common::spawn_test_pacman(&mut world, 0);
-    let pellet = spawn_test_item(&mut world, EntityType::Pellet);
+    let pellet = common::spawn_test_item(&mut world, 1, EntityType::Pellet);
 
     // Send collision event
-    send_collision_event(&mut world, pacman, pellet);
+    common::send_collision_event(&mut world, pacman, pellet);
 
     // Run the item system
     world.run_system_once(item_system).expect("System should run successfully");
@@ -119,11 +65,11 @@ fn test_item_system_pellet_collection() {
 
 #[test]
 fn test_item_system_power_pellet_collection() {
-    let mut world = create_test_world();
+    let mut world = common::create_test_world();
-    let pacman = spawn_test_pacman(&mut world);
+    let pacman = common::spawn_test_pacman(&mut world, 0);
-    let power_pellet = spawn_test_item(&mut world, EntityType::PowerPellet);
+    let power_pellet = common::spawn_test_item(&mut world, 1, EntityType::PowerPellet);
 
-    send_collision_event(&mut world, pacman, power_pellet);
+    common::send_collision_event(&mut world, pacman, power_pellet);
 
     world.run_system_once(item_system).expect("System should run successfully");
 
@@ -142,16 +88,16 @@ fn test_item_system_power_pellet_collection() {
 
 #[test]
 fn test_item_system_multiple_collections() {
-    let mut world = create_test_world();
+    let mut world = common::create_test_world();
-    let pacman = spawn_test_pacman(&mut world);
+    let pacman = common::spawn_test_pacman(&mut world, 0);
-    let pellet1 = spawn_test_item(&mut world, EntityType::Pellet);
+    let pellet1 = common::spawn_test_item(&mut world, 1, EntityType::Pellet);
-    let pellet2 = spawn_test_item(&mut world, EntityType::Pellet);
+    let pellet2 = common::spawn_test_item(&mut world, 2, EntityType::Pellet);
-    let power_pellet = spawn_test_item(&mut world, EntityType::PowerPellet);
+    let power_pellet = common::spawn_test_item(&mut world, 3, EntityType::PowerPellet);
 
     // Send multiple collision events
-    send_collision_event(&mut world, pacman, pellet1);
+    common::send_collision_event(&mut world, pacman, pellet1);
-    send_collision_event(&mut world, pacman, pellet2);
+    common::send_collision_event(&mut world, pacman, pellet2);
-    send_collision_event(&mut world, pacman, power_pellet);
+    common::send_collision_event(&mut world, pacman, power_pellet);
 
     world.run_system_once(item_system).expect("System should run successfully");
 
@@ -176,8 +122,8 @@ fn test_item_system_multiple_collections() {
 
 #[test]
 fn test_item_system_ignores_non_item_collisions() {
-    let mut world = create_test_world();
+    let mut world = common::create_test_world();
-    let pacman = spawn_test_pacman(&mut world);
+    let pacman = common::spawn_test_pacman(&mut world, 0);
 
     // Create a ghost entity (not an item)
     let ghost = world.spawn((Position::Stopped { node: 2 }, EntityType::Ghost)).id();
@@ -186,7 +132,7 @@ fn test_item_system_ignores_non_item_collisions() {
     let initial_score = world.resource::<ScoreResource>().0;
 
     // Send collision event between pacman and ghost
-    send_collision_event(&mut world, pacman, ghost);
+    common::send_collision_event(&mut world, pacman, ghost);
 
     world.run_system_once(item_system).expect("System should run successfully");
 
@@ -205,9 +151,9 @@ fn test_item_system_ignores_non_item_collisions() {
 
 #[test]
 fn test_item_system_no_collision_events() {
-    let mut world = create_test_world();
+    let mut world = common::create_test_world();
-    let _pacman = spawn_test_pacman(&mut world);
+    let _pacman = common::spawn_test_pacman(&mut world, 0);
-    let _pellet = spawn_test_item(&mut world, EntityType::Pellet);
+    let _pellet = common::spawn_test_item(&mut world, 1, EntityType::Pellet);
 
     let initial_score = world.resource::<ScoreResource>().0;
 
@@ -227,13 +173,13 @@ fn test_item_system_no_collision_events() {
 
 #[test]
 fn test_item_system_collision_with_missing_entity() {
-    let mut world = create_test_world();
+    let mut world = common::create_test_world();
-    let pacman = spawn_test_pacman(&mut world);
+    let pacman = common::spawn_test_pacman(&mut world, 0);
 
     // Create a fake entity ID that doesn't exist
     let fake_entity = Entity::from_raw(999);
 
-    send_collision_event(&mut world, pacman, fake_entity);
+    common::send_collision_event(&mut world, pacman, fake_entity);
 
     // System should handle gracefully and not crash
     world
@@ -247,15 +193,15 @@ fn test_item_system_collision_with_missing_entity() {
 
 #[test]
 fn test_item_system_preserves_existing_score() {
-    let mut world = create_test_world();
+    let mut world = common::create_test_world();
 
     // Set initial score
     world.insert_resource(ScoreResource(100));
 
-    let pacman = spawn_test_pacman(&mut world);
+    let pacman = common::spawn_test_pacman(&mut world, 0);
-    let pellet = spawn_test_item(&mut world, EntityType::Pellet);
+    let pellet = common::spawn_test_item(&mut world, 1, EntityType::Pellet);
 
-    send_collision_event(&mut world, pacman, pellet);
+    common::send_collision_event(&mut world, pacman, pellet);
 
     world.run_system_once(item_system).expect("System should run successfully");
 
@@ -266,17 +212,17 @@ fn test_item_system_preserves_existing_score() {
 
 #[test]
 fn test_power_pellet_does_not_affect_ghosts_in_eyes_state() {
-    let mut world = create_test_world();
+    let mut world = common::create_test_world();
-    let pacman = spawn_test_pacman(&mut world);
+    let pacman = common::spawn_test_pacman(&mut world, 0);
-    let power_pellet = spawn_test_item(&mut world, EntityType::PowerPellet);
+    let power_pellet = common::spawn_test_item(&mut world, 1, EntityType::PowerPellet);
 
     // Spawn a ghost in Eyes state (returning to ghost house)
-    let eyes_ghost = spawn_test_ghost(&mut world, GhostState::Eyes);
+    let eyes_ghost = common::spawn_test_ghost(&mut world, 2, GhostState::Eyes);
 
     // Spawn a ghost in Normal state
-    let normal_ghost = spawn_test_ghost(&mut world, GhostState::Normal);
+    let normal_ghost = common::spawn_test_ghost(&mut world, 3, GhostState::Normal);
 
-    send_collision_event(&mut world, pacman, power_pellet);
+    common::send_collision_event(&mut world, pacman, power_pellet);
 
     world.run_system_once(item_system).expect("System should run successfully");
 

tests/map_builder.rs

@@ -34,61 +34,3 @@ fn test_map_node_positions() {
         assert_eq!(node.position, expected_pos);
     }
 }
-
-// #[test]
-// fn test_generate_items() {
-//     use pacman::texture::sprite::{AtlasMapper, MapperFrame, SpriteAtlas};
-//     use std::collections::HashMap;
-
-//     let map = Map::new(RAW_BOARD).unwrap();
-
-//     // Create a minimal atlas for testing
-//     let mut frames = HashMap::new();
-//     frames.insert(
-//         "maze/pellet.png".to_string(),
-//         MapperFrame {
-//             x: 0,
-//             y: 0,
-//             width: 8,
-//             height: 8,
-//         },
-//     );
-//     frames.insert(
-//         "maze/energizer.png".to_string(),
-//         MapperFrame {
-//             x: 8,
-//             y: 0,
-//             width: 8,
-//             height: 8,
-//         },
-//     );
-
-//     let mapper = AtlasMapper { frames };
-//     let texture = unsafe { std::mem::transmute::<usize, Texture<'static>>(0usize) };
-//     let atlas = SpriteAtlas::new(texture, mapper);
-
-//     let items = map.generate_items(&atlas).unwrap();
-
-//     // Verify we have items
-//     assert!(!items.is_empty());
-
-//     // Count different types
-//     let pellet_count = items
-//         .iter()
-//         .filter(|item| matches!(item.item_type, pacman::entity::item::ItemType::Pellet))
-//         .count();
-//     let energizer_count = items
-//         .iter()
-//         .filter(|item| matches!(item.item_type, pacman::entity::item::ItemType::Energizer))
-//         .count();
-
-//     // Should have both types
-//     assert_eq!(pellet_count, 240);
-//     assert_eq!(energizer_count, 4);
-
-//     // All items should be uncollected initially
-//     assert!(items.iter().all(|item| !item.is_collected()));
-
-//     // All items should have valid node indices
-//     assert!(items.iter().all(|item| item.node_index < map.graph.node_count()));
-// }

tests/movement.rs

@@ -1,28 +1,8 @@
 use glam::Vec2;
 use pacman::map::direction::Direction;
-use pacman::map::graph::{Graph, Node};
 use pacman::systems::movement::{BufferedDirection, Position, Velocity};
 
-fn create_test_graph() -> Graph {
+mod common;
-    let mut graph = Graph::new();
-
-    // Add a few test nodes
-    let node0 = graph.add_node(Node {
-        position: Vec2::new(0.0, 0.0),
-    });
-    let node1 = graph.add_node(Node {
-        position: Vec2::new(16.0, 0.0),
-    });
-    let node2 = graph.add_node(Node {
-        position: Vec2::new(0.0, 16.0),
-    });
-
-    // Connect them
-    graph.connect(node0, node1, false, None, Direction::Right).unwrap();
-    graph.connect(node0, node2, false, None, Direction::Down).unwrap();
-
-    graph
-}
 
 #[test]
 fn test_position_is_at_node() {
@@ -127,7 +107,7 @@ fn test_position_tick_overshoot_with_overflow() {
 
 #[test]
 fn test_position_get_pixel_position_stopped() {
-    let graph = create_test_graph();
+    let graph = common::create_test_graph();
     let pos = Position::Stopped { node: 0 };
 
     let pixel_pos = pos.get_pixel_position(&graph).unwrap();
@@ -141,7 +121,7 @@ fn test_position_get_pixel_position_stopped() {
 
 #[test]
 fn test_position_get_pixel_position_moving() {
-    let graph = create_test_graph();
+    let graph = common::create_test_graph();
     let pos = Position::Moving {
         from: 0,
         to: 1,

tests/player.rs

@@ -1,63 +1,17 @@
-use bevy_ecs::{entity::Entity, event::Events, system::RunSystemOnce, world::World};
+use bevy_ecs::{event::Events, system::RunSystemOnce};
-
 use pacman::{
     events::{GameCommand, GameEvent},
     map::{
-        builder::Map,
         direction::Direction,
         graph::{Edge, TraversalFlags},
     },
     systems::{
         can_traverse, player_control_system, player_movement_system, AudioState, BufferedDirection, DebugState, DeltaTime,
-        EntityType, GlobalState, MovementModifiers, PlayerControlled, Position, Velocity,
+        EntityType, GlobalState, Position, Velocity,
     },
 };
 
-// Test helper functions for ECS setup
+mod common;
-fn create_test_world() -> World {
-    let mut world = World::new();
-
-    // Add resources
-    world.insert_resource(GlobalState { exit: false });
-    world.insert_resource(DebugState::default());
-    world.insert_resource(AudioState::default());
-    world.insert_resource(DeltaTime(1.0 / 60.0)); // 60 FPS
-    world.insert_resource(Events::<GameEvent>::default());
-    world.insert_resource(Events::<pacman::error::GameError>::default());
-
-    // Create a simple test map with nodes and edges
-    let test_map = create_test_map();
-    world.insert_resource(test_map);
-
-    world
-}
-
-fn create_test_map() -> Map {
-    // Use the actual RAW_BOARD from constants.rs
-    use pacman::constants::RAW_BOARD;
-    Map::new(RAW_BOARD).expect("Failed to create test map")
-}
-
-fn spawn_test_player(world: &mut World) -> Entity {
-    world
-        .spawn((
-            PlayerControlled,
-            Position::Stopped { node: 0 },
-            Velocity {
-                speed: 1.0,
-                direction: Direction::Right,
-            },
-            BufferedDirection::None,
-            EntityType::Player,
-            MovementModifiers::default(),
-        ))
-        .id()
-}
-
-fn send_game_event(world: &mut World, command: GameCommand) {
-    let mut events = world.resource_mut::<Events<GameEvent>>();
-    events.send(GameEvent::Command(command));
-}
 
 #[test]
 fn test_can_traverse_player_on_all_edges() {
@@ -155,17 +109,13 @@ fn test_entity_type_traversal_flags() {
     assert_eq!(EntityType::PowerPellet.traversal_flags(), TraversalFlags::empty());
 }
 
-// ============================================================================
-// ECS System Tests
-// ============================================================================
-
 #[test]
 fn test_player_control_system_move_command() {
-    let mut world = create_test_world();
+    let mut world = common::create_test_world();
-    let _player = spawn_test_player(&mut world);
+    let _player = common::spawn_test_player(&mut world, 0);
 
     // Send move command
-    send_game_event(&mut world, GameCommand::MovePlayer(Direction::Up));
+    common::send_game_event(&mut world, GameEvent::Command(GameCommand::MovePlayer(Direction::Up)));
 
     // Run the system
     world
@@ -190,11 +140,11 @@ fn test_player_control_system_move_command() {
 
 #[test]
 fn test_player_control_system_exit_command() {
-    let mut world = create_test_world();
+    let mut world = common::create_test_world();
-    let _player = spawn_test_player(&mut world);
+    let _player = common::spawn_test_player(&mut world, 0);
 
     // Send exit command
-    send_game_event(&mut world, GameCommand::Exit);
+    common::send_game_event(&mut world, GameEvent::Command(GameCommand::Exit));
 
     // Run the system
     world
@@ -208,11 +158,11 @@ fn test_player_control_system_exit_command() {
 
 #[test]
 fn test_player_control_system_toggle_debug() {
-    let mut world = create_test_world();
+    let mut world = common::create_test_world();
-    let _player = spawn_test_player(&mut world);
+    let _player = common::spawn_test_player(&mut world, 0);
 
     // Send toggle debug command
-    send_game_event(&mut world, GameCommand::ToggleDebug);
+    common::send_game_event(&mut world, GameEvent::Command(GameCommand::ToggleDebug));
 
     // Run the system
     world
@@ -226,11 +176,11 @@ fn test_player_control_system_toggle_debug() {
 
 #[test]
 fn test_player_control_system_mute_audio() {
-    let mut world = create_test_world();
+    let mut world = common::create_test_world();
-    let _player = spawn_test_player(&mut world);
+    let _player = common::spawn_test_player(&mut world, 0);
 
     // Send mute audio command
-    send_game_event(&mut world, GameCommand::MuteAudio);
+    common::send_game_event(&mut world, GameEvent::Command(GameCommand::MuteAudio));
 
     // Run the system
     world
@@ -243,7 +193,7 @@ fn test_player_control_system_mute_audio() {
 
     // Send mute audio command again to unmute - need fresh events
     world.resource_mut::<Events<GameEvent>>().clear(); // Clear previous events
-    send_game_event(&mut world, GameCommand::MuteAudio);
+    common::send_game_event(&mut world, GameEvent::Command(GameCommand::MuteAudio));
     world
         .run_system_once(player_control_system)
         .expect("System should run successfully");
@@ -255,10 +205,10 @@ fn test_player_control_system_mute_audio() {
 
 #[test]
 fn test_player_control_system_no_player_entity() {
-    let mut world = create_test_world();
+    let mut world = common::create_test_world();
     // Don't spawn a player entity
 
-    send_game_event(&mut world, GameCommand::MovePlayer(Direction::Up));
+    common::send_game_event(&mut world, GameEvent::Command(GameCommand::MovePlayer(Direction::Up)));
 
     // Run the system - should write an error
     world
@@ -272,8 +222,8 @@ fn test_player_control_system_no_player_entity() {
 
 #[test]
 fn test_player_movement_system_buffered_direction_expires() {
-    let mut world = create_test_world();
+    let mut world = common::create_test_world();
-    let player = spawn_test_player(&mut world);
+    let player = common::spawn_test_player(&mut world, 0);
 
     // Set a buffered direction with short time
     world.entity_mut(player).insert(BufferedDirection::Some {
@@ -305,8 +255,8 @@ fn test_player_movement_system_buffered_direction_expires() {
 
 #[test]
 fn test_player_movement_system_start_moving_from_stopped() {
-    let mut world = create_test_world();
+    let mut world = common::create_test_world();
-    let _player = spawn_test_player(&mut world);
+    let _player = common::spawn_test_player(&mut world, 0);
 
     // Player starts at node 0, facing right (towards node 1)
     // Should start moving when system runs
@@ -330,8 +280,8 @@ fn test_player_movement_system_start_moving_from_stopped() {
 
 #[test]
 fn test_player_movement_system_buffered_direction_change() {
-    let mut world = create_test_world();
+    let mut world = common::create_test_world();
-    let player = spawn_test_player(&mut world);
+    let player = common::spawn_test_player(&mut world, 0);
 
     // Set a buffered direction to go down (towards node 2)
     world.entity_mut(player).insert(BufferedDirection::Some {
@@ -361,8 +311,8 @@ fn test_player_movement_system_buffered_direction_change() {
 
 #[test]
 fn test_player_movement_system_no_valid_edge() {
-    let mut world = create_test_world();
+    let mut world = common::create_test_world();
-    let player = spawn_test_player(&mut world);
+    let player = common::spawn_test_player(&mut world, 0);
 
     // Set velocity to direction with no edge
     world.entity_mut(player).insert(Velocity {
@@ -386,8 +336,8 @@ fn test_player_movement_system_no_valid_edge() {
 
 #[test]
 fn test_player_movement_system_continue_moving() {
-    let mut world = create_test_world();
+    let mut world = common::create_test_world();
-    let player = spawn_test_player(&mut world);
+    let player = common::spawn_test_player(&mut world, 0);
 
     // Set player to already be moving
     world.entity_mut(player).insert(Position::Moving {
@@ -414,17 +364,13 @@ fn test_player_movement_system_continue_moving() {
     }
 }
 
-// ============================================================================
-// Integration Tests
-// ============================================================================
-
 #[test]
 fn test_full_player_input_to_movement_flow() {
-    let mut world = create_test_world();
+    let mut world = common::create_test_world();
-    let _player = spawn_test_player(&mut world);
+    let _player = common::spawn_test_player(&mut world, 0);
 
     // Send move command
-    send_game_event(&mut world, GameCommand::MovePlayer(Direction::Down));
+    common::send_game_event(&mut world, GameEvent::Command(GameCommand::MovePlayer(Direction::Down)));
 
     // Run control system to process input
     world
@@ -454,11 +400,11 @@ fn test_full_player_input_to_movement_flow() {
 
 #[test]
 fn test_buffered_direction_timing() {
-    let mut world = create_test_world();
+    let mut world = common::create_test_world();
-    let _player = spawn_test_player(&mut world);
+    let _player = common::spawn_test_player(&mut world, 0);
 
     // Send move command
-    send_game_event(&mut world, GameCommand::MovePlayer(Direction::Up));
+    common::send_game_event(&mut world, GameEvent::Command(GameCommand::MovePlayer(Direction::Up)));
     world
         .run_system_once(player_control_system)
         .expect("System should run successfully");
@@ -493,21 +439,21 @@ fn test_buffered_direction_timing() {
 
 #[test]
 fn test_multiple_rapid_direction_changes() {
-    let mut world = create_test_world();
+    let mut world = common::create_test_world();
-    let _player = spawn_test_player(&mut world);
+    let _player = common::spawn_test_player(&mut world, 0);
 
     // Send multiple rapid direction changes
-    send_game_event(&mut world, GameCommand::MovePlayer(Direction::Up));
+    common::send_game_event(&mut world, GameEvent::Command(GameCommand::MovePlayer(Direction::Up)));
     world
         .run_system_once(player_control_system)
         .expect("System should run successfully");
 
-    send_game_event(&mut world, GameCommand::MovePlayer(Direction::Down));
+    common::send_game_event(&mut world, GameEvent::Command(GameCommand::MovePlayer(Direction::Down)));
     world
         .run_system_once(player_control_system)
         .expect("System should run successfully");
 
-    send_game_event(&mut world, GameCommand::MovePlayer(Direction::Left));
+    common::send_game_event(&mut world, GameEvent::Command(GameCommand::MovePlayer(Direction::Left)));
     world
         .run_system_once(player_control_system)
         .expect("System should run successfully");
@@ -526,15 +472,15 @@ fn test_multiple_rapid_direction_changes() {
 
 #[test]
 fn test_player_state_persistence_across_systems() {
-    let mut world = create_test_world();
+    let mut world = common::create_test_world();
-    let _player = spawn_test_player(&mut world);
+    let _player = common::spawn_test_player(&mut world, 0);
 
     // Test that multiple commands can be processed - but need to handle events properly
     // Clear any existing events first
     world.resource_mut::<Events<GameEvent>>().clear();
 
     // Toggle debug mode
-    send_game_event(&mut world, GameCommand::ToggleDebug);
+    common::send_game_event(&mut world, GameEvent::Command(GameCommand::ToggleDebug));
     world
         .run_system_once(player_control_system)
         .expect("System should run successfully");
@@ -542,7 +488,7 @@ fn test_player_state_persistence_across_systems() {
 
     // Clear events and mute audio
     world.resource_mut::<Events<GameEvent>>().clear();
-    send_game_event(&mut world, GameCommand::MuteAudio);
+    common::send_game_event(&mut world, GameEvent::Command(GameCommand::MuteAudio));
     world
         .run_system_once(player_control_system)
         .expect("System should run successfully");
@@ -550,7 +496,7 @@ fn test_player_state_persistence_across_systems() {
 
     // Clear events and move player
     world.resource_mut::<Events<GameEvent>>().clear();
-    send_game_event(&mut world, GameCommand::MovePlayer(Direction::Down));
+    common::send_game_event(&mut world, GameEvent::Command(GameCommand::MovePlayer(Direction::Down)));
     world
         .run_system_once(player_control_system)
         .expect("System should run successfully");

tests/profiling.rs

@@ -40,15 +40,8 @@ fn test_timing_statistics() {
         assert_close!(*std_dev, Duration::from_millis(2), "PlayerControls standard deviation timing");
     }
 
-    {
+    // Note: get_total_stats() was removed as we now use the Total system directly
-        let (total_avg, total_std) = timings.get_total_stats();
+    // This test now focuses on individual system statistics
-        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"
-        );
-    }
 }
 
 #[test]
@@ -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,
@@ -108,3 +101,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));
+    timings.add_total_timing(Duration::from_millis(18));
+    timings.add_total_timing(Duration::from_millis(14));
+
+    let stats = timings.get_stats();
+    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"
+    );
+}

tests/sprite.rs

@@ -1,14 +1,12 @@
 use glam::U16Vec2;
-use pacman::texture::sprite::{AtlasMapper, AtlasTile, MapperFrame, SpriteAtlas};
+use pacman::texture::sprite::{AtlasMapper, AtlasTile, MapperFrame};
 use sdl2::pixels::Color;
 use std::collections::HashMap;
 
-fn mock_texture() -> sdl2::render::Texture {
+mod common;
-    unsafe { std::mem::transmute(0usize) }
-}
 
 #[test]
-fn test_sprite_atlas_basic() {
+fn test_atlas_mapper_frame_lookup() {
     let mut frames = HashMap::new();
     frames.insert(
         "test".to_string(),
@@ -19,19 +17,17 @@ fn test_sprite_atlas_basic() {
     );
 
     let mapper = AtlasMapper { frames };
-    let texture = mock_texture();
-    let atlas = SpriteAtlas::new(texture, mapper);
 
-    let tile = atlas.get_tile("test");
+    // Test direct frame lookup
-    assert!(tile.is_some());
+    let frame = mapper.frames.get("test");
-    let tile = tile.unwrap();
+    assert!(frame.is_some());
-    assert_eq!(tile.pos, glam::U16Vec2::new(10, 20));
+    let frame = frame.unwrap();
-    assert_eq!(tile.size, glam::U16Vec2::new(32, 64));
+    assert_eq!(frame.pos, U16Vec2::new(10, 20));
-    assert_eq!(tile.color, None);
+    assert_eq!(frame.size, U16Vec2::new(32, 64));
 }
 
 #[test]
-fn test_sprite_atlas_multiple_tiles() {
+fn test_atlas_mapper_multiple_frames() {
     let mut frames = HashMap::new();
     frames.insert(
         "tile1".to_string(),
@@ -49,27 +45,12 @@ fn test_sprite_atlas_multiple_tiles() {
     );
 
     let mapper = AtlasMapper { frames };
-    let texture = mock_texture();
-    let atlas = SpriteAtlas::new(texture, mapper);
 
-    assert_eq!(atlas.tiles_count(), 2);
+    assert_eq!(mapper.frames.len(), 2);
-    assert!(atlas.has_tile("tile1"));
+    assert!(mapper.frames.contains_key("tile1"));
-    assert!(atlas.has_tile("tile2"));
+    assert!(mapper.frames.contains_key("tile2"));
-    assert!(!atlas.has_tile("tile3"));
+    assert!(!mapper.frames.contains_key("tile3"));
-    assert!(atlas.get_tile("nonexistent").is_none());
+    assert!(!mapper.frames.contains_key("nonexistent"));
-}
-
-#[test]
-fn test_sprite_atlas_color() {
-    let mapper = AtlasMapper { frames: HashMap::new() };
-    let texture = mock_texture();
-    let mut atlas = SpriteAtlas::new(texture, mapper);
-
-    assert_eq!(atlas.default_color(), None);
-
-    let color = Color::RGB(255, 0, 0);
-    atlas.set_color(color);
-    assert_eq!(atlas.default_color(), Some(color));
 }
 
 #[test]

tests/text.rs

@@ -1,9 +1,9 @@
 use pacman::texture::{sprite::SpriteAtlas, text::TextTexture};
 
-use crate::common::create_atlas;
-
 mod common;
 
+use common::create_atlas;
+
 /// Helper function to get all characters that should be in the atlas
 fn get_all_chars() -> String {
     let mut chars = Vec::new();

tests/tracing_buffer.rs

@@ -1,19 +0,0 @@
-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();
-}

web.build.ts

@@ -501,7 +501,6 @@ async function activateEmsdk(
 
   return { vars };
 }
-
 async function main() {
   // Print the OS detected
   logger.debug(
@@ -515,7 +514,19 @@ async function main() {
         .exhaustive()
   );
 
-  const release = process.env.RELEASE !== "0";
+  // Parse command line args for build mode
+  const args = process.argv.slice(2);
+  let release = true; // Default to release mode
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "-d" || arg === "--debug") {
+      release = false;
+    } else if (arg === "-r" || arg === "--release") {
+      release = true;
+    }
+  }
+
   const emsdkDir = resolve("./emsdk");
 
   // Activate the Emscripten SDK (returns null if already activated)