test: add ttf renderer tests

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,76 @@ dependencies = [
  "windows-sys 0.52.0",
 ]
 
+[[package]]
+name = "num"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "35bd024e8b2ff75562e5f34e7f4905839deb4b22955ef5e73d2fea1b9813cb23"
+dependencies = [
+ "num-bigint",
+ "num-complex",
+ "num-integer",
+ "num-iter",
+ "num-rational",
+ "num-traits",
+]
+
+[[package]]
+name = "num-bigint"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9"
+dependencies = [
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-complex"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73f88a1307638156682bada9d7604135552957b7818057dcef22705b4d509495"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "num-conv"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9"
+
+[[package]]
+name = "num-integer"
+version = "0.1.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "num-iter"
+version = "0.1.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1429034a0490724d0075ebb2bc9e875d6503c3cf69e235a8941aa757d83ef5bf"
+dependencies = [
+ "autocfg",
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-rational"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f83d14da390562dca69fc84082e73e548e1ad308d24accdedd2720017cb37824"
+dependencies = [
+ "num-bigint",
+ "num-integer",
+ "num-traits",
+]
+
 [[package]]
 name = "num-traits"
 version = "0.2.19"
@@ -603,11 +682,13 @@ dependencies = [
  "serde",
  "serde_json",
  "smallvec",
+ "speculoos",
  "spin_sleep",
  "strum",
  "strum_macros",
  "thiserror",
  "thousands",
+ "time",
  "tracing",
  "tracing-error",
  "tracing-subscriber",
@@ -722,6 +803,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"
@@ -943,6 +1030,16 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "speculoos"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "00c84ba5fa63b0de837c0d3cef5373ac1c3c6342053b7f446a210a1dde79a034"
+dependencies = [
+ "num",
+ "serde_json",
+]
+
 [[package]]
 name = "spin"
 version = "0.9.8"
@@ -1032,6 +1129,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"
@@ -61,6 +62,7 @@ libc = "0.2.175"  # TODO: Describe why this is required.
 
 [dev-dependencies]
 pretty_assertions = "1.4.1"
+speculoos = "0.13.0"
 
 [build-dependencies]
 phf = { version = "0.13.1", features = ["macros"] }

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:
-    bun run web.build.ts
+web *args:
+    bun run web.build.ts {{args}};
+    caddy file-server --root dist

src/app.rs

@@ -1,17 +1,18 @@
+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.
-///
-/// Handles platform-specific setup, maintains consistent frame timing, and delegates
-/// game logic to the contained `Game` instance. The app manages focus state to
-/// optimize CPU usage when the window loses focus.
 pub struct App {
     pub game: Game,
     last_tick: Instant,
@@ -24,19 +25,15 @@ pub struct App {
 impl App {
     /// Initializes SDL subsystems, creates the game window, and sets up the game state.
     ///
-    /// Performs comprehensive initialization including video/audio subsystems,
-    /// window creation with proper scaling, and canvas configuration. All SDL
-    /// resources are leaked to maintain 'static lifetimes required by the game architecture.
-    ///
     /// # Errors
     ///
     /// Returns `GameError::Sdl` if any SDL initialization step fails, or propagates
     /// errors from `Game::new()` during game state setup.
     pub fn new() -> GameResult<Self> {
         let sdl_context = sdl2::init().map_err(|e| GameError::Sdl(e.to_string()))?;
+        let ttf_context = sdl2::ttf::init().map_err(|e| GameError::Sdl(e.to_string()))?;
         let video_subsystem = sdl_context.video().map_err(|e| GameError::Sdl(e.to_string()))?;
         let audio_subsystem = sdl_context.audio().map_err(|e| GameError::Sdl(e.to_string()))?;
-        // TTF context is initialized within Game::new where it is leaked for font usage
         let event_pump = sdl_context.event_pump().map_err(|e| GameError::Sdl(e.to_string()))?;
 
         let window = video_subsystem
@@ -50,20 +47,55 @@ 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();
 
-        let game = Game::new(canvas, texture_creator, event_pump)?;
-        // game.audio.set_mute(cfg!(debug_assertions));
+        let game = Game::new(canvas, ttf_context, texture_creator, event_pump)?;
 
         Ok(App {
             game,
@@ -91,6 +123,9 @@ impl App {
             let dt = self.last_tick.elapsed().as_secs_f32();
             self.last_tick = start;
 
+            // Increment the global tick counter for tracing
+            formatter::increment_tick();
+
             let exit = self.game.tick(dt);
 
             if exit {

src/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;
@@ -65,8 +72,8 @@ pub mod collider {
 pub mod ui {
     /// Debug font size in points
     pub const DEBUG_FONT_SIZE: u16 = 12;
-    /// Power pellet blink rate in seconds
-    pub const POWER_PELLET_BLINK_RATE: f32 = 0.2;
+    /// Power pellet blink rate in ticks (at 60 FPS, 12 ticks = 0.2 seconds)
+    pub const POWER_PELLET_BLINK_RATE: u32 = 12;
 }
 
 /// Map tile types that define gameplay behavior and collision properties.

src/formatter.rs

@@ -0,0 +1,160 @@
+//! 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, Level, Subscriber};
+use tracing_subscriber::fmt::format::Writer;
+use tracing_subscriber::fmt::{FmtContext, FormatEvent, FormatFields, FormattedFields};
+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
+///
+/// Re-implementation of the Full formatter to add a tick counter and timestamp.
+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 {
+        let meta = event.metadata();
+
+        // 1) Timestamp (dimmed when ANSI)
+        let now = OffsetDateTime::now_utc();
+        let formatted_time = now.format(&TIMESTAMP_FORMAT).map_err(|e| {
+            eprintln!("Failed to format timestamp: {}", e);
+            fmt::Error
+        })?;
+        write_dimmed(&mut writer, formatted_time)?;
+        writer.write_char(' ')?;
+
+        // 2) Tick counter, dim when ANSI
+        let tick_count = get_tick_count() & TICK_DISPLAY_MASK;
+        if writer.has_ansi_escapes() {
+            write!(writer, "\x1b[2m0x{:04X}\x1b[0m ", tick_count)?;
+        } else {
+            write!(writer, "0x{:04X} ", tick_count)?;
+        }
+
+        // 3) Colored 5-char level like Full
+        write_colored_level(&mut writer, meta.level())?;
+        writer.write_char(' ')?;
+
+        // 4) Span scope chain (bold names, fields in braces, dimmed ':')
+        if let Some(scope) = ctx.event_scope() {
+            let mut saw_any = false;
+            for span in scope.from_root() {
+                write_bold(&mut writer, span.metadata().name())?;
+                saw_any = true;
+                let ext = span.extensions();
+                if let Some(fields) = &ext.get::<FormattedFields<N>>() {
+                    if !fields.is_empty() {
+                        write_bold(&mut writer, "{")?;
+                        write!(writer, "{}", fields)?;
+                        write_bold(&mut writer, "}")?;
+                    }
+                }
+                if writer.has_ansi_escapes() {
+                    write!(writer, "\x1b[2m:\x1b[0m")?;
+                } else {
+                    writer.write_char(':')?;
+                }
+            }
+            if saw_any {
+                writer.write_char(' ')?;
+            }
+        }
+
+        // 5) Target (dimmed), then a space
+        if writer.has_ansi_escapes() {
+            write!(writer, "\x1b[2m{}\x1b[0m\x1b[2m:\x1b[0m ", meta.target())?;
+        } else {
+            write!(writer, "{}: ", meta.target())?;
+        }
+
+        // 6) Event fields
+        ctx.format_fields(writer.by_ref(), event)?;
+
+        // 7) Newline
+        writeln!(writer)
+    }
+}
+
+/// Write the verbosity level with the same coloring/alignment as the Full formatter.
+fn write_colored_level(writer: &mut Writer<'_>, level: &Level) -> fmt::Result {
+    if writer.has_ansi_escapes() {
+        // Basic ANSI color sequences; reset with \x1b[0m
+        let (color, text) = match *level {
+            Level::TRACE => ("\x1b[35m", "TRACE"), // purple
+            Level::DEBUG => ("\x1b[34m", "DEBUG"), // blue
+            Level::INFO => ("\x1b[32m", " INFO"),  // green, note leading space
+            Level::WARN => ("\x1b[33m", " WARN"),  // yellow, note leading space
+            Level::ERROR => ("\x1b[31m", "ERROR"), // red
+        };
+        write!(writer, "{}{}\x1b[0m", color, text)
+    } else {
+        // Right-pad to width 5 like Full's non-ANSI mode
+        match *level {
+            Level::TRACE => write!(writer, "{:>5}", "TRACE"),
+            Level::DEBUG => write!(writer, "{:>5}", "DEBUG"),
+            Level::INFO => write!(writer, "{:>5}", " INFO"),
+            Level::WARN => write!(writer, "{:>5}", " WARN"),
+            Level::ERROR => write!(writer, "{:>5}", "ERROR"),
+        }
+    }
+}
+
+fn write_dimmed(writer: &mut Writer<'_>, s: impl fmt::Display) -> fmt::Result {
+    if writer.has_ansi_escapes() {
+        write!(writer, "\x1b[2m{}\x1b[0m", s)
+    } else {
+        write!(writer, "{}", s)
+    }
+}
+
+fn write_bold(writer: &mut Writer<'_>, s: impl fmt::Display) -> fmt::Result {
+    if writer.has_ansi_escapes() {
+        write!(writer, "\x1b[1m{}\x1b[0m", s)
+    } else {
+        write!(writer, "{}", s)
+    }
+}
+
+/// Increment the global tick counter by 1
+///
+/// This should be called once per game tick/frame from the main game loop
+pub fn increment_tick() {
+    TICK_COUNTER.fetch_add(1, Ordering::Relaxed);
+}
+
+/// Get the current tick count
+///
+/// Returns the current value of the global tick counter
+pub fn get_tick_count() -> u64 {
+    TICK_COUNTER.load(Ordering::Relaxed)
+}
+
+/// Reset the tick counter to 0
+///
+/// This can be used for testing or when restarting the game
+#[allow(dead_code)]
+pub fn reset_tick_counter() {
+    TICK_COUNTER.store(0, Ordering::Relaxed);
+}

src/game.rs

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

src/lib.rs

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

src/main.rs

@@ -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() {
-        // Setup buffered tracing subscriber that will buffer logs until console is ready
-        let switchable_writer = platform::tracing_buffer::setup_switchable_subscriber();
-
-        // 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:?}");
-        }
-    }
+    // On Windows, this connects output streams to the console dynamically
+    // On Emscripten, this connects the subscriber to the browser console
+    platform::init_console().expect("Could not initialize console");
 
     let mut app = App::new().expect("Could not create app");
 

src/map/builder.rs

@@ -359,12 +359,7 @@ impl Map {
                             + IVec2::from(Direction::Left.as_ivec2()).as_vec2() * (CELL_SIZE as f32 * 2.0),
                     },
                 )
-                .map_err(|e| {
-                    MapError::InvalidConfig(format!(
-                        "Failed to connect left tunnel entrance to left tunnel hidden node: {}",
-                        e
-                    ))
-                })?
+                .expect("Failed to connect left tunnel entrance to left tunnel hidden node")
         };
 
         // Create the right tunnel nodes
@@ -384,12 +379,7 @@ impl Map {
                             + IVec2::from(Direction::Right.as_ivec2()).as_vec2() * (CELL_SIZE as f32 * 2.0),
                     },
                 )
-                .map_err(|e| {
-                    MapError::InvalidConfig(format!(
-                        "Failed to connect right tunnel entrance to right tunnel hidden node: {}",
-                        e
-                    ))
-                })?
+                .expect("Failed to connect right tunnel entrance to right tunnel hidden node")
         };
 
         // Connect the left tunnel hidden node to the right tunnel hidden node
@@ -401,12 +391,7 @@ impl Map {
                 Some(0.0),
                 Direction::Left,
             )
-            .map_err(|e| {
-                MapError::InvalidConfig(format!(
-                    "Failed to connect left tunnel hidden node to right tunnel hidden node: {}",
-                    e
-                ))
-            })?;
+            .expect("Failed to connect left tunnel hidden node to right tunnel hidden node");
 
         Ok(())
     }

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 {
-    false
+/// A writer that outputs to the browser console via printf (redirected by emscripten)
+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
-        .read_exact(&mut buf)
-        .map_err(|e| AssetError::Io(std::io::Error::other(e)))?;
+    rwops.read_exact(&mut buf).map_err(|e| AssetError::Io(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/blinking.rs

@@ -12,20 +12,24 @@ use crate::systems::{
 
 #[derive(Component, Debug)]
 pub struct Blinking {
-    pub timer: f32,
-    pub interval: f32,
+    pub tick_timer: u32,
+    pub interval_ticks: u32,
 }
 
 impl Blinking {
-    pub fn new(interval: f32) -> Self {
-        Self { timer: 0.0, interval }
+    pub fn new(interval_ticks: u32) -> Self {
+        Self {
+            tick_timer: 0,
+            interval_ticks,
+        }
     }
 }
 
 /// Updates blinking entities by toggling their visibility at regular intervals.
 ///
 /// This system manages entities that have both `Blinking` and `Renderable` components,
-/// accumulating time and toggling visibility when the specified interval is reached.
+/// accumulating ticks and toggling visibility when the specified interval is reached.
+/// Uses integer arithmetic for deterministic behavior.
 #[allow(clippy::type_complexity)]
 pub fn blinking_system(
     mut commands: Commands,
@@ -42,22 +46,40 @@ pub fn blinking_system(
             continue;
         }
 
-        // Increase the timer by the delta time
-        blinking.timer += time.0;
+        // Increase the timer by the delta ticks
+        blinking.tick_timer += time.ticks;
 
-        // If the timer is less than the interval, there's nothing to do yet
-        if blinking.timer < blinking.interval {
+        // Handle zero interval case (immediate toggling)
+        if blinking.interval_ticks == 0 {
+            if time.ticks > 0 {
+                if hidden {
+                    commands.entity(entity).remove::<Hidden>();
+                } else {
+                    commands.entity(entity).insert(Hidden);
+                }
+            }
             continue;
         }
 
-        // Subtract the interval (allows for the timer to retain partial interval progress)
-        blinking.timer -= blinking.interval;
+        // Calculate how many complete intervals have passed
+        let complete_intervals = blinking.tick_timer / blinking.interval_ticks;
 
-        // Toggle the Hidden component
-        if hidden {
-            commands.entity(entity).remove::<Hidden>();
-        } else {
-            commands.entity(entity).insert(Hidden);
+        // If no complete intervals have passed, there's nothing to do yet
+        if complete_intervals == 0 {
+            continue;
+        }
+
+        // Update the timer to the remainder after complete intervals
+        blinking.tick_timer %= blinking.interval_ticks;
+
+        // Toggle the Hidden component for each complete interval
+        // Since toggling twice is a no-op, we only need to toggle if the count is odd
+        if complete_intervals % 2 == 1 {
+            if hidden {
+                commands.entity(entity).remove::<Hidden>();
+            } else {
+                commands.entity(entity).insert(Hidden);
+            }
         }
     }
 }

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/components.rs

@@ -162,7 +162,35 @@ pub struct GlobalState {
 pub struct ScoreResource(pub u32);
 
 #[derive(Resource)]
-pub struct DeltaTime(pub f32);
+pub struct DeltaTime {
+    /// Floating-point delta time in seconds
+    pub seconds: f32,
+    /// Integer tick delta (usually 1, but can be different for testing)
+    pub ticks: u32,
+}
+
+#[allow(dead_code)]
+impl DeltaTime {
+    /// Creates a new DeltaTime from a floating-point delta time in seconds
+    ///
+    /// While this method exists as a helper, it does not mean that seconds and ticks are interchangeable.
+    pub fn from_seconds(seconds: f32) -> Self {
+        Self {
+            seconds,
+            ticks: (seconds * 60.0).round() as u32,
+        }
+    }
+
+    /// Creates a new DeltaTime from an integer tick delta
+    ///
+    /// While this method exists as a helper, it does not mean that seconds and ticks are interchangeable.
+    pub fn from_ticks(ticks: u32) -> Self {
+        Self {
+            seconds: ticks as f32 / 60.0,
+            ticks,
+        }
+    }
+}
 
 /// Movement modifiers that can affect Pac-Man's speed or handling.
 #[derive(Component, Debug, Clone, Copy)]

src/systems/debug.rs

@@ -1,13 +1,13 @@
 //! Debug rendering system
 use std::cmp::Ordering;
 
-use crate::constants::BOARD_PIXEL_OFFSET;
+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::{NonSendMut, Query, Res};
-use glam::{IVec2, UVec2, Vec2};
+use bevy_ecs::system::{Query, Res};
+use glam::{IVec2, Vec2};
 use sdl2::pixels::Color;
 use sdl2::rect::{Point, Rect};
 use sdl2::render::{Canvas, Texture};
@@ -152,11 +152,12 @@ fn transform_position_with_offset(pos: Vec2, scale: f32) -> IVec2 {
 fn render_timing_display(
     canvas: &mut Canvas<Window>,
     timings: &SystemTimings,
+    current_tick: u64,
     text_renderer: &TtfRenderer,
     atlas: &mut TtfAtlas,
 ) {
     // Format timing information using the formatting module
-    let lines = timings.format_timing_display();
+    let lines = timings.format_timing_display(current_tick);
     let line_height = text_renderer.text_height(atlas) as i32 + 2; // Add 2px line spacing
     let padding = 10;
 
@@ -203,140 +204,135 @@ fn render_timing_display(
 
 #[allow(clippy::too_many_arguments)]
 pub fn debug_render_system(
-    mut canvas: NonSendMut<&mut Canvas<Window>>,
-    mut debug_texture: NonSendMut<DebugTextureResource>,
-    mut ttf_atlas: NonSendMut<TtfAtlasResource>,
-    batched_lines: Res<BatchedLinesResource>,
-    debug_state: Res<DebugState>,
-    timings: Res<SystemTimings>,
-    map: Res<Map>,
-    colliders: Query<(&Collider, &Position)>,
-    cursor: Res<CursorPosition>,
+    canvas: &mut Canvas<Window>,
+    ttf_atlas: &mut TtfAtlasResource,
+    batched_lines: &Res<BatchedLinesResource>,
+    debug_state: &Res<DebugState>,
+    timings: &Res<SystemTimings>,
+    timing: &Res<crate::systems::profiling::Timing>,
+    map: &Res<Map>,
+    colliders: &Query<(&Collider, &Position)>,
+    cursor: &Res<CursorPosition>,
 ) {
     if !debug_state.enabled {
         return;
     }
-    let scale =
-        (UVec2::from(canvas.output_size().unwrap()).as_vec2() / UVec2::from(canvas.logical_size()).as_vec2()).min_element();
-
     // Create debug text renderer
     let text_renderer = TtfRenderer::new(1.0);
 
-    let cursor_world_pos = match *cursor {
+    let cursor_world_pos = match &**cursor {
         CursorPosition::None => None,
         CursorPosition::Some { position, .. } => Some(position - BOARD_PIXEL_OFFSET.as_vec2()),
     };
 
-    // Draw debug info on the high-resolution debug texture
-    canvas
-        .with_texture_canvas(&mut debug_texture.0, |debug_canvas| {
-            // Clear the debug canvas
-            debug_canvas.set_draw_color(Color::RGBA(0, 0, 0, 0));
-            debug_canvas.clear();
+    // Clear the debug canvas
+    canvas.set_draw_color(Color::RGBA(0, 0, 0, 0));
+    canvas.clear();
 
-            // Find the closest node to the cursor
-            let closest_node = if let Some(cursor_world_pos) = cursor_world_pos {
-                map.graph
-                    .nodes()
-                    .map(|node| node.position.distance(cursor_world_pos))
-                    .enumerate()
-                    .min_by(|(_, a), (_, b)| a.partial_cmp(b).unwrap_or(Ordering::Less))
-                    .map(|(id, _)| id)
-            } else {
-                None
-            };
+    // Find the closest node to the cursor
+    let closest_node = if let Some(cursor_world_pos) = cursor_world_pos {
+        map.graph
+            .nodes()
+            .map(|node| node.position.distance(cursor_world_pos))
+            .enumerate()
+            .min_by(|(_, a), (_, b)| a.partial_cmp(b).unwrap_or(Ordering::Less))
+            .map(|(id, _)| id)
+    } else {
+        None
+    };
 
-            debug_canvas.set_draw_color(Color::GREEN);
-            {
-                let rects = colliders
-                    .iter()
-                    .map(|(collider, position)| {
-                        let pos = position.get_pixel_position(&map.graph).unwrap();
+    canvas.set_draw_color(Color::GREEN);
+    {
+        let rects = colliders
+            .iter()
+            .map(|(collider, position)| {
+                let pos = position.get_pixel_position(&map.graph).unwrap();
 
-                        // Transform position and size using common methods
-                        let pos = (pos * scale).as_ivec2();
-                        let size = (collider.size * scale) as u32;
+                // Transform position and size using common methods
+                let pos = (pos * constants::LARGE_SCALE).as_ivec2();
+                let size = (collider.size * constants::LARGE_SCALE) as u32;
 
-                        Rect::from_center(Point::from((pos.x, pos.y)), size, size)
-                    })
-                    .collect::<SmallVec<[Rect; 100]>>();
-                if rects.len() > rects.capacity() {
-                    warn!(
-                        capacity = rects.capacity(),
-                        count = rects.len(),
-                        "Collider rects capacity exceeded"
-                    );
-                }
-                debug_canvas.draw_rects(&rects).unwrap();
-            }
+                Rect::from_center(Point::from((pos.x, pos.y)), size, size)
+            })
+            .collect::<SmallVec<[Rect; 100]>>();
+        if rects.len() > rects.capacity() {
+            warn!(
+                capacity = rects.capacity(),
+                count = rects.len(),
+                "Collider rects capacity exceeded"
+            );
+        }
+        canvas.draw_rects(&rects).unwrap();
+    }
 
-            debug_canvas.set_draw_color(Color {
-                a: f32_to_u8(0.6),
-                ..Color::RED
-            });
-            debug_canvas.set_blend_mode(sdl2::render::BlendMode::Blend);
+    canvas.set_draw_color(Color {
+        a: f32_to_u8(0.65),
+        ..Color::RED
+    });
+    canvas.set_blend_mode(sdl2::render::BlendMode::Blend);
 
-            // Use cached batched line segments
-            batched_lines.render(debug_canvas);
+    // Use cached batched line segments
+    batched_lines.render(canvas);
 
-            {
-                let rects: Vec<_> = map
-                    .graph
-                    .nodes()
-                    .enumerate()
-                    .filter_map(|(id, node)| {
-                        let pos = transform_position_with_offset(node.position, scale);
-                        let size = (2.0 * scale) as u32;
-                        let rect = Rect::new(pos.x - (size as i32 / 2), pos.y - (size as i32 / 2), size, size);
+    {
+        let rects: Vec<_> = map
+            .graph
+            .nodes()
+            .enumerate()
+            .filter_map(|(id, node)| {
+                let pos = transform_position_with_offset(node.position, constants::LARGE_SCALE);
+                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
-                        if closest_node == Some(id) {
-                            debug_canvas.set_draw_color(Color::YELLOW);
-                            debug_canvas.fill_rect(rect).unwrap();
-                            return None;
-                        }
-
-                        Some(rect)
-                    })
-                    .collect();
-
-                if rects.len() > rects.capacity() {
-                    warn!(
-                        capacity = rects.capacity(),
-                        count = rects.len(),
-                        "Node rects capacity exceeded"
-                    );
+                // If the node is the one closest to the cursor, draw it immediately
+                if closest_node == Some(id) {
+                    canvas.set_draw_color(Color::YELLOW);
+                    canvas.fill_rect(rect).unwrap();
+                    return None;
                 }
 
-                // Draw the non-closest nodes all at once in blue
-                debug_canvas.set_draw_color(Color::BLUE);
-                debug_canvas.fill_rects(&rects).unwrap();
-            }
+                Some(rect)
+            })
+            .collect();
 
-            // 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);
+        if rects.len() > rects.capacity() {
+            warn!(
+                capacity = rects.capacity(),
+                count = rects.len(),
+                "Node rects capacity exceeded"
+            );
+        }
 
-                let node_id_text = closest_node_id.to_string();
-                let text_pos = Vec2::new((pos.x + 10) as f32, (pos.y - 5) as f32);
+        // Draw the non-closest nodes all at once in blue
+        canvas.set_draw_color(Color::BLUE);
+        canvas.fill_rects(&rects).unwrap();
+    }
 
-                text_renderer
-                    .render_text(
-                        debug_canvas,
-                        &mut ttf_atlas.0,
-                        &node_id_text,
-                        text_pos,
-                        Color {
-                            a: f32_to_u8(0.4),
-                            ..Color::WHITE
-                        },
-                    )
-                    .unwrap();
-            }
+    // 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, constants::LARGE_SCALE);
 
-            // Render timing information in the top-left corner
-            render_timing_display(debug_canvas, &timings, &text_renderer, &mut ttf_atlas.0);
-        })
-        .unwrap();
+        let node_id_text = closest_node_id.to_string();
+        let text_pos = Vec2::new((pos.x + 10) as f32, (pos.y - 5) as f32);
+
+        text_renderer
+            .render_text(
+                canvas,
+                &mut ttf_atlas.0,
+                &node_id_text,
+                text_pos,
+                Color {
+                    a: f32_to_u8(0.9),
+                    ..Color::WHITE
+                },
+            )
+            .unwrap();
+    }
+
+    // Render timing information in the top-left corner
+    // Use previous tick since current tick is incomplete (frame is still running)
+    let current_tick = timing.get_current_tick();
+    let previous_tick = current_tick.saturating_sub(1);
+    render_timing_display(canvas, timings, previous_tick, &text_renderer, &mut ttf_atlas.0);
 }

src/systems/ghost.rs

@@ -25,7 +25,7 @@ pub fn ghost_movement_system(
     mut ghosts: Query<(&Ghost, &mut Velocity, &mut Position), Without<Frozen>>,
 ) {
     for (_ghost, mut velocity, mut position) in ghosts.iter_mut() {
-        let mut distance = velocity.speed * 60.0 * delta_time.0;
+        let mut distance = velocity.speed * 60.0 * delta_time.seconds;
         loop {
             match *position {
                 Position::Stopped { node: current_node } => {
@@ -111,7 +111,7 @@ pub fn eaten_ghost_system(
                 }
             }
             Position::Moving { to, .. } => {
-                let distance = velocity.speed * 60.0 * delta_time.0;
+                let distance = velocity.speed * 60.0 * delta_time.seconds;
                 if let Some(_overflow) = position.tick(distance) {
                     // Reached target node, check if we're at ghost house center
                     if to == ghost_house_center {

src/systems/input.rs

@@ -6,7 +6,11 @@ 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 crate::systems::components::DeltaTime;
@@ -15,6 +19,12 @@ use crate::{
     map::direction::Direction,
 };
 
+// Touch input constants
+pub const TOUCH_DIRECTION_THRESHOLD: f32 = 10.0;
+pub const TOUCH_EASING_DISTANCE_THRESHOLD: f32 = 1.0;
+pub const MAX_TOUCH_MOVEMENT_SPEED: f32 = 100.0;
+pub const TOUCH_EASING_FACTOR: f32 = 1.5;
+
 #[derive(Resource, Default, Debug, Copy, Clone)]
 pub enum CursorPosition {
     #[default]
@@ -25,6 +35,30 @@ pub enum CursorPosition {
     },
 }
 
+#[derive(Resource, Default, Debug, Clone)]
+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,27 +159,67 @@ pub fn process_simple_key_events(bindings: &mut Bindings, frame_events: &[Simple
     emitted_events
 }
 
+/// Calculates the primary direction from a 2D vector delta
+pub 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.
+pub 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.
     let frame_events: SmallVec<[Event; 3]> = pump.poll_iter().collect();
 
-    // Warn if the smallvec was heap allocated due to exceeding stack capacity
-    #[cfg(debug_assertions)]
-    if frame_events.len() > frame_events.capacity() {
-        tracing::warn!(
-            "More than {} events in a frame, consider adjusting stack capacity: {:?}",
-            frame_events.capacity(),
-            frame_events
-        );
-    }
-
     // Handle non-keyboard events inline and build a simplified keyboard event stream.
     let mut simple_key_events: SmallVec<[SimpleKeyEvent; 3]> = smallvec![];
     for event in &frame_events {
@@ -159,6 +233,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,8 +287,15 @@ pub fn input_system(
                     simple_key_events.push(SimpleKeyEvent::KeyUp(key));
                 }
             }
+            Event::Window { win_event, .. } => {
+                if let WindowEvent::Resized(w, h) = win_event {
+                    tracing::info!(width = w, height = h, event = ?win_event, "Window Resized");
+                }
+            }
+            // Despite disabling this event, it's still received, so we ignore it explicitly.
+            Event::RenderTargetsReset { .. } => {}
             _ => {
-                tracing::warn!("Unhandled event, consider disabling: {:?}", event);
+                tracing::warn!(event = ?event, "Unhandled Event");
             }
         }
     }
@@ -188,8 +306,27 @@ 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.seconds);
+
+        // 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;
+        *remaining_time -= delta_time.seconds;
         if *remaining_time <= 0.0 {
             *cursor = CursorPosition::None;
         }

src/systems/player.rs

@@ -99,12 +99,12 @@ pub fn player_movement_system(
             } else {
                 *buffered_direction = BufferedDirection::Some {
                     direction,
-                    remaining_time: remaining_time - delta_time.0,
+                    remaining_time: remaining_time - delta_time.seconds,
                 };
             }
         }
 
-        let mut distance = velocity.speed * modifiers.speed_multiplier * 60.0 * delta_time.0;
+        let mut distance = velocity.speed * modifiers.speed_multiplier * 60.0 * delta_time.seconds;
 
         loop {
             match *position {

src/systems/profiling.rs

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

src/systems/render.rs

@@ -1,9 +1,11 @@
 use crate::constants::CANVAS_SIZE;
 use crate::error::{GameError, TextureError};
 use crate::map::builder::Map;
+use crate::systems::input::TouchState;
 use crate::systems::{
-    DebugState, DebugTextureResource, DeltaTime, DirectionalAnimation, LinearAnimation, Position, Renderable, ScoreResource,
-    StartupSequence, Velocity,
+    debug_render_system, BatchedLinesResource, Collider, CursorPosition, DebugState, DebugTextureResource, DeltaTime,
+    DirectionalAnimation, LinearAnimation, Position, Renderable, ScoreResource, StartupSequence, SystemId, SystemTimings,
+    TtfAtlasResource, Velocity,
 };
 use crate::texture::sprite::SpriteAtlas;
 use crate::texture::text::TextTexture;
@@ -18,6 +20,7 @@ use sdl2::pixels::Color;
 use sdl2::rect::{Point, Rect};
 use sdl2::render::{BlendMode, Canvas, Texture};
 use sdl2::video::Window;
+use std::time::Instant;
 
 #[derive(Resource, Default)]
 pub struct RenderDirty(pub bool);
@@ -25,6 +28,13 @@ pub struct RenderDirty(pub bool);
 #[derive(Component)]
 pub struct Hidden;
 
+/// Enum to identify which texture is being rendered to in the combined render system
+#[derive(Debug, Clone, Copy)]
+enum RenderTarget {
+    Backbuffer,
+    Debug,
+}
+
 #[allow(clippy::type_complexity)]
 pub fn dirty_render_system(
     mut dirty: ResMut<RenderDirty>,
@@ -45,7 +55,7 @@ pub fn directional_render_system(
     dt: Res<DeltaTime>,
     mut query: Query<(&Position, &Velocity, &mut DirectionalAnimation, &mut Renderable)>,
 ) {
-    let ticks = (dt.0 * 60.0).round() as u16; // Convert from seconds to ticks at 60 ticks/sec
+    let ticks = (dt.seconds * 60.0).round() as u16; // Convert from seconds to ticks at 60 ticks/sec
 
     for (position, velocity, mut anim, mut renderable) in query.iter_mut() {
         let stopped = matches!(position, Position::Stopped { .. });
@@ -80,7 +90,7 @@ pub fn directional_render_system(
 ///
 /// This system handles entities that use LinearAnimation component for simple frame cycling.
 pub fn linear_render_system(dt: Res<DeltaTime>, mut query: Query<(&mut LinearAnimation, &mut Renderable)>) {
-    let ticks = (dt.0 * 60.0).round() as u16; // Convert from seconds to ticks at 60 ticks/sec
+    let ticks = (dt.seconds * 60.0).round() as u16; // Convert from seconds to ticks at 60 ticks/sec
 
     for (mut anim, mut renderable) in query.iter_mut() {
         // Tick animation
@@ -105,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>,
@@ -172,59 +255,142 @@ pub fn hud_render_system(
 
 #[allow(clippy::too_many_arguments)]
 pub fn render_system(
+    canvas: &mut Canvas<Window>,
+    map_texture: &NonSendMut<MapTextureResource>,
+    atlas: &mut SpriteAtlas,
+    map: &Res<Map>,
+    dirty: &Res<RenderDirty>,
+    renderables: &Query<(Entity, &Renderable, &Position), Without<Hidden>>,
+    errors: &mut EventWriter<GameError>,
+) {
+    if !dirty.0 {
+        return;
+    }
+
+    // Clear the backbuffer
+    canvas.set_draw_color(sdl2::pixels::Color::BLACK);
+    canvas.clear();
+
+    // Copy the pre-rendered map texture to the backbuffer
+    if let Err(e) = canvas.copy(&map_texture.0, None, None) {
+        errors.write(TextureError::RenderFailed(e.to_string()).into());
+    }
+
+    // Render all entities to the backbuffer
+    for (_, renderable, position) in renderables
+        .iter()
+        .sort_by_key::<(Entity, &Renderable, &Position), _>(|(_, renderable, _)| renderable.layer)
+        .rev()
+    {
+        let pos = position.get_pixel_position(&map.graph);
+        match pos {
+            Ok(pos) => {
+                let dest = Rect::from_center(
+                    Point::from((pos.x as i32, pos.y as i32)),
+                    renderable.sprite.size.x as u32,
+                    renderable.sprite.size.y as u32,
+                );
+
+                renderable
+                    .sprite
+                    .render(canvas, atlas, dest)
+                    .err()
+                    .map(|e| errors.write(TextureError::RenderFailed(e.to_string()).into()));
+            }
+            Err(e) => {
+                errors.write(e);
+            }
+        }
+    }
+}
+
+/// Combined render system that renders to both backbuffer and debug textures in a single
+/// with_multiple_texture_canvas call for reduced overhead
+#[allow(clippy::too_many_arguments)]
+pub fn combined_render_system(
     mut canvas: NonSendMut<&mut Canvas<Window>>,
     map_texture: NonSendMut<MapTextureResource>,
     mut backbuffer: NonSendMut<BackbufferResource>,
+    mut debug_texture: NonSendMut<DebugTextureResource>,
     mut atlas: NonSendMut<SpriteAtlas>,
+    mut ttf_atlas: NonSendMut<TtfAtlasResource>,
+    batched_lines: Res<BatchedLinesResource>,
+    debug_state: Res<DebugState>,
+    timings: Res<SystemTimings>,
+    timing: Res<crate::systems::profiling::Timing>,
     map: Res<Map>,
     dirty: Res<RenderDirty>,
     renderables: Query<(Entity, &Renderable, &Position), Without<Hidden>>,
+    colliders: Query<(&Collider, &Position)>,
+    cursor: Res<CursorPosition>,
     mut errors: EventWriter<GameError>,
 ) {
     if !dirty.0 {
         return;
     }
-    // Render to backbuffer
-    canvas
-        .with_texture_canvas(&mut backbuffer.0, |backbuffer_canvas| {
-            // Clear the backbuffer
-            backbuffer_canvas.set_draw_color(sdl2::pixels::Color::BLACK);
-            backbuffer_canvas.clear();
 
-            // Copy the pre-rendered map texture to the backbuffer
-            if let Err(e) = backbuffer_canvas.copy(&map_texture.0, None, None) {
-                errors.write(TextureError::RenderFailed(e.to_string()).into());
+    // Prepare textures and render targets
+    let textures = [
+        (&mut backbuffer.0, RenderTarget::Backbuffer),
+        (&mut debug_texture.0, RenderTarget::Debug),
+    ];
+
+    // Record timing for each system independently
+    let mut render_duration = None;
+    let mut debug_render_duration = None;
+
+    let result = canvas.with_multiple_texture_canvas(textures.iter(), |texture_canvas, render_target| match render_target {
+        RenderTarget::Backbuffer => {
+            let start_time = Instant::now();
+
+            render_system(
+                texture_canvas,
+                &map_texture,
+                &mut atlas,
+                &map,
+                &dirty,
+                &renderables,
+                &mut errors,
+            );
+
+            render_duration = Some(start_time.elapsed());
+        }
+        RenderTarget::Debug => {
+            if !debug_state.enabled {
+                return;
             }
 
-            // Render all entities to the backbuffer
-            for (_, renderable, position) in renderables
-                .iter()
-                .sort_by_key::<(Entity, &Renderable, &Position), _>(|(_, renderable, _)| renderable.layer)
-                .rev()
-            {
-                let pos = position.get_pixel_position(&map.graph);
-                match pos {
-                    Ok(pos) => {
-                        let dest = Rect::from_center(
-                            Point::from((pos.x as i32, pos.y as i32)),
-                            renderable.sprite.size.x as u32,
-                            renderable.sprite.size.y as u32,
-                        );
+            let start_time = Instant::now();
 
-                        renderable
-                            .sprite
-                            .render(backbuffer_canvas, &mut atlas, dest)
-                            .err()
-                            .map(|e| errors.write(TextureError::RenderFailed(e.to_string()).into()));
-                    }
-                    Err(e) => {
-                        errors.write(e);
-                    }
-                }
-            }
-        })
-        .err()
-        .map(|e| errors.write(TextureError::RenderFailed(e.to_string()).into()));
+            debug_render_system(
+                texture_canvas,
+                &mut ttf_atlas,
+                &batched_lines,
+                &debug_state,
+                &timings,
+                &timing,
+                &map,
+                &colliders,
+                &cursor,
+            );
+
+            debug_render_duration = Some(start_time.elapsed());
+        }
+    });
+
+    if let Err(e) = result {
+        errors.write(TextureError::RenderFailed(e.to_string()).into());
+    }
+
+    // Record timings for each system independently
+    let current_tick = timing.get_current_tick();
+
+    if let Some(duration) = render_duration {
+        timings.add_timing(SystemId::Render, duration, current_tick);
+    }
+    if let Some(duration) = debug_render_duration {
+        timings.add_timing(SystemId::DebugRender, duration, current_tick);
+    }
 }
 
 pub fn present_system(

src/texture/blinking.rs

@@ -1,46 +0,0 @@
-#![allow(dead_code)]
-use crate::texture::sprite::AtlasTile;
-
-#[derive(Clone)]
-pub struct BlinkingTexture {
-    tile: AtlasTile,
-    blink_duration: f32,
-    time_bank: f32,
-    is_on: bool,
-}
-
-impl BlinkingTexture {
-    pub fn new(tile: AtlasTile, blink_duration: f32) -> Self {
-        Self {
-            tile,
-            blink_duration,
-            time_bank: 0.0,
-            is_on: true,
-        }
-    }
-
-    pub fn tick(&mut self, dt: f32) {
-        self.time_bank += dt;
-        if self.time_bank >= self.blink_duration {
-            self.time_bank -= self.blink_duration;
-            self.is_on = !self.is_on;
-        }
-    }
-
-    pub fn is_on(&self) -> bool {
-        self.is_on
-    }
-
-    pub fn tile(&self) -> &AtlasTile {
-        &self.tile
-    }
-
-    // Helper methods for testing
-    pub fn time_bank(&self) -> f32 {
-        self.time_bank
-    }
-
-    pub fn blink_duration(&self) -> f32 {
-        self.blink_duration
-    }
-}

src/texture/mod.rs

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

src/texture/sprite.rs

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

src/texture/sprites.rs

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

src/texture/text.rs

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

tests/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/asset.rs

@@ -0,0 +1,17 @@
+use pacman::asset::Asset;
+use speculoos::prelude::*;
+use strum::IntoEnumIterator;
+
+#[test]
+fn all_asset_paths_exist() {
+    for asset in Asset::iter() {
+        let path = asset.path();
+        let full_path = format!("assets/game/{}", path);
+
+        let metadata = std::fs::metadata(&full_path)
+            .map_err(|e| format!("Error getting metadata for {}: {}", full_path, e))
+            .unwrap();
+        assert_that(&metadata.is_file()).is_true();
+        assert_that(&metadata.len()).is_greater_than(1024);
+    }
+}

tests/blinking.rs

@@ -1,49 +1,316 @@
-use glam::U16Vec2;
-use pacman::texture::blinking::BlinkingTexture;
-use pacman::texture::sprite::AtlasTile;
-use sdl2::pixels::Color;
+use bevy_ecs::{entity::Entity, system::RunSystemOnce, world::World};
+use pacman::systems::{
+    blinking::{blinking_system, Blinking},
+    components::{DeltaTime, Renderable},
+    Frozen, Hidden,
+};
+use speculoos::prelude::*;
 
-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)),
-    }
+mod common;
+
+/// Creates a test world with blinking system resources
+fn create_blinking_test_world() -> World {
+    let mut world = World::new();
+    world.insert_resource(DeltaTime::from_ticks(1));
+    world
+}
+
+/// Spawns a test entity with blinking and renderable components
+fn spawn_blinking_entity(world: &mut World, interval_ticks: u32) -> Entity {
+    world
+        .spawn((
+            Blinking::new(interval_ticks),
+            Renderable {
+                sprite: common::mock_atlas_tile(1),
+                layer: 0,
+            },
+        ))
+        .id()
+}
+
+/// Spawns a test entity with blinking, renderable, and hidden components
+fn spawn_hidden_blinking_entity(world: &mut World, interval_ticks: u32) -> Entity {
+    world
+        .spawn((
+            Blinking::new(interval_ticks),
+            Renderable {
+                sprite: common::mock_atlas_tile(1),
+                layer: 0,
+            },
+            Hidden,
+        ))
+        .id()
+}
+
+/// Spawns a test entity with blinking, renderable, and frozen components
+fn spawn_frozen_blinking_entity(world: &mut World, interval_ticks: u32) -> Entity {
+    world
+        .spawn((
+            Blinking::new(interval_ticks),
+            Renderable {
+                sprite: common::mock_atlas_tile(1),
+                layer: 0,
+            },
+            Frozen,
+        ))
+        .id()
+}
+
+/// Spawns a test entity with blinking, renderable, hidden, and frozen components
+fn spawn_frozen_hidden_blinking_entity(world: &mut World, interval_ticks: u32) -> Entity {
+    world
+        .spawn((
+            Blinking::new(interval_ticks),
+            Renderable {
+                sprite: common::mock_atlas_tile(1),
+                layer: 0,
+            },
+            Hidden,
+            Frozen,
+        ))
+        .id()
+}
+
+/// Runs the blinking system with the given delta time
+fn run_blinking_system(world: &mut World, delta_ticks: u32) {
+    world.resource_mut::<DeltaTime>().ticks = delta_ticks;
+    world.run_system_once(blinking_system).unwrap();
+}
+
+/// Checks if an entity has the Hidden component
+fn has_hidden_component(world: &World, entity: Entity) -> bool {
+    world.entity(entity).contains::<Hidden>()
+}
+
+/// Checks if an entity has the Frozen component
+fn has_frozen_component(world: &World, entity: Entity) -> bool {
+    world.entity(entity).contains::<Frozen>()
 }
 
 #[test]
-fn test_blinking_texture() {
-    let tile = mock_atlas_tile(1);
-    let mut texture = BlinkingTexture::new(tile, 0.5);
+fn test_blinking_component_creation() {
+    let blinking = Blinking::new(10);
 
-    assert!(texture.is_on());
-
-    texture.tick(0.5);
-    assert!(!texture.is_on());
-
-    texture.tick(0.5);
-    assert!(texture.is_on());
-
-    texture.tick(0.5);
-    assert!(!texture.is_on());
+    assert_that(&blinking.tick_timer).is_equal_to(0);
+    assert_that(&blinking.interval_ticks).is_equal_to(10);
 }
 
 #[test]
-fn test_blinking_texture_partial_duration() {
-    let tile = mock_atlas_tile(1);
-    let mut texture = BlinkingTexture::new(tile, 0.5);
+fn test_blinking_system_normal_interval_no_toggle() {
+    let mut world = create_blinking_test_world();
+    let entity = spawn_blinking_entity(&mut world, 5);
 
-    texture.tick(0.625);
-    assert!(!texture.is_on());
-    assert_eq!(texture.time_bank(), 0.125);
+    // Run system with 3 ticks (less than interval)
+    run_blinking_system(&mut world, 3);
+
+    // Entity should not be hidden yet
+    assert_that(&has_hidden_component(&world, entity)).is_false();
+
+    // Check that timer was updated
+    let blinking = world.entity(entity).get::<Blinking>().unwrap();
+    assert_that(&blinking.tick_timer).is_equal_to(3);
 }
 
 #[test]
-fn test_blinking_texture_negative_time() {
-    let tile = mock_atlas_tile(1);
-    let mut texture = BlinkingTexture::new(tile, 0.5);
+fn test_blinking_system_normal_interval_first_toggle() {
+    let mut world = create_blinking_test_world();
+    let entity = spawn_blinking_entity(&mut world, 5);
 
-    texture.tick(-0.1);
-    assert!(texture.is_on());
-    assert_eq!(texture.time_bank(), -0.1);
+    // Run system with 5 ticks (exactly one interval)
+    run_blinking_system(&mut world, 5);
+
+    // Entity should now be hidden
+    assert_that(&has_hidden_component(&world, entity)).is_true();
+
+    // Check that timer was reset
+    let blinking = world.entity(entity).get::<Blinking>().unwrap();
+    assert_that(&blinking.tick_timer).is_equal_to(0);
+}
+
+#[test]
+fn test_blinking_system_normal_interval_second_toggle() {
+    let mut world = create_blinking_test_world();
+    let entity = spawn_blinking_entity(&mut world, 5);
+
+    // First toggle: 5 ticks
+    run_blinking_system(&mut world, 5);
+    assert_that(&has_hidden_component(&world, entity)).is_true();
+
+    // Second toggle: another 5 ticks
+    run_blinking_system(&mut world, 5);
+    assert_that(&has_hidden_component(&world, entity)).is_false();
+}
+
+#[test]
+fn test_blinking_system_normal_interval_multiple_intervals() {
+    let mut world = create_blinking_test_world();
+    let entity = spawn_blinking_entity(&mut world, 3);
+
+    // Run system with 7 ticks (2 complete intervals + 1 remainder)
+    run_blinking_system(&mut world, 7);
+
+    // Should toggle twice (even number), so back to original state (not hidden)
+    assert_that(&has_hidden_component(&world, entity)).is_false();
+
+    // Check that timer was updated to remainder
+    let blinking = world.entity(entity).get::<Blinking>().unwrap();
+    assert_that(&blinking.tick_timer).is_equal_to(1);
+}
+
+#[test]
+fn test_blinking_system_normal_interval_odd_intervals() {
+    let mut world = create_blinking_test_world();
+    let entity = spawn_blinking_entity(&mut world, 2);
+
+    // Run system with 5 ticks (2 complete intervals + 1 remainder)
+    run_blinking_system(&mut world, 5);
+
+    // Should toggle twice (even number), so back to original state (not hidden)
+    assert_that(&has_hidden_component(&world, entity)).is_false();
+
+    // Check that timer was updated to remainder
+    let blinking = world.entity(entity).get::<Blinking>().unwrap();
+    assert_that(&blinking.tick_timer).is_equal_to(1);
+}
+
+#[test]
+fn test_blinking_system_zero_interval_with_ticks() {
+    let mut world = create_blinking_test_world();
+    let entity = spawn_blinking_entity(&mut world, 0);
+
+    // Run system with any positive ticks
+    run_blinking_system(&mut world, 1);
+
+    // Entity should be hidden immediately
+    assert_that(&has_hidden_component(&world, entity)).is_true();
+}
+
+#[test]
+fn test_blinking_system_zero_interval_no_ticks() {
+    let mut world = create_blinking_test_world();
+    let entity = spawn_blinking_entity(&mut world, 0);
+
+    // Run system with 0 ticks
+    run_blinking_system(&mut world, 0);
+
+    // Entity should not be hidden (no time passed)
+    assert_that(&has_hidden_component(&world, entity)).is_false();
+}
+
+#[test]
+fn test_blinking_system_zero_interval_toggle_back() {
+    let mut world = create_blinking_test_world();
+    let entity = spawn_hidden_blinking_entity(&mut world, 0);
+
+    // Run system with any positive ticks
+    run_blinking_system(&mut world, 1);
+
+    // Entity should be unhidden
+    assert_that(&has_hidden_component(&world, entity)).is_false();
+}
+
+#[test]
+fn test_blinking_system_frozen_entity_unhidden() {
+    let mut world = create_blinking_test_world();
+    let entity = spawn_frozen_hidden_blinking_entity(&mut world, 5);
+
+    // Run system with ticks
+    run_blinking_system(&mut world, 10);
+
+    // Frozen entity should be unhidden and stay unhidden
+    assert_that(&has_hidden_component(&world, entity)).is_false();
+    assert_that(&has_frozen_component(&world, entity)).is_true();
+}
+
+#[test]
+fn test_blinking_system_frozen_entity_no_blinking() {
+    let mut world = create_blinking_test_world();
+    let entity = spawn_frozen_blinking_entity(&mut world, 5);
+
+    // Run system with ticks
+    run_blinking_system(&mut world, 10);
+
+    // Frozen entity should not be hidden (blinking disabled)
+    assert_that(&has_hidden_component(&world, entity)).is_false();
+    assert_that(&has_frozen_component(&world, entity)).is_true();
+}
+
+#[test]
+fn test_blinking_system_frozen_entity_timer_not_updated() {
+    let mut world = create_blinking_test_world();
+    let entity = spawn_frozen_blinking_entity(&mut world, 5);
+
+    // Run system with ticks
+    run_blinking_system(&mut world, 10);
+
+    // Timer should not be updated for frozen entities
+    let blinking = world.entity(entity).get::<Blinking>().unwrap();
+    assert_that(&blinking.tick_timer).is_equal_to(0);
+}
+
+#[test]
+fn test_blinking_system_entity_without_renderable_ignored() {
+    let mut world = create_blinking_test_world();
+
+    // Spawn entity with only Blinking component (no Renderable)
+    let entity = world.spawn(Blinking::new(5)).id();
+
+    // Run system
+    run_blinking_system(&mut world, 10);
+
+    // Entity should not be affected (not in query)
+    assert_that(&has_hidden_component(&world, entity)).is_false();
+}
+
+#[test]
+fn test_blinking_system_entity_without_blinking_ignored() {
+    let mut world = create_blinking_test_world();
+
+    // Spawn entity with only Renderable component (no Blinking)
+    let entity = world
+        .spawn(Renderable {
+            sprite: common::mock_atlas_tile(1),
+            layer: 0,
+        })
+        .id();
+
+    // Run system
+    run_blinking_system(&mut world, 10);
+
+    // Entity should not be affected (not in query)
+    assert_that(&has_hidden_component(&world, entity)).is_false();
+}
+
+#[test]
+fn test_blinking_system_large_interval() {
+    let mut world = create_blinking_test_world();
+    let entity = spawn_blinking_entity(&mut world, 1000);
+
+    // Run system with 500 ticks (less than interval)
+    run_blinking_system(&mut world, 500);
+
+    // Entity should not be hidden yet
+    assert_that(&has_hidden_component(&world, entity)).is_false();
+
+    // Check that timer was updated
+    let blinking = world.entity(entity).get::<Blinking>().unwrap();
+    assert_that(&blinking.tick_timer).is_equal_to(500);
+}
+
+#[test]
+fn test_blinking_system_very_small_interval() {
+    let mut world = create_blinking_test_world();
+    let entity = spawn_blinking_entity(&mut world, 1);
+
+    // Run system with 1 tick
+    run_blinking_system(&mut world, 1);
+
+    // Entity should be hidden
+    assert_that(&has_hidden_component(&world, entity)).is_true();
+
+    // Run system with another 1 tick
+    run_blinking_system(&mut world, 1);
+
+    // Entity should be unhidden
+    assert_that(&has_hidden_component(&world, entity)).is_false();
 }

tests/collision.rs

@@ -1,73 +1,8 @@
-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 speculoos::prelude::*;
 
-use pacman::{
-    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()
-}
+mod common;
 
 #[test]
 fn test_collider_collision_detection() {
@@ -75,13 +10,13 @@ fn test_collider_collision_detection() {
     let collider2 = Collider { size: 8.0 };
 
     // Test collision detection
-    assert!(collider1.collides_with(collider2.size, 5.0)); // Should collide (distance < 9.0)
-    assert!(!collider1.collides_with(collider2.size, 15.0)); // Should not collide (distance > 9.0)
+    assert_that(&collider1.collides_with(collider2.size, 5.0)).is_true(); // Should collide (distance < 9.0)
+    assert_that(&collider1.collides_with(collider2.size, 15.0)).is_false(); // Should not collide (distance > 9.0)
 }
 
 #[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 };
@@ -89,21 +24,21 @@ fn test_check_collision_helper() {
 
     // Test collision at same position
     let result = check_collision(&pos1, &collider1, &pos2, &collider2, &map);
-    assert!(result.is_ok());
-    assert!(result.unwrap()); // Should collide at same position
+    assert_that(&result.is_ok()).is_true();
+    assert_that(&result.unwrap()).is_true(); // Should collide at same position
 
     // Test collision at different positions
     let pos3 = Position::Stopped { node: 1 }; // Different position
     let result = check_collision(&pos1, &collider1, &pos3, &collider2, &map);
-    assert!(result.is_ok());
+    assert_that(&result.is_ok()).is_true();
     // May or may not collide depending on actual node positions
 }
 
 #[test]
 fn test_collision_system_pacman_item() {
-    let mut world = create_test_world();
-    let _pacman = spawn_test_pacman(&mut world);
-    let _item = spawn_test_item(&mut world);
+    let mut world = common::create_test_world();
+    let _pacman = common::spawn_test_pacman(&mut world, 0);
+    let _item = common::spawn_test_item(&mut world, 0, EntityType::Pellet);
 
     // Run collision system - should not panic
     world
@@ -113,9 +48,9 @@ fn test_collision_system_pacman_item() {
 
 #[test]
 fn test_collision_system_pacman_ghost() {
-    let mut world = create_test_world();
-    let _pacman = spawn_test_pacman(&mut world);
-    let _ghost = spawn_test_ghost(&mut world);
+    let mut world = common::create_test_world();
+    let _pacman = common::spawn_test_pacman(&mut world, 0);
+    let _ghost = common::spawn_test_ghost(&mut world, 0, GhostState::Normal);
 
     // Run collision system - should not panic
     world
@@ -125,9 +60,9 @@ fn test_collision_system_pacman_ghost() {
 
 #[test]
 fn test_collision_system_no_collision() {
-    let mut world = create_test_world();
-    let _pacman = spawn_test_pacman(&mut world);
-    let _ghost = spawn_test_ghost_at_node(&mut world, 1); // Different node
+    let mut world = common::create_test_world();
+    let _pacman = common::spawn_test_pacman(&mut world, 0);
+    let _ghost = common::spawn_test_ghost(&mut world, 1, GhostState::Normal); // Different node
 
     // Run collision system - should not panic
     world
@@ -137,10 +72,10 @@ fn test_collision_system_no_collision() {
 
 #[test]
 fn test_collision_system_multiple_entities() {
-    let mut world = create_test_world();
-    let _pacman = spawn_test_pacman(&mut world);
-    let _item = spawn_test_item(&mut world);
-    let _ghost = spawn_test_ghost(&mut world);
+    let mut world = common::create_test_world();
+    let _pacman = common::spawn_test_pacman(&mut world, 0);
+    let _item = common::spawn_test_item(&mut world, 0, EntityType::Pellet);
+    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,125 @@ 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 {
+        seconds: 1.0 / 60.0,
+        ticks: 1,
+    }); // 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/constants.rs

@@ -1,35 +0,0 @@
-use pacman::constants::*;
-
-#[test]
-fn test_raw_board_structure() {
-    // Test board dimensions match expected size
-    assert_eq!(RAW_BOARD.len(), BOARD_CELL_SIZE.y as usize);
-    for row in RAW_BOARD.iter() {
-        assert_eq!(row.len(), BOARD_CELL_SIZE.x as usize);
-    }
-
-    // Test boundaries are properly walled
-    assert!(RAW_BOARD[0].chars().all(|c| c == '#'));
-    assert!(RAW_BOARD[RAW_BOARD.len() - 1].chars().all(|c| c == '#'));
-}
-
-#[test]
-fn test_raw_board_contains_required_elements() {
-    // Test that essential game elements are present
-    assert!(
-        RAW_BOARD.iter().any(|row| row.contains('X')),
-        "Board should contain Pac-Man start position"
-    );
-    assert!(
-        RAW_BOARD.iter().any(|row| row.contains("==")),
-        "Board should contain ghost house door"
-    );
-    assert!(
-        RAW_BOARD.iter().any(|row| row.chars().any(|c| c == 'T')),
-        "Board should contain tunnel entrances"
-    );
-    assert!(
-        RAW_BOARD.iter().any(|row| row.chars().any(|c| c == 'o')),
-        "Board should contain power pellets"
-    );
-}

tests/direction.rs

@@ -1,5 +1,5 @@
-use glam::I8Vec2;
 use pacman::map::direction::*;
+use speculoos::prelude::*;
 
 #[test]
 fn test_direction_opposite() {
@@ -11,21 +11,47 @@ fn test_direction_opposite() {
     ];
 
     for (dir, expected) in test_cases {
-        assert_eq!(dir.opposite(), expected);
+        assert_that(&dir.opposite()).is_equal_to(expected);
     }
 }
 
 #[test]
-fn test_direction_as_ivec2() {
-    let test_cases = [
-        (Direction::Up, -I8Vec2::Y),
-        (Direction::Down, I8Vec2::Y),
-        (Direction::Left, -I8Vec2::X),
-        (Direction::Right, I8Vec2::X),
-    ];
-
-    for (dir, expected) in test_cases {
-        assert_eq!(dir.as_ivec2(), expected);
-        assert_eq!(I8Vec2::from(dir), expected);
+fn test_direction_opposite_symmetry() {
+    // Test that opposite() is symmetric: opposite(opposite(d)) == d
+    for &dir in &Direction::DIRECTIONS {
+        assert_that(&dir.opposite().opposite()).is_equal_to(dir);
     }
 }
+
+#[test]
+fn test_direction_opposite_exhaustive() {
+    // Test that every direction has a unique opposite
+    let mut opposites = std::collections::HashSet::new();
+    for &dir in &Direction::DIRECTIONS {
+        let opposite = dir.opposite();
+        assert_that(&opposites.insert(opposite)).is_true();
+    }
+    assert_that(&opposites).has_length(4);
+}
+
+#[test]
+fn test_direction_as_usize_exhaustive() {
+    // Test that as_usize() returns unique values for all directions
+    let mut usizes = std::collections::HashSet::new();
+    for &dir in &Direction::DIRECTIONS {
+        let usize_val = dir.as_usize();
+        assert_that(&usizes.insert(usize_val)).is_true();
+    }
+    assert_that(&usizes).has_length(4);
+}
+
+#[test]
+fn test_direction_as_ivec2_exhaustive() {
+    // Test that as_ivec2() returns unique values for all directions
+    let mut ivec2s = std::collections::HashSet::new();
+    for &dir in &Direction::DIRECTIONS {
+        let ivec2_val = dir.as_ivec2();
+        assert_that(&ivec2s.insert(ivec2_val)).is_true();
+    }
+    assert_that(&ivec2s).has_length(4);
+}

tests/error.rs

@@ -1,83 +1,15 @@
-use pacman::error::{
-    AssetError, EntityError, GameError, GameResult, IntoGameError, MapError, OptionExt, ParseError, ResultExt, TextureError,
-};
+use pacman::error::{GameError, GameResult, IntoGameError, OptionExt, ResultExt};
+use speculoos::prelude::*;
 use std::io;
 
-#[test]
-fn test_game_error_from_asset_error() {
-    let asset_error = AssetError::NotFound("test.png".to_string());
-    let game_error: GameError = asset_error.into();
-    assert!(matches!(game_error, GameError::Asset(_)));
-}
-
-#[test]
-fn test_game_error_from_parse_error() {
-    let parse_error = ParseError::UnknownCharacter('Z');
-    let game_error: GameError = parse_error.into();
-    assert!(matches!(game_error, GameError::MapParse(_)));
-}
-
-#[test]
-fn test_game_error_from_map_error() {
-    let map_error = MapError::NodeNotFound(42);
-    let game_error: GameError = map_error.into();
-    assert!(matches!(game_error, GameError::Map(_)));
-}
-
-#[test]
-fn test_game_error_from_texture_error() {
-    let texture_error = TextureError::LoadFailed("Failed to load".to_string());
-    let game_error: GameError = texture_error.into();
-    assert!(matches!(game_error, GameError::Texture(_)));
-}
-
-#[test]
-fn test_game_error_from_entity_error() {
-    let entity_error = EntityError::NodeNotFound(10);
-    let game_error: GameError = entity_error.into();
-    assert!(matches!(game_error, GameError::Entity(_)));
-}
-
-#[test]
-fn test_game_error_from_io_error() {
-    let io_error = io::Error::new(io::ErrorKind::NotFound, "File not found");
-    let game_error: GameError = io_error.into();
-    assert!(matches!(game_error, GameError::Io(_)));
-}
-
-#[test]
-fn test_asset_error_from_io_error() {
-    let io_error = io::Error::new(io::ErrorKind::PermissionDenied, "Permission denied");
-    let asset_error: AssetError = io_error.into();
-    assert!(matches!(asset_error, AssetError::Io(_)));
-}
-
-#[test]
-fn test_parse_error_display() {
-    let error = ParseError::UnknownCharacter('!');
-    assert_eq!(error.to_string(), "Unknown character in board: !");
-
-    let error = ParseError::InvalidHouseDoorCount(3);
-    assert_eq!(error.to_string(), "House door must have exactly 2 positions, found 3");
-}
-
-#[test]
-fn test_entity_error_display() {
-    let error = EntityError::NodeNotFound(42);
-    assert_eq!(error.to_string(), "Node not found in graph: 42");
-
-    let error = EntityError::EdgeNotFound { from: 1, to: 2 };
-    assert_eq!(error.to_string(), "Edge not found: from 1 to 2");
-}
-
 #[test]
 fn test_into_game_error_trait() {
     let result: Result<i32, io::Error> = Err(io::Error::new(io::ErrorKind::Other, "test error"));
     let game_result: GameResult<i32> = result.into_game_error();
 
-    assert!(game_result.is_err());
+    assert_that(&game_result.is_err()).is_true();
     if let Err(GameError::InvalidState(msg)) = game_result {
-        assert!(msg.contains("test error"));
+        assert_that(&msg.contains("test error")).is_true();
     } else {
         panic!("Expected InvalidState error");
     }
@@ -88,7 +20,7 @@ fn test_into_game_error_trait_success() {
     let result: Result<i32, io::Error> = Ok(42);
     let game_result: GameResult<i32> = result.into_game_error();
 
-    assert_eq!(game_result.unwrap(), 42);
+    assert_that(&game_result.unwrap()).is_equal_to(42);
 }
 
 #[test]
@@ -96,7 +28,7 @@ fn test_option_ext_some() {
     let option: Option<i32> = Some(42);
     let result: GameResult<i32> = option.ok_or_game_error(|| GameError::InvalidState("Not found".to_string()));
 
-    assert_eq!(result.unwrap(), 42);
+    assert_that(&result.unwrap()).is_equal_to(42);
 }
 
 #[test]
@@ -104,9 +36,9 @@ fn test_option_ext_none() {
     let option: Option<i32> = None;
     let result: GameResult<i32> = option.ok_or_game_error(|| GameError::InvalidState("Not found".to_string()));
 
-    assert!(result.is_err());
+    assert_that(&result.is_err()).is_true();
     if let Err(GameError::InvalidState(msg)) = result {
-        assert_eq!(msg, "Not found");
+        assert_that(&msg).is_equal_to("Not found".to_string());
     } else {
         panic!("Expected InvalidState error");
     }
@@ -117,7 +49,7 @@ fn test_result_ext_success() {
     let result: Result<i32, io::Error> = Ok(42);
     let game_result: GameResult<i32> = result.with_context(|_| GameError::InvalidState("Context".to_string()));
 
-    assert_eq!(game_result.unwrap(), 42);
+    assert_that(&game_result.unwrap()).is_equal_to(42);
 }
 
 #[test]
@@ -125,9 +57,9 @@ fn test_result_ext_error() {
     let result: Result<i32, io::Error> = Err(io::Error::new(io::ErrorKind::Other, "original error"));
     let game_result: GameResult<i32> = result.with_context(|_| GameError::InvalidState("Context error".to_string()));
 
-    assert!(game_result.is_err());
+    assert_that(&game_result.is_err()).is_true();
     if let Err(GameError::InvalidState(msg)) = game_result {
-        assert_eq!(msg, "Context error");
+        assert_that(&msg).is_equal_to("Context error".to_string());
     } else {
         panic!("Expected InvalidState error");
     }

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/formatting.rs

@@ -1,8 +1,7 @@
 use pacman::systems::profiling::format_timing_display;
+use speculoos::prelude::*;
 use std::time::Duration;
 
-use pretty_assertions::assert_eq;
-
 fn get_timing_data() -> Vec<(String, Duration, Duration)> {
     vec![
         ("total".to_string(), Duration::from_micros(1234), Duration::from_micros(570)),
@@ -53,45 +52,25 @@ fn test_complex_formatting_alignment() {
     });
 
     // Assert that all positions were found
-    assert_eq!(
-        [
+    assert_that(
+        &[
             &colon_positions,
             &first_decimal_positions,
             &second_decimal_positions,
             &first_unit_positions,
-            &second_unit_positions
+            &second_unit_positions,
         ]
         .iter()
         .all(|p| p.len() == 6),
-        true
-    );
+    )
+    .is_true();
 
     // Assert that all positions are the same
-    assert!(
-        colon_positions.iter().all(|&p| p == colon_positions[0]),
-        "colon positions are not the same {:?}",
-        colon_positions
-    );
-    assert!(
-        first_decimal_positions.iter().all(|&p| p == first_decimal_positions[0]),
-        "first decimal positions are not the same {:?}",
-        first_decimal_positions
-    );
-    assert!(
-        second_decimal_positions.iter().all(|&p| p == second_decimal_positions[0]),
-        "second decimal positions are not the same {:?}",
-        second_decimal_positions
-    );
-    assert!(
-        first_unit_positions.iter().all(|&p| p == first_unit_positions[0]),
-        "first unit positions are not the same {:?}",
-        first_unit_positions
-    );
-    assert!(
-        second_unit_positions.iter().all(|&p| p == second_unit_positions[0]),
-        "second unit positions are not the same {:?}",
-        second_unit_positions
-    );
+    assert_that(&colon_positions.iter().all(|&p| p == colon_positions[0])).is_true();
+    assert_that(&first_decimal_positions.iter().all(|&p| p == first_decimal_positions[0])).is_true();
+    assert_that(&second_decimal_positions.iter().all(|&p| p == second_decimal_positions[0])).is_true();
+    assert_that(&first_unit_positions.iter().all(|&p| p == first_unit_positions[0])).is_true();
+    assert_that(&second_unit_positions.iter().all(|&p| p == second_unit_positions[0])).is_true();
 }
 
 #[test]
@@ -105,17 +84,17 @@ fn test_format_timing_display_basic() {
     let formatted = format_timing_display(timing_data);
 
     // Should have 3 lines (one for each system)
-    assert_eq!(formatted.len(), 3);
+    assert_that(&formatted.len()).is_equal_to(3);
 
     // Each line should contain the system name
-    assert!(formatted.iter().any(|line| line.contains("render")));
-    assert!(formatted.iter().any(|line| line.contains("input")));
-    assert!(formatted.iter().any(|line| line.contains("physics")));
+    assert_that(&formatted.iter().any(|line| line.contains("render"))).is_true();
+    assert_that(&formatted.iter().any(|line| line.contains("input"))).is_true();
+    assert_that(&formatted.iter().any(|line| line.contains("physics"))).is_true();
 
     // Each line should contain timing information with proper units
     for line in formatted.iter() {
-        assert!(line.contains(":"), "Line should contain colon separator: {}", line);
-        assert!(line.contains("±"), "Line should contain ± symbol: {}", line);
+        assert_that(&line.contains(":")).is_true();
+        assert_that(&line.contains("±")).is_true();
     }
 }
 
@@ -132,10 +111,10 @@ fn test_format_timing_display_units() {
 
     // Check that appropriate units are used
     let all_lines = formatted.join(" ");
-    assert!(all_lines.contains("s"), "Should contain seconds unit");
-    assert!(all_lines.contains("ms"), "Should contain milliseconds unit");
-    assert!(all_lines.contains("µs"), "Should contain microseconds unit");
-    assert!(all_lines.contains("ns"), "Should contain nanoseconds unit");
+    assert_that(&all_lines.contains("s")).is_true();
+    assert_that(&all_lines.contains("ms")).is_true();
+    assert_that(&all_lines.contains("µs")).is_true();
+    assert_that(&all_lines.contains("ns")).is_true();
 }
 
 #[test]
@@ -157,9 +136,6 @@ fn test_format_timing_display_alignment() {
     // All colons should be at the same position (aligned)
     if colon_positions.len() > 1 {
         let first_pos = colon_positions[0];
-        assert!(
-            colon_positions.iter().all(|&pos| pos == first_pos),
-            "Colons should be aligned at the same position"
-        );
+        assert_that(&colon_positions.iter().all(|&pos| pos == first_pos)).is_true();
     }
 }

tests/game.rs

@@ -0,0 +1,79 @@
+use pacman::error::{GameError, GameResult};
+use pacman::game::Game;
+use speculoos::prelude::*;
+
+mod common;
+
+use common::setup_sdl;
+
+#[test]
+fn test_game_30_seconds_60fps() -> GameResult<()> {
+    let (canvas, texture_creator, _sdl_context) = setup_sdl().map_err(GameError::Sdl)?;
+    let ttf_context = sdl2::ttf::init().map_err(GameError::Sdl)?;
+    let event_pump = _sdl_context
+        .event_pump()
+        .map_err(|e| pacman::error::GameError::Sdl(e.to_string()))?;
+
+    let mut game = Game::new(canvas, ttf_context, texture_creator, event_pump)?;
+
+    // Run for 30 seconds at 60 FPS = 1800 frames
+    let frame_time = 1.0 / 60.0;
+    let total_frames = 1800;
+    let mut frame_count = 0;
+
+    for _ in 0..total_frames {
+        let should_exit = game.tick(frame_time);
+
+        if should_exit {
+            break;
+        }
+
+        frame_count += 1;
+    }
+
+    assert_eq!(
+        frame_count, total_frames,
+        "Should have processed exactly {} frames",
+        total_frames
+    );
+    Ok(())
+}
+
+/// Test that runs the game for 30 seconds with variable frame timing
+#[test]
+fn test_game_30_seconds_variable_timing() -> GameResult<()> {
+    let (canvas, texture_creator, _sdl_context) = setup_sdl().map_err(GameError::Sdl)?;
+    let ttf_context = sdl2::ttf::init().map_err(|e| GameError::Sdl(e.to_string()))?;
+    let event_pump = _sdl_context
+        .event_pump()
+        .map_err(|e| pacman::error::GameError::Sdl(e.to_string()))?;
+
+    let mut game = Game::new(canvas, ttf_context, texture_creator, event_pump)?;
+
+    // Simulate 30 seconds with variable frame timing
+    let mut total_time = 0.0;
+    let target_time = 30.0;
+    let mut frame_count = 0;
+
+    while total_time < target_time {
+        // Alternate between different frame rates to simulate real gameplay
+        let frame_time = match frame_count % 4 {
+            0 => 1.0 / 60.0,  // 60 FPS
+            1 => 1.0 / 30.0,  // 30 FPS (lag spike)
+            2 => 1.0 / 120.0, // 120 FPS (very fast)
+            _ => 1.0 / 60.0,  // 60 FPS
+        };
+
+        let should_exit = game.tick(frame_time);
+
+        if should_exit {
+            break;
+        }
+
+        total_time += frame_time;
+        frame_count += 1;
+    }
+
+    assert_that(&total_time).is_greater_than_or_equal_to(target_time);
+    Ok(())
+}

tests/graph.rs

@@ -1,23 +1,8 @@
 use pacman::map::direction::Direction;
 use pacman::map::graph::{Graph, Node, TraversalFlags};
+use speculoos::prelude::*;
 
-fn create_test_graph() -> Graph {
-    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
-}
+mod common;
 
 #[test]
 fn test_graph_basic_operations() {
@@ -29,10 +14,10 @@ fn test_graph_basic_operations() {
         position: glam::Vec2::new(16.0, 0.0),
     });
 
-    assert_eq!(graph.nodes().count(), 2);
-    assert!(graph.get_node(node1).is_some());
-    assert!(graph.get_node(node2).is_some());
-    assert!(graph.get_node(999).is_none());
+    assert_that(&graph.nodes().count()).is_equal_to(2);
+    assert_that(&graph.get_node(node1).is_some()).is_true();
+    assert_that(&graph.get_node(node2).is_some()).is_true();
+    assert_that(&graph.get_node(999).is_none()).is_true();
 }
 
 #[test]
@@ -45,15 +30,15 @@ fn test_graph_connect() {
         position: glam::Vec2::new(16.0, 0.0),
     });
 
-    assert!(graph.connect(node1, node2, false, None, Direction::Right).is_ok());
+    assert_that(&graph.connect(node1, node2, false, None, Direction::Right).is_ok()).is_true();
 
     let edge1 = graph.find_edge_in_direction(node1, Direction::Right);
     let edge2 = graph.find_edge_in_direction(node2, Direction::Left);
 
-    assert!(edge1.is_some());
-    assert!(edge2.is_some());
-    assert_eq!(edge1.unwrap().target, node2);
-    assert_eq!(edge2.unwrap().target, node1);
+    assert_that(&edge1.is_some()).is_true();
+    assert_that(&edge2.is_some()).is_true();
+    assert_that(&edge1.unwrap().target).is_equal_to(node2);
+    assert_that(&edge2.unwrap().target).is_equal_to(node1);
 }
 
 #[test]
@@ -63,8 +48,8 @@ fn test_graph_connect_errors() {
         position: glam::Vec2::new(0.0, 0.0),
     });
 
-    assert!(graph.connect(node1, 999, false, None, Direction::Right).is_err());
-    assert!(graph.connect(999, node1, false, None, Direction::Right).is_err());
+    assert_that(&graph.connect(node1, 999, false, None, Direction::Right).is_err()).is_true();
+    assert_that(&graph.connect(999, node1, false, None, Direction::Right).is_err()).is_true();
 }
 
 #[test]
@@ -82,7 +67,7 @@ fn test_graph_edge_permissions() {
         .unwrap();
 
     let edge = graph.find_edge_in_direction(node1, Direction::Right).unwrap();
-    assert_eq!(edge.traversal_flags, TraversalFlags::GHOST);
+    assert_that(&edge.traversal_flags).is_equal_to(TraversalFlags::GHOST);
 }
 
 #[test]
@@ -102,10 +87,10 @@ fn should_add_connected_node() {
         )
         .unwrap();
 
-    assert_eq!(graph.nodes().count(), 2);
+    assert_that(&graph.nodes().count()).is_equal_to(2);
     let edge = graph.find_edge(node1, node2);
-    assert!(edge.is_some());
-    assert_eq!(edge.unwrap().direction, Direction::Right);
+    assert_that(&edge.is_some()).is_true();
+    assert_that(&edge.unwrap().direction).is_equal_to(Direction::Right);
 }
 
 #[test]
@@ -119,33 +104,33 @@ fn should_error_on_negative_edge_distance() {
     });
 
     let result = graph.add_edge(node1, node2, false, Some(-1.0), Direction::Right, TraversalFlags::ALL);
-    assert!(result.is_err());
+    assert_that(&result.is_err()).is_true();
 }
 
 #[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());
+    assert_that(&result.is_err()).is_true();
 }
 
 #[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());
+    assert_that(&result.is_ok()).is_true();
 
     let edge = graph.find_edge(0, 1).unwrap();
-    assert_eq!(edge.distance, 42.0);
+    assert_that(&edge.distance).is_equal_to(42.0);
 }
 
 #[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);
+    assert_that(&edge.is_some()).is_true();
+    assert_that(&edge.unwrap().target).is_equal_to(1);
 
     let non_existent_edge = graph.find_edge(0, 99);
-    assert!(non_existent_edge.is_none());
+    assert_that(&non_existent_edge.is_none()).is_true();
 }

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/input.rs

@@ -1,38 +1,321 @@
+use glam::Vec2;
 use pacman::events::{GameCommand, GameEvent};
 use pacman::map::direction::Direction;
-use pacman::systems::input::{process_simple_key_events, Bindings, SimpleKeyEvent};
+use pacman::systems::input::{
+    calculate_direction_from_delta, process_simple_key_events, update_touch_reference_position, Bindings, CursorPosition,
+    SimpleKeyEvent, TouchData, TouchState, TOUCH_DIRECTION_THRESHOLD, TOUCH_EASING_DISTANCE_THRESHOLD,
+};
 use sdl2::keyboard::Keycode;
+use speculoos::prelude::*;
 
-#[test]
-fn resumes_previous_direction_when_secondary_key_released() {
-    let mut bindings = Bindings::default();
+// Test modules for better organization
+mod keyboard_tests {
+    use super::*;
 
-    // Frame 1: Press W (Up) => emits Move Up
-    let events = process_simple_key_events(&mut bindings, &[SimpleKeyEvent::KeyDown(Keycode::W)]);
-    assert!(events.contains(&GameEvent::Command(GameCommand::MovePlayer(Direction::Up))));
+    #[test]
+    fn key_down_emits_bound_command() {
+        let mut bindings = Bindings::default();
+        let events = process_simple_key_events(&mut bindings, &[SimpleKeyEvent::KeyDown(Keycode::W)]);
+        assert_that(&events).contains(GameEvent::Command(GameCommand::MovePlayer(Direction::Up)));
+    }
 
-    // Frame 2: Press D (Right) => emits Move Right
-    let events = process_simple_key_events(&mut bindings, &[SimpleKeyEvent::KeyDown(Keycode::D)]);
-    assert!(events.contains(&GameEvent::Command(GameCommand::MovePlayer(Direction::Right))));
+    #[test]
+    fn key_down_emits_non_movement_commands() {
+        let mut bindings = Bindings::default();
+        let events = process_simple_key_events(&mut bindings, &[SimpleKeyEvent::KeyDown(Keycode::P)]);
+        assert_that(&events).contains(GameEvent::Command(GameCommand::TogglePause));
+    }
 
-    // Frame 3: Release D, no new key this frame => should continue previous key W (Up)
-    let events = process_simple_key_events(&mut bindings, &[SimpleKeyEvent::KeyUp(Keycode::D)]);
-    assert!(events.contains(&GameEvent::Command(GameCommand::MovePlayer(Direction::Up))));
+    #[test]
+    fn unbound_key_emits_nothing() {
+        let mut bindings = Bindings::default();
+        let events = process_simple_key_events(&mut bindings, &[SimpleKeyEvent::KeyDown(Keycode::Z)]);
+        assert_that(&events).is_empty();
+    }
+
+    #[test]
+    fn movement_key_held_continues_across_frames() {
+        let mut bindings = Bindings::default();
+        process_simple_key_events(&mut bindings, &[SimpleKeyEvent::KeyDown(Keycode::Left)]);
+        let events = process_simple_key_events(&mut bindings, &[]);
+        assert_that(&events).contains(GameEvent::Command(GameCommand::MovePlayer(Direction::Left)));
+    }
+
+    #[test]
+    fn releasing_movement_key_stops_continuation() {
+        let mut bindings = Bindings::default();
+        process_simple_key_events(&mut bindings, &[SimpleKeyEvent::KeyDown(Keycode::Up)]);
+        let events = process_simple_key_events(&mut bindings, &[SimpleKeyEvent::KeyUp(Keycode::Up)]);
+        assert_that(&events).is_empty();
+    }
+
+    #[test]
+    fn multiple_movement_keys_resumes_previous_when_current_released() {
+        let mut bindings = Bindings::default();
+        process_simple_key_events(&mut bindings, &[SimpleKeyEvent::KeyDown(Keycode::W)]);
+        process_simple_key_events(&mut bindings, &[SimpleKeyEvent::KeyDown(Keycode::D)]);
+        let events = process_simple_key_events(&mut bindings, &[SimpleKeyEvent::KeyUp(Keycode::D)]);
+        assert_that(&events).contains(GameEvent::Command(GameCommand::MovePlayer(Direction::Up)));
+    }
 }
 
-#[test]
-fn holds_last_pressed_key_across_frames_when_no_new_input() {
-    let mut bindings = Bindings::default();
+mod direction_calculation_tests {
+    use super::*;
 
-    // Frame 1: Press Left
-    let events = process_simple_key_events(&mut bindings, &[SimpleKeyEvent::KeyDown(Keycode::Left)]);
-    assert!(events.contains(&GameEvent::Command(GameCommand::MovePlayer(Direction::Left))));
+    #[test]
+    fn prioritizes_horizontal_movement() {
+        let test_cases = vec![
+            (Vec2::new(6.0, 5.0), Direction::Right),
+            (Vec2::new(-6.0, 5.0), Direction::Left),
+        ];
 
-    // Frame 2: No input => continues Left
-    let events = process_simple_key_events(&mut bindings, &[]);
-    assert!(events.contains(&GameEvent::Command(GameCommand::MovePlayer(Direction::Left))));
+        for (delta, expected) in test_cases {
+            assert_that(&calculate_direction_from_delta(delta)).is_equal_to(expected);
+        }
+    }
 
-    // Frame 3: Release Left, no input remains => nothing emitted
-    let events = process_simple_key_events(&mut bindings, &[SimpleKeyEvent::KeyUp(Keycode::Left)]);
-    assert!(events.is_empty());
+    #[test]
+    fn uses_vertical_when_dominant() {
+        let test_cases = vec![
+            (Vec2::new(3.0, 10.0), Direction::Down),
+            (Vec2::new(3.0, -10.0), Direction::Up),
+        ];
+
+        for (delta, expected) in test_cases {
+            assert_that(&calculate_direction_from_delta(delta)).is_equal_to(expected);
+        }
+    }
+
+    #[test]
+    fn handles_zero_delta() {
+        let delta = Vec2::ZERO;
+        // Should default to Up when both components are zero
+        assert_that(&calculate_direction_from_delta(delta)).is_equal_to(Direction::Up);
+    }
+
+    #[test]
+    fn handles_equal_magnitudes() {
+        // When x and y have equal absolute values, should prioritize vertical
+        let delta = Vec2::new(5.0, 5.0);
+        assert_that(&calculate_direction_from_delta(delta)).is_equal_to(Direction::Down);
+
+        let delta = Vec2::new(-5.0, 5.0);
+        assert_that(&calculate_direction_from_delta(delta)).is_equal_to(Direction::Down);
+    }
+}
+
+mod touch_easing_tests {
+    use super::*;
+
+    #[test]
+    fn easing_within_threshold_does_nothing() {
+        let mut touch_data = TouchData::new(0, Vec2::new(100.0, 100.0));
+        touch_data.current_pos = Vec2::new(100.0 + TOUCH_EASING_DISTANCE_THRESHOLD - 0.1, 100.0);
+
+        let (_delta, distance) = update_touch_reference_position(&mut touch_data, 0.016);
+
+        assert_that(&distance).is_less_than(TOUCH_EASING_DISTANCE_THRESHOLD);
+        assert_that(&touch_data.start_pos).is_equal_to(Vec2::new(100.0, 100.0));
+    }
+
+    #[test]
+    fn easing_beyond_threshold_moves_towards_target() {
+        let mut touch_data = TouchData::new(0, Vec2::new(100.0, 100.0));
+        touch_data.current_pos = Vec2::new(150.0, 100.0);
+
+        let original_start_pos = touch_data.start_pos;
+        let (_delta, distance) = update_touch_reference_position(&mut touch_data, 0.016);
+
+        assert_that(&distance).is_greater_than(TOUCH_EASING_DISTANCE_THRESHOLD);
+        assert_that(&touch_data.start_pos.x).is_greater_than(original_start_pos.x);
+        assert_that(&touch_data.start_pos.x).is_less_than(touch_data.current_pos.x);
+    }
+
+    #[test]
+    fn easing_overshoot_sets_to_target() {
+        let mut touch_data = TouchData::new(0, Vec2::new(100.0, 100.0));
+        touch_data.current_pos = Vec2::new(101.0, 100.0);
+
+        let (_delta, _distance) = update_touch_reference_position(&mut touch_data, 10.0);
+
+        assert_that(&touch_data.start_pos).is_equal_to(touch_data.current_pos);
+    }
+
+    #[test]
+    fn easing_returns_correct_delta() {
+        let mut touch_data = TouchData::new(0, Vec2::new(100.0, 100.0));
+        touch_data.current_pos = Vec2::new(120.0, 110.0);
+
+        let (delta, distance) = update_touch_reference_position(&mut touch_data, 0.016);
+
+        let expected_delta = Vec2::new(20.0, 10.0);
+        let expected_distance = expected_delta.length();
+
+        assert_that(&delta).is_equal_to(expected_delta);
+        assert_that(&distance).is_equal_to(expected_distance);
+    }
+}
+
+// Integration tests for the full input system
+mod integration_tests {
+    use super::*;
+
+    fn mouse_motion_event(x: i32, y: i32) -> sdl2::event::Event {
+        sdl2::event::Event::MouseMotion {
+            x,
+            y,
+            xrel: 0,
+            yrel: 0,
+            mousestate: sdl2::mouse::MouseState::from_sdl_state(0),
+            which: 0,
+            window_id: 0,
+            timestamp: 0,
+        }
+    }
+
+    fn mouse_button_down_event(x: i32, y: i32) -> sdl2::event::Event {
+        sdl2::event::Event::MouseButtonDown {
+            x,
+            y,
+            mouse_btn: sdl2::mouse::MouseButton::Left,
+            clicks: 1,
+            which: 0,
+            window_id: 0,
+            timestamp: 0,
+        }
+    }
+
+    fn mouse_button_up_event(x: i32, y: i32) -> sdl2::event::Event {
+        sdl2::event::Event::MouseButtonUp {
+            x,
+            y,
+            mouse_btn: sdl2::mouse::MouseButton::Left,
+            clicks: 1,
+            which: 0,
+            window_id: 0,
+            timestamp: 0,
+        }
+    }
+
+    // Simplified helper for testing SDL integration
+    fn run_input_system_with_events(events: Vec<sdl2::event::Event>, delta_time: f32) -> (CursorPosition, TouchState) {
+        use bevy_ecs::{event::Events, system::RunSystemOnce, world::World};
+        use pacman::systems::components::DeltaTime;
+        use pacman::systems::input::input_system;
+
+        let sdl_context = sdl2::init().expect("Failed to initialize SDL");
+        let event_subsystem = sdl_context.event().expect("Failed to get event subsystem");
+        let event_pump = sdl_context.event_pump().expect("Failed to create event pump");
+
+        let mut world = World::new();
+        world.insert_resource(Events::<GameEvent>::default());
+        world.insert_resource(DeltaTime {
+            seconds: delta_time,
+            ticks: 1,
+        });
+        world.insert_resource(Bindings::default());
+        world.insert_resource(CursorPosition::None);
+        world.insert_resource(TouchState::default());
+        world.insert_non_send_resource(event_pump);
+
+        // Inject events into SDL's event queue
+        for event in events {
+            event_subsystem.push_event(event).expect("Failed to push event");
+        }
+
+        // Run the real input system
+        world
+            .run_system_once(input_system)
+            .expect("Input system should run successfully");
+
+        let cursor = *world.resource::<CursorPosition>();
+        let touch_state = world.resource::<TouchState>().clone();
+
+        (cursor, touch_state)
+    }
+
+    #[test]
+    fn mouse_motion_updates_cursor_position() {
+        let events = vec![mouse_motion_event(100, 200)];
+        let (cursor, _touch_state) = run_input_system_with_events(events, 0.016);
+
+        match cursor {
+            CursorPosition::Some {
+                position,
+                remaining_time,
+            } => {
+                assert_that(&position).is_equal_to(Vec2::new(100.0, 200.0));
+                assert_that(&remaining_time).is_equal_to(0.20);
+            }
+            CursorPosition::None => panic!("Expected cursor position to be set"),
+        }
+    }
+
+    #[test]
+    fn mouse_button_down_starts_touch() {
+        let events = vec![mouse_button_down_event(150, 250)];
+        let (_cursor, touch_state) = run_input_system_with_events(events, 0.016);
+
+        assert_that(&touch_state.active_touch).is_some();
+        if let Some(touch_data) = &touch_state.active_touch {
+            assert_that(&touch_data.finger_id).is_equal_to(0);
+            assert_that(&touch_data.start_pos).is_equal_to(Vec2::new(150.0, 250.0));
+        }
+    }
+
+    #[test]
+    fn mouse_button_up_ends_touch() {
+        let events = vec![mouse_button_down_event(150, 250), mouse_button_up_event(150, 250)];
+        let (_cursor, touch_state) = run_input_system_with_events(events, 0.016);
+
+        assert_that(&touch_state.active_touch).is_none();
+    }
+}
+
+// Touch direction tests
+mod touch_direction_tests {
+    use super::*;
+
+    #[test]
+    fn movement_above_threshold_emits_direction() {
+        let mut touch_data = TouchData::new(1, Vec2::new(100.0, 100.0));
+        touch_data.current_pos = Vec2::new(100.0 + TOUCH_DIRECTION_THRESHOLD + 5.0, 100.0);
+
+        let (delta, distance) = update_touch_reference_position(&mut touch_data, 0.016);
+
+        assert_that(&distance).is_greater_than_or_equal_to(TOUCH_DIRECTION_THRESHOLD);
+        let direction = calculate_direction_from_delta(delta);
+        assert_that(&direction).is_equal_to(Direction::Right);
+    }
+
+    #[test]
+    fn movement_below_threshold_no_direction() {
+        let mut touch_data = TouchData::new(1, Vec2::new(100.0, 100.0));
+        touch_data.current_pos = Vec2::new(100.0 + TOUCH_DIRECTION_THRESHOLD - 1.0, 100.0);
+
+        let (_delta, distance) = update_touch_reference_position(&mut touch_data, 0.016);
+
+        assert_that(&distance).is_less_than(TOUCH_DIRECTION_THRESHOLD);
+    }
+
+    #[test]
+    fn all_directions_work_correctly() {
+        let test_cases = vec![
+            (Vec2::new(TOUCH_DIRECTION_THRESHOLD + 5.0, 0.0), Direction::Right),
+            (Vec2::new(-TOUCH_DIRECTION_THRESHOLD - 5.0, 0.0), Direction::Left),
+            (Vec2::new(0.0, TOUCH_DIRECTION_THRESHOLD + 5.0), Direction::Down),
+            (Vec2::new(0.0, -TOUCH_DIRECTION_THRESHOLD - 5.0), Direction::Up),
+        ];
+
+        for (offset, expected_direction) in test_cases {
+            let mut touch_data = TouchData::new(1, Vec2::new(100.0, 100.0));
+            touch_data.current_pos = Vec2::new(100.0, 100.0) + offset;
+
+            let (delta, distance) = update_touch_reference_position(&mut touch_data, 0.016);
+
+            assert_that(&distance).is_greater_than_or_equal_to(TOUCH_DIRECTION_THRESHOLD);
+            let direction = calculate_direction_from_delta(delta);
+            assert_that(&direction).is_equal_to(expected_direction);
+        }
+    }
 }

tests/item.rs

@@ -1,112 +1,59 @@
-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 speculoos::prelude::*;
 
-use pacman::{
-    events::GameEvent,
-    map::builder::Map,
-    systems::{
-        is_valid_item_collision, item_system, AudioEvent, AudioState, EntityType, Ghost, GhostCollider, GhostState, ItemCollider,
-        PacmanCollider, Position, ScoreResource,
-    },
-};
+mod common;
 
 #[test]
 fn test_calculate_score_for_item() {
-    assert!(EntityType::Pellet.score_value() < EntityType::PowerPellet.score_value());
-    assert!(EntityType::Pellet.score_value().is_some());
-    assert!(EntityType::PowerPellet.score_value().is_some());
-    assert!(EntityType::Player.score_value().is_none());
-    assert!(EntityType::Ghost.score_value().is_none());
+    assert_that(&(EntityType::Pellet.score_value() < EntityType::PowerPellet.score_value())).is_true();
+    assert_that(&EntityType::Pellet.score_value().is_some()).is_true();
+    assert_that(&EntityType::PowerPellet.score_value().is_some()).is_true();
+    assert_that(&EntityType::Player.score_value().is_none()).is_true();
+    assert_that(&EntityType::Ghost.score_value().is_none()).is_true();
 }
 
 #[test]
 fn test_is_collectible_item() {
     // Collectible
-    assert!(EntityType::Pellet.is_collectible());
-    assert!(EntityType::PowerPellet.is_collectible());
+    assert_that(&EntityType::Pellet.is_collectible()).is_true();
+    assert_that(&EntityType::PowerPellet.is_collectible()).is_true();
 
     // Non-collectible
-    assert!(!EntityType::Player.is_collectible());
-    assert!(!EntityType::Ghost.is_collectible());
+    assert_that(&EntityType::Player.is_collectible()).is_false();
+    assert_that(&EntityType::Ghost.is_collectible()).is_false();
 }
 
 #[test]
 fn test_is_valid_item_collision() {
     // Player-item collisions should be valid
-    assert!(is_valid_item_collision(EntityType::Player, EntityType::Pellet));
-    assert!(is_valid_item_collision(EntityType::Player, EntityType::PowerPellet));
-    assert!(is_valid_item_collision(EntityType::Pellet, EntityType::Player));
-    assert!(is_valid_item_collision(EntityType::PowerPellet, EntityType::Player));
+    assert_that(&is_valid_item_collision(EntityType::Player, EntityType::Pellet)).is_true();
+    assert_that(&is_valid_item_collision(EntityType::Player, EntityType::PowerPellet)).is_true();
+    assert_that(&is_valid_item_collision(EntityType::Pellet, EntityType::Player)).is_true();
+    assert_that(&is_valid_item_collision(EntityType::PowerPellet, EntityType::Player)).is_true();
 
     // Non-player-item collisions should be invalid
-    assert!(!is_valid_item_collision(EntityType::Player, EntityType::Ghost));
-    assert!(!is_valid_item_collision(EntityType::Ghost, EntityType::Pellet));
-    assert!(!is_valid_item_collision(EntityType::Pellet, EntityType::PowerPellet));
-    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));
+    assert_that(&is_valid_item_collision(EntityType::Player, EntityType::Ghost)).is_false();
+    assert_that(&is_valid_item_collision(EntityType::Ghost, EntityType::Pellet)).is_false();
+    assert_that(&is_valid_item_collision(EntityType::Pellet, EntityType::PowerPellet)).is_false();
+    assert_that(&is_valid_item_collision(EntityType::Player, EntityType::Player)).is_false();
 }
 
 #[test]
 fn test_item_system_pellet_collection() {
-    let mut world = create_test_world();
-    let pacman = spawn_test_pacman(&mut world);
-    let pellet = spawn_test_item(&mut world, EntityType::Pellet);
+    let mut world = common::create_test_world();
+    let pacman = common::spawn_test_pacman(&mut world, 0);
+    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");
 
     // Check that score was updated
     let score = world.resource::<ScoreResource>();
-    assert_eq!(score.0, 10);
+    assert_that(&score.0).is_equal_to(10);
 
     // Check that the pellet was despawned (query should return empty)
     let item_count = world
@@ -114,22 +61,22 @@ fn test_item_system_pellet_collection() {
         .iter(&world)
         .filter(|&entity_type| matches!(entity_type, EntityType::Pellet))
         .count();
-    assert_eq!(item_count, 0);
+    assert_that(&item_count).is_equal_to(0);
 }
 
 #[test]
 fn test_item_system_power_pellet_collection() {
-    let mut world = create_test_world();
-    let pacman = spawn_test_pacman(&mut world);
-    let power_pellet = spawn_test_item(&mut world, EntityType::PowerPellet);
+    let mut world = common::create_test_world();
+    let pacman = common::spawn_test_pacman(&mut world, 0);
+    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");
 
     // Check that score was updated with power pellet value
     let score = world.resource::<ScoreResource>();
-    assert_eq!(score.0, 50);
+    assert_that(&score.0).is_equal_to(50);
 
     // Check that the power pellet was despawned (query should return empty)
     let item_count = world
@@ -137,27 +84,27 @@ fn test_item_system_power_pellet_collection() {
         .iter(&world)
         .filter(|&entity_type| matches!(entity_type, EntityType::PowerPellet))
         .count();
-    assert_eq!(item_count, 0);
+    assert_that(&item_count).is_equal_to(0);
 }
 
 #[test]
 fn test_item_system_multiple_collections() {
-    let mut world = create_test_world();
-    let pacman = spawn_test_pacman(&mut world);
-    let pellet1 = spawn_test_item(&mut world, EntityType::Pellet);
-    let pellet2 = spawn_test_item(&mut world, EntityType::Pellet);
-    let power_pellet = spawn_test_item(&mut world, EntityType::PowerPellet);
+    let mut world = common::create_test_world();
+    let pacman = common::spawn_test_pacman(&mut world, 0);
+    let pellet1 = common::spawn_test_item(&mut world, 1, EntityType::Pellet);
+    let pellet2 = common::spawn_test_item(&mut world, 2, EntityType::Pellet);
+    let power_pellet = common::spawn_test_item(&mut world, 3, EntityType::PowerPellet);
 
     // Send multiple collision events
-    send_collision_event(&mut world, pacman, pellet1);
-    send_collision_event(&mut world, pacman, pellet2);
-    send_collision_event(&mut world, pacman, power_pellet);
+    common::send_collision_event(&mut world, pacman, pellet1);
+    common::send_collision_event(&mut world, pacman, pellet2);
+    common::send_collision_event(&mut world, pacman, power_pellet);
 
     world.run_system_once(item_system).expect("System should run successfully");
 
     // Check final score: 2 pellets (20) + 1 power pellet (50) = 70
     let score = world.resource::<ScoreResource>();
-    assert_eq!(score.0, 70);
+    assert_that(&score.0).is_equal_to(70);
 
     // Check that all items were despawned
     let pellet_count = world
@@ -170,14 +117,14 @@ fn test_item_system_multiple_collections() {
         .iter(&world)
         .filter(|&entity_type| matches!(entity_type, EntityType::PowerPellet))
         .count();
-    assert_eq!(pellet_count, 0);
-    assert_eq!(power_pellet_count, 0);
+    assert_that(&pellet_count).is_equal_to(0);
+    assert_that(&power_pellet_count).is_equal_to(0);
 }
 
 #[test]
 fn test_item_system_ignores_non_item_collisions() {
-    let mut world = create_test_world();
-    let pacman = spawn_test_pacman(&mut world);
+    let mut world = common::create_test_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,13 +133,13 @@ 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");
 
     // Score should remain unchanged
     let score = world.resource::<ScoreResource>();
-    assert_eq!(score.0, initial_score);
+    assert_that(&score.0).is_equal_to(initial_score);
 
     // Ghost should still exist (not despawned)
     let ghost_count = world
@@ -200,14 +147,14 @@ fn test_item_system_ignores_non_item_collisions() {
         .iter(&world)
         .filter(|&entity_type| matches!(entity_type, EntityType::Ghost))
         .count();
-    assert_eq!(ghost_count, 1);
+    assert_that(&ghost_count).is_equal_to(1);
 }
 
 #[test]
 fn test_item_system_no_collision_events() {
-    let mut world = create_test_world();
-    let _pacman = spawn_test_pacman(&mut world);
-    let _pellet = spawn_test_item(&mut world, EntityType::Pellet);
+    let mut world = common::create_test_world();
+    let _pacman = common::spawn_test_pacman(&mut world, 0);
+    let _pellet = common::spawn_test_item(&mut world, 1, EntityType::Pellet);
 
     let initial_score = world.resource::<ScoreResource>().0;
 
@@ -216,24 +163,24 @@ fn test_item_system_no_collision_events() {
 
     // Nothing should change
     let score = world.resource::<ScoreResource>();
-    assert_eq!(score.0, initial_score);
+    assert_that(&score.0).is_equal_to(initial_score);
     let pellet_count = world
         .query::<&EntityType>()
         .iter(&world)
         .filter(|&entity_type| matches!(entity_type, EntityType::Pellet))
         .count();
-    assert_eq!(pellet_count, 1);
+    assert_that(&pellet_count).is_equal_to(1);
 }
 
 #[test]
 fn test_item_system_collision_with_missing_entity() {
-    let mut world = create_test_world();
-    let pacman = spawn_test_pacman(&mut world);
+    let mut world = common::create_test_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
@@ -242,47 +189,47 @@ fn test_item_system_collision_with_missing_entity() {
 
     // Score should remain unchanged
     let score = world.resource::<ScoreResource>();
-    assert_eq!(score.0, 0);
+    assert_that(&score.0).is_equal_to(0);
 }
 
 #[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 pellet = spawn_test_item(&mut world, EntityType::Pellet);
+    let pacman = common::spawn_test_pacman(&mut world, 0);
+    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");
 
     // Score should be initial + pellet value
     let score = world.resource::<ScoreResource>();
-    assert_eq!(score.0, 110);
+    assert_that(&score.0).is_equal_to(110);
 }
 
 #[test]
 fn test_power_pellet_does_not_affect_ghosts_in_eyes_state() {
-    let mut world = create_test_world();
-    let pacman = spawn_test_pacman(&mut world);
-    let power_pellet = spawn_test_item(&mut world, EntityType::PowerPellet);
+    let mut world = common::create_test_world();
+    let pacman = common::spawn_test_pacman(&mut world, 0);
+    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");
 
     // Check that the power pellet was collected and score updated
     let score = world.resource::<ScoreResource>();
-    assert_eq!(score.0, 50);
+    assert_that(&score.0).is_equal_to(50);
 
     // Check that the power pellet was despawned
     let power_pellet_count = world
@@ -290,13 +237,13 @@ fn test_power_pellet_does_not_affect_ghosts_in_eyes_state() {
         .iter(&world)
         .filter(|&entity_type| matches!(entity_type, EntityType::PowerPellet))
         .count();
-    assert_eq!(power_pellet_count, 0);
+    assert_that(&power_pellet_count).is_equal_to(0);
 
     // Check that the Eyes ghost state was not changed
     let eyes_ghost_state = world.entity(eyes_ghost).get::<GhostState>().unwrap();
-    assert!(matches!(*eyes_ghost_state, GhostState::Eyes));
+    assert_that(&matches!(*eyes_ghost_state, GhostState::Eyes)).is_true();
 
     // Check that the Normal ghost state was changed to Frightened
     let normal_ghost_state = world.entity(normal_ghost).get::<GhostState>().unwrap();
-    assert!(matches!(*normal_ghost_state, GhostState::Frightened { .. }));
+    assert_that(&matches!(*normal_ghost_state, GhostState::Frightened { .. })).is_true();
 }

tests/map_builder.rs

@@ -1,13 +1,15 @@
 use glam::Vec2;
 use pacman::constants::{CELL_SIZE, RAW_BOARD};
 use pacman::map::builder::Map;
+use pacman::map::graph::TraversalFlags;
+use speculoos::prelude::*;
 
 #[test]
-fn test_map_creation() {
+fn test_map_creation_success() {
     let map = Map::new(RAW_BOARD).unwrap();
 
-    assert!(map.graph.nodes().count() > 0);
-    assert!(!map.grid_to_node.is_empty());
+    assert_that(&map.graph.nodes().count()).is_greater_than(0);
+    assert_that(&map.grid_to_node.is_empty()).is_false();
 
     // Check that some connections were made
     let mut has_connections = false;
@@ -17,11 +19,11 @@ fn test_map_creation() {
             break;
         }
     }
-    assert!(has_connections);
+    assert_that(&has_connections).is_true();
 }
 
 #[test]
-fn test_map_node_positions() {
+fn test_map_node_positions_accuracy() {
     let map = Map::new(RAW_BOARD).unwrap();
 
     for (grid_pos, &node_id) in &map.grid_to_node {
@@ -31,64 +33,57 @@ fn test_map_node_positions() {
             (grid_pos.y as i32 * CELL_SIZE as i32) as f32,
         ) + Vec2::splat(CELL_SIZE as f32 / 2.0);
 
-        assert_eq!(node.position, expected_pos);
+        assert_that(&node.position).is_equal_to(expected_pos);
     }
 }
 
-// #[test]
-// fn test_generate_items() {
-//     use pacman::texture::sprite::{AtlasMapper, MapperFrame, SpriteAtlas};
-//     use std::collections::HashMap;
+#[test]
+fn test_start_positions_are_valid() {
+    let map = Map::new(RAW_BOARD).unwrap();
+    let positions = &map.start_positions;
 
-//     let map = Map::new(RAW_BOARD).unwrap();
+    // All start positions should exist in the graph
+    assert_that(&map.graph.get_node(positions.pacman)).is_some();
+    assert_that(&map.graph.get_node(positions.blinky)).is_some();
+    assert_that(&map.graph.get_node(positions.pinky)).is_some();
+    assert_that(&map.graph.get_node(positions.inky)).is_some();
+    assert_that(&map.graph.get_node(positions.clyde)).is_some();
+}
 
-//     // 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,
-//         },
-//     );
+#[test]
+fn test_ghost_house_has_ghost_only_entrance() {
+    let map = Map::new(RAW_BOARD).unwrap();
 
-//     let mapper = AtlasMapper { frames };
-//     let texture = unsafe { std::mem::transmute::<usize, Texture<'static>>(0usize) };
-//     let atlas = SpriteAtlas::new(texture, mapper);
+    // Find the house entrance node
+    let house_entrance = map.start_positions.blinky;
 
-//     let items = map.generate_items(&atlas).unwrap();
+    // Check that there's a ghost-only connection from the house entrance
+    let mut has_ghost_only_connection = false;
+    for edge in map.graph.adjacency_list[house_entrance as usize].edges() {
+        if edge.traversal_flags == TraversalFlags::GHOST {
+            has_ghost_only_connection = true;
+            break;
+        }
+    }
+    assert_that(&has_ghost_only_connection).is_true();
+}
 
-//     // Verify we have items
-//     assert!(!items.is_empty());
+#[test]
+fn test_tunnel_connections_exist() {
+    let map = Map::new(RAW_BOARD).unwrap();
 
-//     // 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()));
-// }
+    // Find tunnel nodes by looking for nodes with zero-distance connections
+    let mut has_tunnel_connection = false;
+    for intersection in &map.graph.adjacency_list {
+        for edge in intersection.edges() {
+            if edge.distance == 0.0f32 {
+                has_tunnel_connection = true;
+                break;
+            }
+        }
+        if has_tunnel_connection {
+            break;
+        }
+    }
+    assert_that(&has_tunnel_connection).is_true();
+}

tests/movement.rs

@@ -1,28 +1,9 @@
 use glam::Vec2;
 use pacman::map::direction::Direction;
-use pacman::map::graph::{Graph, Node};
 use pacman::systems::movement::{BufferedDirection, Position, Velocity};
+use speculoos::prelude::*;
 
-fn create_test_graph() -> Graph {
-    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
-}
+mod common;
 
 #[test]
 fn test_position_is_at_node() {
@@ -33,8 +14,8 @@ fn test_position_is_at_node() {
         remaining_distance: 8.0,
     };
 
-    assert!(stopped_pos.is_at_node());
-    assert!(!moving_pos.is_at_node());
+    assert_that(&stopped_pos.is_at_node()).is_true();
+    assert_that(&moving_pos.is_at_node()).is_false();
 }
 
 #[test]
@@ -46,8 +27,8 @@ fn test_position_current_node() {
         remaining_distance: 12.0,
     };
 
-    assert_eq!(stopped_pos.current_node(), 5);
-    assert_eq!(moving_pos.current_node(), 3);
+    assert_that(&stopped_pos.current_node()).is_equal_to(5);
+    assert_that(&moving_pos.current_node()).is_equal_to(3);
 }
 
 #[test]
@@ -55,8 +36,8 @@ fn test_position_tick_no_movement_when_stopped() {
     let mut pos = Position::Stopped { node: 0 };
     let result = pos.tick(5.0);
 
-    assert!(result.is_none());
-    assert_eq!(pos, Position::Stopped { node: 0 });
+    assert_that(&result.is_none()).is_true();
+    assert_that(&pos).is_equal_to(Position::Stopped { node: 0 });
 }
 
 #[test]
@@ -68,15 +49,12 @@ fn test_position_tick_no_movement_when_zero_distance() {
     };
     let result = pos.tick(0.0);
 
-    assert!(result.is_none());
-    assert_eq!(
-        pos,
-        Position::Moving {
-            from: 0,
-            to: 1,
-            remaining_distance: 10.0,
-        }
-    );
+    assert_that(&result.is_none()).is_true();
+    assert_that(&pos).is_equal_to(Position::Moving {
+        from: 0,
+        to: 1,
+        remaining_distance: 10.0,
+    });
 }
 
 #[test]
@@ -88,15 +66,12 @@ fn test_position_tick_partial_movement() {
     };
     let result = pos.tick(3.0);
 
-    assert!(result.is_none());
-    assert_eq!(
-        pos,
-        Position::Moving {
-            from: 0,
-            to: 1,
-            remaining_distance: 7.0,
-        }
-    );
+    assert_that(&result.is_none()).is_true();
+    assert_that(&pos).is_equal_to(Position::Moving {
+        from: 0,
+        to: 1,
+        remaining_distance: 7.0,
+    });
 }
 
 #[test]
@@ -108,8 +83,8 @@ fn test_position_tick_exact_arrival() {
     };
     let result = pos.tick(5.0);
 
-    assert!(result.is_none());
-    assert_eq!(pos, Position::Stopped { node: 1 });
+    assert_that(&result.is_none()).is_true();
+    assert_that(&pos).is_equal_to(Position::Stopped { node: 1 });
 }
 
 #[test]
@@ -121,13 +96,13 @@ fn test_position_tick_overshoot_with_overflow() {
     };
     let result = pos.tick(8.0);
 
-    assert_eq!(result, Some(5.0));
-    assert_eq!(pos, Position::Stopped { node: 1 });
+    assert_that(&result).is_equal_to(Some(5.0));
+    assert_that(&pos).is_equal_to(Position::Stopped { node: 1 });
 }
 
 #[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();
@@ -136,12 +111,12 @@ fn test_position_get_pixel_position_stopped() {
         0.0 + pacman::constants::BOARD_PIXEL_OFFSET.y as f32,
     );
 
-    assert_eq!(pixel_pos, expected);
+    assert_that(&pixel_pos).is_equal_to(expected);
 }
 
 #[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,
@@ -155,7 +130,7 @@ fn test_position_get_pixel_position_moving() {
         0.0 + pacman::constants::BOARD_PIXEL_OFFSET.y as f32,
     );
 
-    assert_eq!(pixel_pos, expected);
+    assert_that(&pixel_pos).is_equal_to(expected);
 }
 
 #[test]
@@ -165,14 +140,14 @@ fn test_velocity_basic_properties() {
         direction: Direction::Up,
     };
 
-    assert_eq!(velocity.speed, 2.5);
-    assert_eq!(velocity.direction, Direction::Up);
+    assert_that(&velocity.speed).is_equal_to(2.5);
+    assert_that(&velocity.direction).is_equal_to(Direction::Up);
 }
 
 #[test]
 fn test_buffered_direction_none() {
     let buffered = BufferedDirection::None;
-    assert_eq!(buffered, BufferedDirection::None);
+    assert_that(&buffered).is_equal_to(BufferedDirection::None);
 }
 
 #[test]
@@ -187,8 +162,8 @@ fn test_buffered_direction_some() {
         remaining_time,
     } = buffered
     {
-        assert_eq!(direction, Direction::Left);
-        assert_eq!(remaining_time, 0.5);
+        assert_that(&direction).is_equal_to(Direction::Left);
+        assert_that(&remaining_time).is_equal_to(0.5);
     } else {
         panic!("Expected BufferedDirection::Some");
     }

tests/parser.rs

@@ -1,6 +1,7 @@
 use pacman::constants::{BOARD_CELL_SIZE, RAW_BOARD};
 use pacman::error::ParseError;
 use pacman::map::parser::MapTileParser;
+use speculoos::prelude::*;
 
 #[test]
 fn test_parse_character() {
@@ -15,25 +16,25 @@ fn test_parse_character() {
     ];
 
     for (char, _expected) in test_cases {
-        assert!(matches!(MapTileParser::parse_character(char).unwrap(), _expected));
+        assert_that(&matches!(MapTileParser::parse_character(char).unwrap(), _expected)).is_true();
     }
 
-    assert!(MapTileParser::parse_character('Z').is_err());
+    assert_that(&MapTileParser::parse_character('Z').is_err()).is_true();
 }
 
 #[test]
 fn test_parse_board() {
     let result = MapTileParser::parse_board(RAW_BOARD);
-    assert!(result.is_ok());
+    assert_that(&result.is_ok()).is_true();
 
     let parsed = result.unwrap();
-    assert_eq!(parsed.tiles.len(), BOARD_CELL_SIZE.x as usize);
-    assert_eq!(parsed.tiles[0].len(), BOARD_CELL_SIZE.y as usize);
-    assert!(parsed.house_door[0].is_some());
-    assert!(parsed.house_door[1].is_some());
-    assert!(parsed.tunnel_ends[0].is_some());
-    assert!(parsed.tunnel_ends[1].is_some());
-    assert!(parsed.pacman_start.is_some());
+    assert_that(&parsed.tiles.len()).is_equal_to(BOARD_CELL_SIZE.x as usize);
+    assert_that(&parsed.tiles[0].len()).is_equal_to(BOARD_CELL_SIZE.y as usize);
+    assert_that(&parsed.house_door[0].is_some()).is_true();
+    assert_that(&parsed.house_door[1].is_some()).is_true();
+    assert_that(&parsed.tunnel_ends[0].is_some()).is_true();
+    assert_that(&parsed.tunnel_ends[1].is_some()).is_true();
+    assert_that(&parsed.pacman_start.is_some()).is_true();
 }
 
 #[test]
@@ -42,6 +43,6 @@ fn test_parse_board_invalid_character() {
     invalid_board[0] = "###########################Z".to_string();
 
     let result = MapTileParser::parse_board(invalid_board.each_ref().map(|s| s.as_str()));
-    assert!(result.is_err());
-    assert!(matches!(result.unwrap_err(), ParseError::UnknownCharacter('Z')));
+    assert_that(&result.is_err()).is_true();
+    assert_that(&matches!(result.unwrap_err(), ParseError::UnknownCharacter('Z'))).is_true();
 }

tests/player.rs

@@ -1,63 +1,18 @@
-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,
     },
 };
+use speculoos::prelude::*;
 
-// Test helper functions for ECS setup
-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));
-}
+mod common;
 
 #[test]
 fn test_can_traverse_player_on_all_edges() {
@@ -68,7 +23,7 @@ fn test_can_traverse_player_on_all_edges() {
         traversal_flags: TraversalFlags::ALL,
     };
 
-    assert!(can_traverse(EntityType::Player, edge));
+    assert_that(&can_traverse(EntityType::Player, edge)).is_true();
 }
 
 #[test]
@@ -80,7 +35,7 @@ fn test_can_traverse_player_on_pacman_only_edges() {
         traversal_flags: TraversalFlags::PACMAN,
     };
 
-    assert!(can_traverse(EntityType::Player, edge));
+    assert_that(&can_traverse(EntityType::Player, edge)).is_true();
 }
 
 #[test]
@@ -92,7 +47,7 @@ fn test_can_traverse_player_blocked_on_ghost_only_edges() {
         traversal_flags: TraversalFlags::GHOST,
     };
 
-    assert!(!can_traverse(EntityType::Player, edge));
+    assert_that(&can_traverse(EntityType::Player, edge)).is_false();
 }
 
 #[test]
@@ -104,7 +59,7 @@ fn test_can_traverse_ghost_on_all_edges() {
         traversal_flags: TraversalFlags::ALL,
     };
 
-    assert!(can_traverse(EntityType::Ghost, edge));
+    assert_that(&can_traverse(EntityType::Ghost, edge)).is_true();
 }
 
 #[test]
@@ -116,7 +71,7 @@ fn test_can_traverse_ghost_on_ghost_only_edges() {
         traversal_flags: TraversalFlags::GHOST,
     };
 
-    assert!(can_traverse(EntityType::Ghost, edge));
+    assert_that(&can_traverse(EntityType::Ghost, edge)).is_true();
 }
 
 #[test]
@@ -128,7 +83,7 @@ fn test_can_traverse_ghost_blocked_on_pacman_only_edges() {
         traversal_flags: TraversalFlags::PACMAN,
     };
 
-    assert!(!can_traverse(EntityType::Ghost, edge));
+    assert_that(&can_traverse(EntityType::Ghost, edge)).is_false();
 }
 
 #[test]
@@ -143,29 +98,25 @@ fn test_can_traverse_static_entities_flags() {
     // Static entities have empty traversal flags but can still "traverse"
     // in the sense that empty flags are contained in any flag set
     // This is the expected behavior since empty ⊆ any set
-    assert!(can_traverse(EntityType::Pellet, edge));
-    assert!(can_traverse(EntityType::PowerPellet, edge));
+    assert_that(&can_traverse(EntityType::Pellet, edge)).is_true();
+    assert_that(&can_traverse(EntityType::PowerPellet, edge)).is_true();
 }
 
 #[test]
 fn test_entity_type_traversal_flags() {
-    assert_eq!(EntityType::Player.traversal_flags(), TraversalFlags::PACMAN);
-    assert_eq!(EntityType::Ghost.traversal_flags(), TraversalFlags::GHOST);
-    assert_eq!(EntityType::Pellet.traversal_flags(), TraversalFlags::empty());
-    assert_eq!(EntityType::PowerPellet.traversal_flags(), TraversalFlags::empty());
+    assert_that(&EntityType::Player.traversal_flags()).is_equal_to(TraversalFlags::PACMAN);
+    assert_that(&EntityType::Ghost.traversal_flags()).is_equal_to(TraversalFlags::GHOST);
+    assert_that(&EntityType::Pellet.traversal_flags()).is_equal_to(TraversalFlags::empty());
+    assert_that(&EntityType::PowerPellet.traversal_flags()).is_equal_to(TraversalFlags::empty());
 }
 
-// ============================================================================
-// ECS System Tests
-// ============================================================================
-
 #[test]
 fn test_player_control_system_move_command() {
-    let mut world = create_test_world();
-    let _player = spawn_test_player(&mut world);
+    let mut world = common::create_test_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
@@ -181,8 +132,8 @@ fn test_player_control_system_move_command() {
             direction,
             remaining_time,
         } => {
-            assert_eq!(direction, Direction::Up);
-            assert_eq!(remaining_time, 0.25);
+            assert_that(&direction).is_equal_to(Direction::Up);
+            assert_that(&remaining_time).is_equal_to(0.25);
         }
         BufferedDirection::None => panic!("Expected buffered direction to be set"),
     }
@@ -190,11 +141,11 @@ fn test_player_control_system_move_command() {
 
 #[test]
 fn test_player_control_system_exit_command() {
-    let mut world = create_test_world();
-    let _player = spawn_test_player(&mut world);
+    let mut world = common::create_test_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
@@ -203,16 +154,16 @@ fn test_player_control_system_exit_command() {
 
     // Check that exit flag was set
     let state = world.resource::<GlobalState>();
-    assert!(state.exit);
+    assert_that(&state.exit).is_true();
 }
 
 #[test]
 fn test_player_control_system_toggle_debug() {
-    let mut world = create_test_world();
-    let _player = spawn_test_player(&mut world);
+    let mut world = common::create_test_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
@@ -221,16 +172,16 @@ fn test_player_control_system_toggle_debug() {
 
     // Check that debug state changed
     let debug_state = world.resource::<DebugState>();
-    assert!(debug_state.enabled);
+    assert_that(&debug_state.enabled).is_true();
 }
 
 #[test]
 fn test_player_control_system_mute_audio() {
-    let mut world = create_test_world();
-    let _player = spawn_test_player(&mut world);
+    let mut world = common::create_test_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
@@ -239,26 +190,26 @@ fn test_player_control_system_mute_audio() {
 
     // Check that audio was muted
     let audio_state = world.resource::<AudioState>();
-    assert!(audio_state.muted);
+    assert_that(&audio_state.muted).is_true();
 
     // 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");
 
     // Check that audio was unmuted
     let audio_state = world.resource::<AudioState>();
-    assert!(!audio_state.muted, "Audio should be unmuted after second toggle");
+    assert_that(&audio_state.muted).is_false();
 }
 
 #[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 +223,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 player = spawn_test_player(&mut world);
+    let mut world = common::create_test_world();
+    let player = common::spawn_test_player(&mut world, 0);
 
     // Set a buffered direction with short time
     world.entity_mut(player).insert(BufferedDirection::Some {
@@ -282,7 +233,7 @@ fn test_player_movement_system_buffered_direction_expires() {
     });
 
     // Set delta time to expire the buffered direction
-    world.insert_resource(DeltaTime(0.02));
+    world.insert_resource(DeltaTime::from_seconds(0.02));
 
     // Run the system
     world
@@ -295,18 +246,15 @@ fn test_player_movement_system_buffered_direction_expires() {
     match *buffered_direction {
         BufferedDirection::None => {} // Expected - fully expired
         BufferedDirection::Some { remaining_time, .. } => {
-            assert!(
-                remaining_time <= 0.0,
-                "Buffered direction should be expired or have non-positive time"
-            );
+            assert_that(&(remaining_time <= 0.0)).is_true();
         }
     }
 }
 
 #[test]
 fn test_player_movement_system_start_moving_from_stopped() {
-    let mut world = create_test_world();
-    let _player = spawn_test_player(&mut world);
+    let mut world = common::create_test_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
@@ -321,7 +269,7 @@ fn test_player_movement_system_start_moving_from_stopped() {
 
     match *position {
         Position::Moving { from, .. } => {
-            assert_eq!(from, 0, "Player should start from node 0");
+            assert_that(&from).is_equal_to(0);
             // Don't assert exact target node since the real map has different connectivity
         }
         Position::Stopped { .. } => {} // May stay stopped if no valid edge in current direction
@@ -330,8 +278,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 player = spawn_test_player(&mut world);
+    let mut world = common::create_test_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 {
@@ -349,8 +297,8 @@ fn test_player_movement_system_buffered_direction_change() {
 
     match *position {
         Position::Moving { from, to, .. } => {
-            assert_eq!(from, 0);
-            assert_eq!(to, 2); // Should be moving to node 2 (down)
+            assert_that(&from).is_equal_to(0);
+            assert_that(&to).is_equal_to(2); // Should be moving to node 2 (down)
         }
         Position::Stopped { .. } => panic!("Player should have started moving"),
     }
@@ -361,8 +309,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 player = spawn_test_player(&mut world);
+    let mut world = common::create_test_world();
+    let player = common::spawn_test_player(&mut world, 0);
 
     // Set velocity to direction with no edge
     world.entity_mut(player).insert(Velocity {
@@ -379,15 +327,15 @@ fn test_player_movement_system_no_valid_edge() {
     let position = query.single(&world).expect("Player should exist");
 
     match *position {
-        Position::Stopped { node } => assert_eq!(node, 0),
+        Position::Stopped { node } => assert_that(&node).is_equal_to(0),
         Position::Moving { .. } => panic!("Player shouldn't be able to move without valid edge"),
     }
 }
 
 #[test]
 fn test_player_movement_system_continue_moving() {
-    let mut world = create_test_world();
-    let player = spawn_test_player(&mut world);
+    let mut world = common::create_test_world();
+    let player = common::spawn_test_player(&mut world, 0);
 
     // Set player to already be moving
     world.entity_mut(player).insert(Position::Moving {
@@ -406,7 +354,7 @@ fn test_player_movement_system_continue_moving() {
 
     match *position {
         Position::Moving { remaining_distance, .. } => {
-            assert!(remaining_distance < 50.0); // Should have moved
+            assert_that(&(remaining_distance < 50.0)).is_true(); // Should have moved
         }
         Position::Stopped { .. } => {
             // If player reached destination, that's also valid
@@ -414,17 +362,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 _player = spawn_test_player(&mut world);
+    let mut world = common::create_test_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
@@ -442,8 +386,8 @@ fn test_full_player_input_to_movement_flow() {
 
     match *position {
         Position::Moving { from, to, .. } => {
-            assert_eq!(from, 0);
-            assert_eq!(to, 2); // Moving to node 2 (down)
+            assert_that(&from).is_equal_to(0);
+            assert_that(&to).is_equal_to(2); // Moving to node 2 (down)
         }
         Position::Stopped { .. } => panic!("Player should be moving"),
     }
@@ -454,17 +398,17 @@ fn test_full_player_input_to_movement_flow() {
 
 #[test]
 fn test_buffered_direction_timing() {
-    let mut world = create_test_world();
-    let _player = spawn_test_player(&mut world);
+    let mut world = common::create_test_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");
 
     // Run movement system multiple times with small delta times
-    world.insert_resource(DeltaTime(0.1)); // 0.1 seconds
+    world.insert_resource(DeltaTime::from_seconds(0.1)); // 0.1 seconds
 
     // First run - buffered direction should still be active
     world
@@ -475,39 +419,39 @@ fn test_buffered_direction_timing() {
 
     match *buffered_direction {
         BufferedDirection::Some { remaining_time, .. } => {
-            assert!(remaining_time > 0.0);
-            assert!(remaining_time < 0.25);
+            assert_that(&(remaining_time > 0.0)).is_true();
+            assert_that(&(remaining_time < 0.25)).is_true();
         }
         BufferedDirection::None => panic!("Buffered direction should still be active"),
     }
 
     // Run again to fully expire the buffered direction
-    world.insert_resource(DeltaTime(0.2)); // Total 0.3 seconds, should expire
+    world.insert_resource(DeltaTime::from_seconds(0.2)); // Total 0.3 seconds, should expire
     world
         .run_system_once(player_movement_system)
         .expect("System should run successfully");
 
     let buffered_direction = query.single(&world).expect("Player should exist");
-    assert_eq!(*buffered_direction, BufferedDirection::None);
+    assert_that(buffered_direction).is_equal_to(BufferedDirection::None);
 }
 
 #[test]
 fn test_multiple_rapid_direction_changes() {
-    let mut world = create_test_world();
-    let _player = spawn_test_player(&mut world);
+    let mut world = common::create_test_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");
@@ -518,7 +462,7 @@ fn test_multiple_rapid_direction_changes() {
 
     match *buffered_direction {
         BufferedDirection::Some { direction, .. } => {
-            assert_eq!(direction, Direction::Left);
+            assert_that(&direction).is_equal_to(Direction::Left);
         }
         BufferedDirection::None => panic!("Expected buffered direction"),
     }
@@ -526,15 +470,15 @@ fn test_multiple_rapid_direction_changes() {
 
 #[test]
 fn test_player_state_persistence_across_systems() {
-    let mut world = create_test_world();
-    let _player = spawn_test_player(&mut world);
+    let mut world = common::create_test_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 +486,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 +494,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");
@@ -564,8 +508,8 @@ fn test_player_state_persistence_across_systems() {
     let position = *query.single(&world).expect("Player should exist");
 
     // Check that the state changes persisted individually
-    assert!(debug_state_after_toggle.enabled, "Debug state should have toggled");
-    assert!(audio_muted_after_toggle, "Audio should be muted");
+    assert_that(&debug_state_after_toggle.enabled).is_true();
+    assert_that(&audio_muted_after_toggle).is_true();
 
     // Player position depends on actual map connectivity
     match position {

tests/profiling.rs

@@ -1,4 +1,5 @@
 use pacman::systems::profiling::{SystemId, SystemTimings};
+use speculoos::prelude::*;
 use std::time::Duration;
 use strum::IntoEnumIterator;
 
@@ -6,15 +7,7 @@ macro_rules! assert_close {
     ($actual:expr, $expected:expr, $concern:expr) => {
         let tolerance = Duration::from_micros(500);
         let diff = $actual.abs_diff($expected);
-        assert!(
-            diff < tolerance,
-            "Expected {expected:?} ± {tolerance:.0?}, got {actual:?}, off by {diff:?} ({concern})",
-            concern = $concern,
-            expected = $expected,
-            actual = $actual,
-            tolerance = tolerance,
-            diff = diff
-        );
+        assert_that(&(diff < tolerance)).is_true();
     };
 }
 
@@ -22,33 +15,26 @@ macro_rules! assert_close {
 fn test_timing_statistics() {
     let timings = SystemTimings::default();
 
-    // 10ms average, 2ms std dev
-    timings.add_timing(SystemId::PlayerControls, Duration::from_millis(10));
-    timings.add_timing(SystemId::PlayerControls, Duration::from_millis(12));
-    timings.add_timing(SystemId::PlayerControls, Duration::from_millis(8));
+    // Add consecutive timing measurements (no skipped ticks to avoid zero padding)
+    timings.add_timing(SystemId::PlayerControls, Duration::from_millis(10), 1);
+    timings.add_timing(SystemId::PlayerControls, Duration::from_millis(12), 2);
+    timings.add_timing(SystemId::PlayerControls, Duration::from_millis(8), 3);
 
-    // 2ms average, 1ms std dev
-    timings.add_timing(SystemId::Blinking, Duration::from_millis(3));
-    timings.add_timing(SystemId::Blinking, Duration::from_millis(2));
-    timings.add_timing(SystemId::Blinking, Duration::from_millis(1));
+    // Add consecutive timing measurements for another system
+    timings.add_timing(SystemId::Blinking, Duration::from_millis(3), 1);
+    timings.add_timing(SystemId::Blinking, Duration::from_millis(2), 2);
+    timings.add_timing(SystemId::Blinking, Duration::from_millis(1), 3);
 
     {
-        let stats = timings.get_stats();
+        let stats = timings.get_stats(3);
         let (avg, std_dev) = stats.get(&SystemId::PlayerControls).unwrap();
 
         assert_close!(*avg, Duration::from_millis(10), "PlayerControls average timing");
         assert_close!(*std_dev, Duration::from_millis(2), "PlayerControls standard deviation timing");
     }
 
-    {
-        let (total_avg, total_std) = timings.get_total_stats();
-        assert_close!(total_avg, Duration::from_millis(2), "Total average timing across all systems");
-        assert_close!(
-            total_std,
-            Duration::from_millis(7),
-            "Total standard deviation timing across all systems"
-        );
-    }
+    // Note: get_total_stats() was removed as we now use the Total system directly
+    // This test now focuses on individual system statistics
 }
 
 #[test]
@@ -56,22 +42,22 @@ fn test_default_zero_timing_for_unused_systems() {
     let timings = SystemTimings::default();
 
     // Add timing data for only one system
-    timings.add_timing(SystemId::PlayerControls, Duration::from_millis(5));
+    timings.add_timing(SystemId::PlayerControls, Duration::from_millis(5), 1);
 
-    let stats = timings.get_stats();
+    let stats = timings.get_stats(1);
 
     // Verify all SystemId variants are present in the stats
     let expected_count = SystemId::iter().count();
-    assert_eq!(stats.len(), expected_count, "All SystemId variants should be in stats");
+    assert_that(&stats.len()).is_equal_to(expected_count);
 
     // Verify that the system with data has non-zero timing
     let (avg, std_dev) = stats.get(&SystemId::PlayerControls).unwrap();
     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,
@@ -88,23 +74,19 @@ fn test_default_zero_timing_for_unused_systems() {
 }
 
 #[test]
-fn test_pre_populated_timing_entries() {
+fn test_total_system_timing() {
     let timings = SystemTimings::default();
 
-    // Verify that we can add timing to any SystemId without panicking
-    // (this would fail with the old implementation if the entry didn't exist)
-    for id in SystemId::iter() {
-        timings.add_timing(id, Duration::from_nanos(1));
-    }
+    // Add some timing data to the Total system
+    timings.add_total_timing(Duration::from_millis(16), 1);
+    timings.add_total_timing(Duration::from_millis(18), 2);
+    timings.add_total_timing(Duration::from_millis(14), 3);
 
-    // Verify all systems now have non-zero timing
-    let stats = timings.get_stats();
-    for id in SystemId::iter() {
-        let (avg, _) = stats.get(&id).unwrap();
-        assert!(
-            *avg > Duration::ZERO,
-            "System {:?} should have non-zero timing after add_timing",
-            id
-        );
-    }
+    let stats = timings.get_stats(3);
+    let (avg, std_dev) = stats.get(&SystemId::Total).unwrap();
+
+    // Should have 16ms average (16+18+14)/3 = 16ms
+    assert_close!(*avg, Duration::from_millis(16), "Total system average timing");
+    // Should have some standard deviation
+    assert_that(&(*std_dev > Duration::ZERO)).is_true();
 }

tests/sprite.rs

@@ -1,14 +1,13 @@
 use glam::U16Vec2;
-use pacman::texture::sprite::{AtlasMapper, AtlasTile, MapperFrame, SpriteAtlas};
+use pacman::texture::sprite::{AtlasMapper, AtlasTile, MapperFrame};
 use sdl2::pixels::Color;
+use speculoos::prelude::*;
 use std::collections::HashMap;
 
-fn mock_texture() -> sdl2::render::Texture {
-    unsafe { std::mem::transmute(0usize) }
-}
+mod common;
 
 #[test]
-fn test_sprite_atlas_basic() {
+fn test_atlas_mapper_frame_lookup() {
     let mut frames = HashMap::new();
     frames.insert(
         "test".to_string(),
@@ -19,19 +18,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");
-    assert!(tile.is_some());
-    let tile = tile.unwrap();
-    assert_eq!(tile.pos, glam::U16Vec2::new(10, 20));
-    assert_eq!(tile.size, glam::U16Vec2::new(32, 64));
-    assert_eq!(tile.color, None);
+    // Test direct frame lookup
+    let frame = mapper.frames.get("test");
+    assert_that(&frame.is_some()).is_true();
+    let frame = frame.unwrap();
+    assert_that(&frame.pos).is_equal_to(U16Vec2::new(10, 20));
+    assert_that(&frame.size).is_equal_to(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 +46,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!(atlas.has_tile("tile1"));
-    assert!(atlas.has_tile("tile2"));
-    assert!(!atlas.has_tile("tile3"));
-    assert!(atlas.get_tile("nonexistent").is_none());
-}
-
-#[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));
+    assert_that(&mapper.frames.len()).is_equal_to(2);
+    assert_that(&mapper.frames.contains_key("tile1")).is_true();
+    assert_that(&mapper.frames.contains_key("tile2")).is_true();
+    assert_that(&mapper.frames.contains_key("tile3")).is_false();
+    assert_that(&mapper.frames.contains_key("nonexistent")).is_false();
 }
 
 #[test]
@@ -79,10 +61,10 @@ fn test_atlas_tile_new_and_with_color() {
     let color = Color::RGB(100, 150, 200);
 
     let tile = AtlasTile::new(pos, size, None);
-    assert_eq!(tile.pos, pos);
-    assert_eq!(tile.size, size);
-    assert_eq!(tile.color, None);
+    assert_that(&tile.pos).is_equal_to(pos);
+    assert_that(&tile.size).is_equal_to(size);
+    assert_that(&tile.color).is_equal_to(None);
 
     let tile_with_color = tile.with_color(color);
-    assert_eq!(tile_with_color.color, Some(color));
+    assert_that(&tile_with_color.color).is_equal_to(Some(color));
 }

tests/text.rs

@@ -1,9 +1,10 @@
 use pacman::texture::{sprite::SpriteAtlas, text::TextTexture};
-
-use crate::common::create_atlas;
+use speculoos::prelude::*;
 
 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();
@@ -16,22 +17,16 @@ fn get_all_chars() -> String {
 /// Helper function to check if a character is in the atlas and char_map
 fn check_char(text_texture: &mut TextTexture, atlas: &mut SpriteAtlas, c: char) {
     // Check that the character is not in the char_map yet
-    assert!(
-        !text_texture.get_char_map().contains_key(&c),
-        "Character {c} should not yet be in char_map"
-    );
+    assert_that(&text_texture.get_char_map().contains_key(&c)).is_false();
 
     // Get the tile from the atlas, which caches the tile in the char_map
     let tile = text_texture.get_tile(c, atlas);
 
-    assert!(tile.is_ok(), "Failed to get tile for character {c}");
-    assert!(tile.unwrap().is_some(), "Tile for character {c} not found in atlas");
+    assert_that(&tile.is_ok()).is_true();
+    assert_that(&tile.unwrap().is_some()).is_true();
 
     // Check that the tile is now cached in the char_map
-    assert!(
-        text_texture.get_char_map().contains_key(&c),
-        "Tile for character {c} was not cached in char_map"
-    );
+    assert_that(&text_texture.get_char_map().contains_key(&c)).is_true();
 }
 
 #[test]
@@ -74,8 +69,8 @@ fn test_text_width() -> Result<(), String> {
         let width = text_texture.text_width(&string);
         let height = text_texture.text_height();
 
-        assert!(width > 0, "Width for string {string} should be greater than 0");
-        assert!(height > 0, "Height for string {string} should be greater than 0");
+        assert_that(&(width > 0)).is_true();
+        assert_that(&(height > 0)).is_true();
     }
 
     Ok(())
@@ -88,22 +83,22 @@ fn test_text_scale() -> Result<(), String> {
 
     let mut text_texture = TextTexture::new(0.5);
 
-    assert_eq!(text_texture.scale(), 0.5);
-    assert_eq!(text_texture.text_height(), 4);
-    assert_eq!(text_texture.text_width(""), 0);
-    assert_eq!(text_texture.text_width(string), base_width / 2);
+    assert_that(&text_texture.scale()).is_equal_to(0.5);
+    assert_that(&text_texture.text_height()).is_equal_to(4);
+    assert_that(&text_texture.text_width("")).is_equal_to(0);
+    assert_that(&text_texture.text_width(string)).is_equal_to(base_width / 2);
 
     text_texture.set_scale(2.0);
-    assert_eq!(text_texture.scale(), 2.0);
-    assert_eq!(text_texture.text_height(), 16);
-    assert_eq!(text_texture.text_width(string), base_width * 2);
-    assert_eq!(text_texture.text_width(""), 0);
+    assert_that(&text_texture.scale()).is_equal_to(2.0);
+    assert_that(&text_texture.text_height()).is_equal_to(16);
+    assert_that(&text_texture.text_width(string)).is_equal_to(base_width * 2);
+    assert_that(&text_texture.text_width("")).is_equal_to(0);
 
     text_texture.set_scale(1.0);
-    assert_eq!(text_texture.scale(), 1.0);
-    assert_eq!(text_texture.text_height(), 8);
-    assert_eq!(text_texture.text_width(string), base_width);
-    assert_eq!(text_texture.text_width(""), 0);
+    assert_that(&text_texture.scale()).is_equal_to(1.0);
+    assert_that(&text_texture.text_height()).is_equal_to(8);
+    assert_that(&text_texture.text_width(string)).is_equal_to(base_width);
+    assert_that(&text_texture.text_width("")).is_equal_to(0);
 
     Ok(())
 }
@@ -113,17 +108,17 @@ fn test_text_color() -> Result<(), String> {
     let mut text_texture = TextTexture::new(1.0);
 
     // Test default color (should be None initially)
-    assert_eq!(text_texture.color(), None);
+    assert_that(&text_texture.color()).is_equal_to(None);
 
     // Test setting color
     let test_color = sdl2::pixels::Color::YELLOW;
     text_texture.set_color(test_color);
-    assert_eq!(text_texture.color(), Some(test_color));
+    assert_that(&text_texture.color()).is_equal_to(Some(test_color));
 
     // Test changing color
     let new_color = sdl2::pixels::Color::RED;
     text_texture.set_color(new_color);
-    assert_eq!(text_texture.color(), Some(new_color));
+    assert_that(&text_texture.color()).is_equal_to(Some(new_color));
 
     Ok(())
 }

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();
-}

tests/ttf.rs

@@ -0,0 +1,115 @@
+use pacman::texture::ttf::{TtfAtlas, TtfRenderer};
+use sdl2::pixels::Color;
+
+mod common;
+
+#[test]
+fn text_width_calculates_correctly_for_empty_string() {
+    let (mut canvas, texture_creator, _sdl) = common::setup_sdl().unwrap();
+    let _ttf_context = sdl2::ttf::init().unwrap();
+    let font = _ttf_context.load_font("assets/game/TerminalVector.ttf", 16).unwrap();
+
+    let mut atlas = TtfAtlas::new(&texture_creator, &font).unwrap();
+    atlas.populate_atlas(&mut canvas, &texture_creator, &font).unwrap();
+
+    let renderer = TtfRenderer::new(1.0);
+    let width = renderer.text_width(&atlas, "");
+
+    assert_eq!(width, 0);
+}
+
+#[test]
+fn text_width_calculates_correctly_for_single_character() {
+    let (mut canvas, texture_creator, _sdl) = common::setup_sdl().unwrap();
+    let _ttf_context = sdl2::ttf::init().unwrap();
+    let font = _ttf_context.load_font("assets/game/TerminalVector.ttf", 16).unwrap();
+
+    let mut atlas = TtfAtlas::new(&texture_creator, &font).unwrap();
+    atlas.populate_atlas(&mut canvas, &texture_creator, &font).unwrap();
+
+    let renderer = TtfRenderer::new(1.0);
+    let width = renderer.text_width(&atlas, "A");
+
+    assert!(width > 0);
+}
+
+#[test]
+fn text_width_scales_correctly() {
+    let (mut canvas, texture_creator, _sdl) = common::setup_sdl().unwrap();
+    let _ttf_context = sdl2::ttf::init().unwrap();
+    let font = _ttf_context.load_font("assets/game/TerminalVector.ttf", 16).unwrap();
+
+    let mut atlas = TtfAtlas::new(&texture_creator, &font).unwrap();
+    atlas.populate_atlas(&mut canvas, &texture_creator, &font).unwrap();
+
+    let renderer1 = TtfRenderer::new(1.0);
+    let renderer2 = TtfRenderer::new(2.0);
+
+    let width1 = renderer1.text_width(&atlas, "Test");
+    let width2 = renderer2.text_width(&atlas, "Test");
+
+    assert_eq!(width2, width1 * 2);
+}
+
+#[test]
+fn text_height_returns_non_zero_for_valid_atlas() {
+    let (mut canvas, texture_creator, _sdl) = common::setup_sdl().unwrap();
+    let _ttf_context = sdl2::ttf::init().unwrap();
+    let font = _ttf_context.load_font("assets/game/TerminalVector.ttf", 16).unwrap();
+
+    let mut atlas = TtfAtlas::new(&texture_creator, &font).unwrap();
+    atlas.populate_atlas(&mut canvas, &texture_creator, &font).unwrap();
+
+    let renderer = TtfRenderer::new(1.0);
+    let height = renderer.text_height(&atlas);
+
+    assert!(height > 0);
+}
+
+#[test]
+fn text_height_scales_correctly() {
+    let (mut canvas, texture_creator, _sdl) = common::setup_sdl().unwrap();
+    let _ttf_context = sdl2::ttf::init().unwrap();
+    let font = _ttf_context.load_font("assets/game/TerminalVector.ttf", 16).unwrap();
+
+    let mut atlas = TtfAtlas::new(&texture_creator, &font).unwrap();
+    atlas.populate_atlas(&mut canvas, &texture_creator, &font).unwrap();
+
+    let renderer1 = TtfRenderer::new(1.0);
+    let renderer2 = TtfRenderer::new(2.0);
+
+    let height1 = renderer1.text_height(&atlas);
+    let height2 = renderer2.text_height(&atlas);
+
+    assert_eq!(height2, height1 * 2);
+}
+
+#[test]
+fn render_text_handles_empty_string() {
+    let (mut canvas, texture_creator, _sdl) = common::setup_sdl().unwrap();
+    let _ttf_context = sdl2::ttf::init().unwrap();
+    let font = _ttf_context.load_font("assets/game/TerminalVector.ttf", 16).unwrap();
+
+    let mut atlas = TtfAtlas::new(&texture_creator, &font).unwrap();
+    atlas.populate_atlas(&mut canvas, &texture_creator, &font).unwrap();
+
+    let renderer = TtfRenderer::new(1.0);
+    let result = renderer.render_text(&mut canvas, &mut atlas, "", glam::Vec2::new(0.0, 0.0), Color::WHITE);
+
+    assert!(result.is_ok());
+}
+
+#[test]
+fn render_text_handles_single_character() {
+    let (mut canvas, texture_creator, _sdl) = common::setup_sdl().unwrap();
+    let _ttf_context = sdl2::ttf::init().unwrap();
+    let font = _ttf_context.load_font("assets/game/TerminalVector.ttf", 16).unwrap();
+
+    let mut atlas = TtfAtlas::new(&texture_creator, &font).unwrap();
+    atlas.populate_atlas(&mut canvas, &texture_creator, &font).unwrap();
+
+    let renderer = TtfRenderer::new(1.0);
+    let result = renderer.render_text(&mut canvas, &mut atlas, "A", glam::Vec2::new(10.0, 10.0), Color::RED);
+
+    assert!(result.is_ok());
+}

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)