fix: proper font loading, cross platform assets, better platform independent trait implementation, conditional modules

src/asset.rs

@@ -11,7 +11,8 @@ pub enum Asset {
     Wav2,
     Wav3,
     Wav4,
-    Atlas,
+    AtlasImage,
+    Font,
 }
 
 impl Asset {
@@ -23,7 +24,8 @@ impl Asset {
             Wav2 => "sound/waka/2.ogg",
             Wav3 => "sound/waka/3.ogg",
             Wav4 => "sound/waka/4.ogg",
-            Atlas => "atlas.png",
+            AtlasImage => "atlas.png",
+            Font => "TerminalVector.ttf",
         }
     }
 }

src/entity/graph.rs

@@ -218,11 +218,6 @@ impl Graph {
         self.nodes.get(id)
     }
 
-    /// Returns the total number of nodes in the graph.
-    pub fn node_count(&self) -> usize {
-        self.nodes.len()
-    }
-
     /// Returns an iterator over all nodes in the graph.
     pub fn nodes(&self) -> impl Iterator<Item = &Node> {
         self.nodes.iter()

src/game/mod.rs

@@ -19,7 +19,7 @@ use crate::systems::{
         AudioState, Collider, DeltaTime, DirectionalAnimated, EntityType, Ghost, GhostBundle, GhostCollider, GlobalState,
         ItemBundle, ItemCollider, PacmanCollider, PlayerBundle, PlayerControlled, RenderDirty, Renderable, ScoreResource,
     },
-    debug::{debug_render_system, DebugState, DebugTextureResource},
+    debug::{debug_render_system, DebugFontResource, DebugState, DebugTextureResource},
     ghost::ghost_movement_system,
     input::input_system,
     item::item_system,
@@ -28,17 +28,14 @@ use crate::systems::{
     render::{directional_render_system, dirty_render_system, render_system, BackbufferResource, MapTextureResource},
 };
 use crate::texture::animated::AnimatedTexture;
-use bevy_ecs::schedule::IntoScheduleConfigs;
-use bevy_ecs::system::NonSendMut;
-use bevy_ecs::{
-    event::EventRegistry,
-    observer::Trigger,
-    schedule::Schedule,
-    system::{Res, ResMut},
-    world::World,
-};
+use bevy_ecs::event::EventRegistry;
+use bevy_ecs::observer::Trigger;
+use bevy_ecs::schedule::Schedule;
+use bevy_ecs::system::{NonSendMut, Res, ResMut};
+use bevy_ecs::world::World;
 use sdl2::image::LoadTexture;
 use sdl2::render::{Canvas, ScaleMode, TextureCreator};
+use sdl2::rwops::RWops;
 use sdl2::video::{Window, WindowContext};
 use sdl2::EventPump;
 
@@ -47,7 +44,7 @@ use crate::{
     constants,
     events::GameCommand,
     map::render::MapRenderer,
-    systems::{debug::CursorPosition, input::Bindings},
+    systems::input::{Bindings, CursorPosition},
     texture::sprite::{AtlasMapper, SpriteAtlas},
 };
 
@@ -70,6 +67,7 @@ impl Game {
     ) -> GameResult<Game> {
         let mut world = World::default();
         let mut schedule = Schedule::default();
+        let ttf_context = Box::leak(Box::new(sdl2::ttf::init().map_err(|e| GameError::Sdl(e.to_string()))?));
 
         EventRegistry::register_event::<GameError>(&mut world);
         EventRegistry::register_event::<GameEvent>(&mut world);
@@ -92,11 +90,18 @@ impl Game {
             .map_err(|e| GameError::Sdl(e.to_string()))?;
         debug_texture.set_scale_mode(ScaleMode::Nearest);
 
+        let font_data = get_asset_bytes(Asset::Font)?;
+        let static_font_data: &'static [u8] = Box::leak(font_data.to_vec().into_boxed_slice());
+        let font_asset = RWops::from_bytes(static_font_data).map_err(|_| GameError::Sdl("Failed to load font".to_string()))?;
+        let debug_font = ttf_context
+            .load_font_from_rwops(font_asset, 12)
+            .map_err(|e| GameError::Sdl(e.to_string()))?;
+
         // Initialize audio system
         let audio = crate::audio::Audio::new();
 
         // Load atlas and create map texture
-        let atlas_bytes = get_asset_bytes(Asset::Atlas)?;
+        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") {
                 GameError::Texture(crate::error::TextureError::InvalidFormat(format!(
@@ -187,6 +192,7 @@ impl Game {
         world.insert_non_send_resource(BackbufferResource(backbuffer));
         world.insert_non_send_resource(MapTextureResource(map_texture));
         world.insert_non_send_resource(DebugTextureResource(debug_texture));
+        world.insert_non_send_resource(DebugFontResource(debug_font));
         world.insert_non_send_resource(AudioResource(audio));
 
         world.insert_resource(map);
@@ -207,40 +213,37 @@ impl Game {
                 }
             },
         );
-        schedule.add_systems(
-            (
-                profile(SystemId::Input, input_system),
-                profile(SystemId::PlayerControls, player_control_system),
-                profile(SystemId::PlayerMovement, player_movement_system),
-                profile(SystemId::Ghost, ghost_movement_system),
-                profile(SystemId::Collision, collision_system),
-                profile(SystemId::Item, item_system),
-                profile(SystemId::Audio, audio_system),
-                profile(SystemId::Blinking, blinking_system),
-                profile(SystemId::DirectionalRender, directional_render_system),
-                profile(SystemId::DirtyRender, dirty_render_system),
-                profile(SystemId::Render, render_system),
-                profile(SystemId::DebugRender, debug_render_system),
-                profile(
-                    SystemId::Present,
-                    |mut canvas: NonSendMut<&mut Canvas<Window>>,
-                     backbuffer: NonSendMut<BackbufferResource>,
-                     debug_state: Res<DebugState>,
-                     mut dirty: ResMut<RenderDirty>| {
-                        if dirty.0 || *debug_state != DebugState::Off {
-                            // Only copy backbuffer to main canvas if debug rendering is off
-                            // (debug rendering draws directly to main canvas)
-                            if *debug_state == DebugState::Off {
-                                canvas.copy(&backbuffer.0, None, None).unwrap();
-                            }
-                            dirty.0 = false;
-                            canvas.present();
+        schedule.add_systems((
+            profile(SystemId::Input, input_system),
+            profile(SystemId::PlayerControls, player_control_system),
+            profile(SystemId::PlayerMovement, player_movement_system),
+            profile(SystemId::Ghost, ghost_movement_system),
+            profile(SystemId::Collision, collision_system),
+            profile(SystemId::Item, item_system),
+            profile(SystemId::Audio, audio_system),
+            profile(SystemId::Blinking, blinking_system),
+            profile(SystemId::DirectionalRender, directional_render_system),
+            profile(SystemId::DirtyRender, dirty_render_system),
+            profile(SystemId::Render, render_system),
+            profile(SystemId::DebugRender, debug_render_system),
+            profile(
+                SystemId::Present,
+                |mut canvas: NonSendMut<&mut Canvas<Window>>,
+                 backbuffer: NonSendMut<BackbufferResource>,
+                 debug_state: Res<DebugState>,
+                 mut dirty: ResMut<RenderDirty>| {
+                    if dirty.0 || *debug_state != DebugState::Off {
+                        // Only copy backbuffer to main canvas if debug rendering is off
+                        // (debug rendering draws directly to main canvas)
+                        if *debug_state == DebugState::Off {
+                            canvas.copy(&backbuffer.0, None, None).unwrap();
                         }
-                    },
-                ),
-            )
-                .chain(),
-        );
+                        dirty.0 = false;
+                        canvas.present();
+                    }
+                },
+            ),
+        ));
 
         // Spawn player
         world.spawn(player);
@@ -288,7 +291,7 @@ impl Game {
         Ok(Game { world, schedule })
     }
 
-    /// Spawns all four ghosts at their starting positions with appropriate textures.
+    /// Spowns all four ghosts at their starting positions with appropriate textures.
     fn spawn_ghosts(world: &mut World) -> GameResult<()> {
         // Extract the data we need first to avoid borrow conflicts
         let ghost_start_positions = {

src/map/builder.rs

@@ -3,12 +3,9 @@ use crate::constants::{MapTile, BOARD_CELL_SIZE, CELL_SIZE};
 use crate::entity::direction::Direction;
 use crate::entity::graph::{Graph, Node, TraversalFlags};
 use crate::map::parser::MapTileParser;
-use crate::map::render::MapRenderer;
 use crate::systems::movement::NodeId;
-use crate::texture::sprite::SpriteAtlas;
 use bevy_ecs::resource::Resource;
 use glam::{IVec2, Vec2};
-use sdl2::render::{Canvas, RenderTarget};
 use std::collections::{HashMap, VecDeque};
 use tracing::debug;
 
@@ -165,20 +162,6 @@ impl Map {
         })
     }
 
-    /// Renders a debug visualization with cursor-based highlighting.
-    ///
-    /// This function provides interactive debugging by highlighting the nearest node
-    /// to the cursor, showing its ID, and highlighting its connections.
-    pub fn debug_render_with_cursor<T: RenderTarget>(
-        &self,
-        canvas: &mut Canvas<T>,
-        text_renderer: &mut crate::texture::text::TextTexture,
-        atlas: &mut SpriteAtlas,
-        cursor_pos: glam::Vec2,
-    ) -> GameResult<()> {
-        MapRenderer::debug_render_with_cursor(&self.graph, canvas, text_renderer, atlas, cursor_pos)
-    }
-
     /// Builds the house structure in the graph.
     fn build_house(
         graph: &mut Graph,

src/map/render.rs

@@ -3,14 +3,10 @@
 use crate::constants::{BOARD_CELL_OFFSET, CELL_SIZE};
 use crate::map::layout::TILE_MAP;
 use crate::texture::sprite::{AtlasTile, SpriteAtlas};
-use crate::texture::text::TextTexture;
-use glam::Vec2;
 use sdl2::pixels::Color;
-use sdl2::rect::{Point, Rect};
+use sdl2::rect::Rect;
 use sdl2::render::{Canvas, RenderTarget};
 
-use crate::error::{EntityError, GameError, GameResult};
-
 /// Handles rendering operations for the map.
 pub struct MapRenderer;
 
@@ -37,111 +33,4 @@ impl MapRenderer {
             }
         }
     }
-
-    /// Renders a debug visualization with cursor-based highlighting.
-    ///
-    /// This function provides interactive debugging by highlighting the nearest node
-    /// to the cursor, showing its ID, and highlighting its connections.
-    pub fn debug_render_with_cursor<T: RenderTarget>(
-        graph: &crate::entity::graph::Graph,
-        canvas: &mut Canvas<T>,
-        text_renderer: &mut TextTexture,
-        atlas: &mut SpriteAtlas,
-        cursor_pos: Vec2,
-    ) -> GameResult<()> {
-        // Find the nearest node to the cursor
-        let nearest_node = Self::find_nearest_node(graph, cursor_pos);
-
-        // Draw all connections in blue
-        canvas.set_draw_color(Color::RGB(0, 0, 128)); // Dark blue for regular connections
-        for i in 0..graph.node_count() {
-            let node = graph.get_node(i).ok_or(GameError::Entity(EntityError::NodeNotFound(i)))?;
-            let pos = node.position + crate::constants::BOARD_PIXEL_OFFSET.as_vec2();
-
-            for edge in graph.adjacency_list[i].edges() {
-                let end_pos = graph
-                    .get_node(edge.target)
-                    .ok_or(GameError::Entity(EntityError::NodeNotFound(edge.target)))?
-                    .position
-                    + crate::constants::BOARD_PIXEL_OFFSET.as_vec2();
-                canvas
-                    .draw_line((pos.x as i32, pos.y as i32), (end_pos.x as i32, end_pos.y as i32))
-                    .map_err(|e| GameError::Sdl(e.to_string()))?;
-            }
-        }
-
-        // Draw all nodes in green
-        canvas.set_draw_color(Color::RGB(0, 128, 0)); // Dark green for regular nodes
-        for i in 0..graph.node_count() {
-            let node = graph.get_node(i).ok_or(GameError::Entity(EntityError::NodeNotFound(i)))?;
-            let pos = node.position + crate::constants::BOARD_PIXEL_OFFSET.as_vec2();
-
-            canvas
-                .fill_rect(Rect::new(0, 0, 3, 3).centered_on(Point::new(pos.x as i32, pos.y as i32)))
-                .map_err(|e| GameError::Sdl(e.to_string()))?;
-        }
-
-        // Highlight connections from the nearest node in bright blue
-        if let Some(nearest_id) = nearest_node {
-            let nearest_pos = graph
-                .get_node(nearest_id)
-                .ok_or(GameError::Entity(EntityError::NodeNotFound(nearest_id)))?
-                .position
-                + crate::constants::BOARD_PIXEL_OFFSET.as_vec2();
-
-            canvas.set_draw_color(Color::RGB(0, 255, 255)); // Bright cyan for highlighted connections
-            for edge in graph.adjacency_list[nearest_id].edges() {
-                let end_pos = graph
-                    .get_node(edge.target)
-                    .ok_or(GameError::Entity(EntityError::NodeNotFound(edge.target)))?
-                    .position
-                    + crate::constants::BOARD_PIXEL_OFFSET.as_vec2();
-                canvas
-                    .draw_line(
-                        (nearest_pos.x as i32, nearest_pos.y as i32),
-                        (end_pos.x as i32, end_pos.y as i32),
-                    )
-                    .map_err(|e| GameError::Sdl(e.to_string()))?;
-            }
-
-            // Highlight the nearest node in bright green
-            canvas.set_draw_color(Color::RGB(0, 255, 0)); // Bright green for highlighted node
-            canvas
-                .fill_rect(Rect::new(0, 0, 5, 5).centered_on(Point::new(nearest_pos.x as i32, nearest_pos.y as i32)))
-                .map_err(|e| GameError::Sdl(e.to_string()))?;
-
-            // Draw node ID text (small, offset to top right)
-            text_renderer.set_scale(0.5); // Small text
-            let id_text = format!("#{nearest_id}");
-            let text_pos = glam::UVec2::new(
-                (nearest_pos.x + 4.0) as u32, // Offset to the right
-                (nearest_pos.y - 6.0) as u32, // Offset to the top
-            );
-            if let Err(e) = text_renderer.render(canvas, atlas, &id_text, text_pos) {
-                tracing::error!("Failed to render node ID text: {}", e);
-            }
-        }
-
-        Ok(())
-    }
-
-    /// Finds the nearest node to the given cursor position.
-    pub fn find_nearest_node(graph: &crate::entity::graph::Graph, cursor_pos: Vec2) -> Option<usize> {
-        let mut nearest_id = None;
-        let mut nearest_distance = f32::INFINITY;
-
-        for i in 0..graph.node_count() {
-            if let Some(node) = graph.get_node(i) {
-                let node_pos = node.position + crate::constants::BOARD_PIXEL_OFFSET.as_vec2();
-                let distance = cursor_pos.distance(node_pos);
-
-                if distance < nearest_distance {
-                    nearest_distance = distance;
-                    nearest_id = Some(i);
-                }
-            }
-        }
-
-        nearest_id
-    }
 }

src/platform/desktop.rs

@@ -5,12 +5,12 @@ use std::time::Duration;
 
 use crate::asset::Asset;
 use crate::error::{AssetError, PlatformError};
-use crate::platform::Platform;
+use crate::platform::CommonPlatform;
 
 /// Desktop platform implementation.
-pub struct DesktopPlatform;
+pub struct Platform;
 
-impl Platform for DesktopPlatform {
+impl CommonPlatform for Platform {
     fn sleep(&self, duration: Duration, focused: bool) {
         if focused {
             spin_sleep::sleep(duration);
@@ -75,7 +75,8 @@ impl Platform for DesktopPlatform {
             Asset::Wav2 => Ok(Cow::Borrowed(include_bytes!("../../assets/game/sound/waka/2.ogg"))),
             Asset::Wav3 => Ok(Cow::Borrowed(include_bytes!("../../assets/game/sound/waka/3.ogg"))),
             Asset::Wav4 => Ok(Cow::Borrowed(include_bytes!("../../assets/game/sound/waka/4.ogg"))),
-            Asset::Atlas => Ok(Cow::Borrowed(include_bytes!("../../assets/game/atlas.png"))),
+            Asset::AtlasImage => Ok(Cow::Borrowed(include_bytes!("../../assets/game/atlas.png"))),
+            Asset::Font => Ok(Cow::Borrowed(include_bytes!("../../assets/game/TerminalVector.ttf"))),
         }
     }
 }

src/platform/emscripten.rs

@@ -5,12 +5,12 @@ use std::time::Duration;
 
 use crate::asset::Asset;
 use crate::error::{AssetError, PlatformError};
-use crate::platform::Platform;
+use crate::platform::CommonPlatform;
 
 /// Emscripten platform implementation.
-pub struct EmscriptenPlatform;
+pub struct Platform;
 
-impl Platform for EmscriptenPlatform {
+impl CommonPlatform for Platform {
     fn sleep(&self, duration: Duration, _focused: bool) {
         unsafe {
             emscripten_sleep(duration.as_millis() as u32);

src/platform/mod.rs

@@ -5,11 +5,13 @@ use crate::error::{AssetError, PlatformError};
 use std::borrow::Cow;
 use std::time::Duration;
 
-pub mod desktop;
-pub mod emscripten;
+#[cfg(not(target_os = "emscripten"))]
+mod desktop;
+#[cfg(target_os = "emscripten")]
+mod emscripten;
 
 /// Platform abstraction trait that defines cross-platform functionality.
-pub trait Platform {
+pub trait CommonPlatform {
     /// Sleep for the specified duration using platform-appropriate method.
     fn sleep(&self, duration: Duration, focused: bool);
 
@@ -32,17 +34,14 @@ pub trait Platform {
 
 /// Get the current platform implementation.
 #[allow(dead_code)]
-pub fn get_platform() -> &'static dyn Platform {
-    static DESKTOP: desktop::DesktopPlatform = desktop::DesktopPlatform;
-    static EMSCRIPTEN: emscripten::EmscriptenPlatform = emscripten::EmscriptenPlatform;
-
+pub fn get_platform() -> &'static dyn CommonPlatform {
     #[cfg(not(target_os = "emscripten"))]
     {
-        &DESKTOP
+        &desktop::Platform
     }
 
     #[cfg(target_os = "emscripten")]
     {
-        &EMSCRIPTEN
+        &emscripten::Platform
     }
 }

src/systems/debug.rs

@@ -4,19 +4,18 @@ use std::cmp::Ordering;
 use crate::constants::BOARD_PIXEL_OFFSET;
 use crate::map::builder::Map;
 use crate::systems::components::Collider;
+use crate::systems::input::CursorPosition;
 use crate::systems::movement::Position;
 use crate::systems::profiling::SystemTimings;
 use crate::systems::render::BackbufferResource;
 use bevy_ecs::prelude::*;
-use glam::Vec2;
+use glam::{IVec2, UVec2, Vec2};
 use sdl2::pixels::Color;
-use sdl2::rect::Rect;
+use sdl2::rect::{Point, Rect};
 use sdl2::render::{Canvas, Texture, TextureCreator};
+use sdl2::ttf::Font;
 use sdl2::video::{Window, WindowContext};
 
-#[derive(Resource, Default, Debug, Copy, Clone)]
-pub struct CursorPosition(pub Vec2);
-
 #[derive(Resource, Default, Debug, Copy, Clone, PartialEq)]
 pub enum DebugState {
     #[default]
@@ -38,41 +37,12 @@ impl DebugState {
 /// Resource to hold the debug texture for persistent rendering
 pub struct DebugTextureResource(pub Texture<'static>);
 
-/// Transforms a position from logical canvas coordinates to output canvas coordinates
-fn transform_position(pos: (f32, f32), output_size: (u32, u32), logical_size: (u32, u32)) -> (i32, i32) {
-    let scale_x = output_size.0 as f32 / logical_size.0 as f32;
-    let scale_y = output_size.1 as f32 / logical_size.1 as f32;
-    let scale = scale_x.min(scale_y);
-
-    let offset_x = (output_size.0 as f32 - logical_size.0 as f32 * scale) / 2.0;
-    let offset_y = (output_size.1 as f32 - logical_size.1 as f32 * scale) / 2.0;
-
-    let x = (pos.0 * scale + offset_x) as i32;
-    let y = (pos.1 * scale + offset_y) as i32;
-    (x, y)
-}
+/// Resource to hold the debug font
+pub struct DebugFontResource(pub Font<'static, 'static>);
 
 /// Transforms a position from logical canvas coordinates to output canvas coordinates (with board offset)
-fn transform_position_with_offset(pos: (f32, f32), output_size: (u32, u32), logical_size: (u32, u32)) -> (i32, i32) {
-    let scale_x = output_size.0 as f32 / logical_size.0 as f32;
-    let scale_y = output_size.1 as f32 / logical_size.1 as f32;
-    let scale = scale_x.min(scale_y);
-
-    let offset_x = (output_size.0 as f32 - logical_size.0 as f32 * scale) / 2.0;
-    let offset_y = (output_size.1 as f32 - logical_size.1 as f32 * scale) / 2.0;
-
-    let x = ((pos.0 + BOARD_PIXEL_OFFSET.x as f32) * scale + offset_x) as i32;
-    let y = ((pos.1 + BOARD_PIXEL_OFFSET.y as f32) * scale + offset_y) as i32;
-    (x, y)
-}
-
-/// Transforms a size from logical canvas coordinates to output canvas coordinates
-fn transform_size(size: f32, output_size: (u32, u32), logical_size: (u32, u32)) -> u32 {
-    let scale_x = output_size.0 as f32 / logical_size.0 as f32;
-    let scale_y = output_size.1 as f32 / logical_size.1 as f32;
-    let scale = scale_x.min(scale_y); // Use the smaller scale to maintain aspect ratio
-
-    (size * scale) as u32
+fn transform_position_with_offset(pos: Vec2, scale: f32) -> IVec2 {
+    ((pos + BOARD_PIXEL_OFFSET.as_vec2()) * scale).as_ivec2()
 }
 
 /// Renders timing information in the top-left corner of the screen
@@ -80,13 +50,8 @@ fn render_timing_display(
     canvas: &mut Canvas<Window>,
     texture_creator: &mut TextureCreator<WindowContext>,
     timings: &SystemTimings,
+    font: &Font,
 ) {
-    // Get TTF context
-    let ttf_context = sdl2::ttf::init().unwrap();
-
-    // Load font
-    let font = ttf_context.load_font("assets/site/TerminalVector.ttf", 12).unwrap();
-
     // Format timing information using the formatting module
     let lines = timings.format_timing_display();
     let line_height = 14; // Approximate line height for 12pt font
@@ -133,10 +98,12 @@ fn render_timing_display(
     }
 }
 
+#[allow(clippy::too_many_arguments)]
 pub fn debug_render_system(
     mut canvas: NonSendMut<&mut Canvas<Window>>,
     backbuffer: NonSendMut<BackbufferResource>,
     mut debug_texture: NonSendMut<DebugTextureResource>,
+    debug_font: NonSendMut<DebugFontResource>,
     debug_state: Res<DebugState>,
     timings: Res<SystemTimings>,
     map: Res<Map>,
@@ -146,10 +113,8 @@ pub fn debug_render_system(
     if *debug_state == DebugState::Off {
         return;
     }
-
-    // Get canvas sizes for coordinate transformation
-    let output_size = canvas.output_size().unwrap();
-    let logical_size = canvas.logical_size();
+    let scale =
+        (UVec2::from(canvas.output_size().unwrap()).as_vec2() / UVec2::from(canvas.logical_size()).as_vec2()).min_element();
 
     // Copy the current backbuffer to the debug texture
     canvas
@@ -165,8 +130,12 @@ pub fn debug_render_system(
 
     // Get texture creator before entering the closure to avoid borrowing conflicts
     let mut texture_creator = canvas.texture_creator();
+    let font = &debug_font.0;
 
-    let cursor_world_pos = cursor.0 - BOARD_PIXEL_OFFSET.as_vec2();
+    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
@@ -175,13 +144,16 @@ pub fn debug_render_system(
                 DebugState::Graph => {
                     // Find the closest node to the cursor
 
-                    let closest_node = 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);
+                    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::RED);
                     for (start_node, end_node) in map.graph.edges() {
@@ -189,34 +161,43 @@ pub fn debug_render_system(
                         let end_node = map.graph.get_node(end_node.target).unwrap().position;
 
                         // Transform positions using common method
-                        let (start_x, start_y) = transform_position_with_offset(
-                            (start_node_model.position.x, start_node_model.position.y),
-                            output_size,
-                            logical_size,
-                        );
-                        let (end_x, end_y) = transform_position_with_offset((end_node.x, end_node.y), output_size, logical_size);
+                        let start = transform_position_with_offset(start_node_model.position, scale);
+                        let end = transform_position_with_offset(end_node, scale);
 
-                        debug_canvas.draw_line((start_x, start_y), (end_x, end_y)).unwrap();
+                        debug_canvas
+                            .draw_line(Point::from((start.x, start.y)), Point::from((end.x, end.y)))
+                            .unwrap();
                     }
 
                     for (id, node) in map.graph.nodes().enumerate() {
                         let pos = node.position;
 
                         // Set color based on whether the node is the closest to the cursor
-                        if Some(id) == closest_node {
-                            debug_canvas.set_draw_color(Color::YELLOW);
+                        debug_canvas.set_draw_color(if Some(id) == closest_node {
+                            Color::YELLOW
                         } else {
-                            debug_canvas.set_draw_color(Color::BLUE);
-                        }
+                            Color::BLUE
+                        });
 
                         // Transform position using common method
-                        let (x, y) = transform_position_with_offset((pos.x, pos.y), output_size, logical_size);
-                        let size = transform_size(4.0, output_size, logical_size);
+                        let pos = transform_position_with_offset(pos, scale);
+                        let size = (3.0 * scale) as u32;
 
                         debug_canvas
-                            .fill_rect(Rect::new(x - (size as i32 / 2), y - (size as i32 / 2), size, size))
+                            .fill_rect(Rect::new(pos.x - (size as i32 / 2), pos.y - (size as i32 / 2), size, size))
                             .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).unwrap();
+                        let pos = transform_position_with_offset(node.position, scale);
+
+                        let surface = font.render(&closest_node_id.to_string()).blended(Color::WHITE).unwrap();
+                        let texture = texture_creator.create_texture_from_surface(&surface).unwrap();
+                        let dest = Rect::new(pos.x + 10, pos.y - 5, texture.query().width, texture.query().height);
+                        debug_canvas.copy(&texture, None, dest).unwrap();
+                    }
                 }
                 DebugState::Collision => {
                     debug_canvas.set_draw_color(Color::GREEN);
@@ -224,41 +205,18 @@ pub fn debug_render_system(
                         let pos = position.get_pixel_position(&map.graph).unwrap();
 
                         // Transform position and size using common methods
-                        let (x, y) = transform_position((pos.x, pos.y), output_size, logical_size);
-                        let size = transform_size(collider.size, output_size, logical_size);
+                        let pos = (pos * scale).as_ivec2();
+                        let size = (collider.size * scale) as u32;
 
-                        // Center the collision box on the entity
-                        let rect = Rect::new(x - (size as i32 / 2), y - (size as i32 / 2), size, size);
+                        let rect = Rect::from_center(Point::from((pos.x, pos.y)), size, size);
                         debug_canvas.draw_rect(rect).unwrap();
                     }
                 }
                 _ => {}
             }
 
-            // Render node ID if a node is highlighted
-            if let DebugState::Graph = *debug_state {
-                if let Some(closest_node_id) = 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)
-                {
-                    let node = map.graph.get_node(closest_node_id).unwrap();
-                    let (x, y) = transform_position_with_offset((node.position.x, node.position.y), output_size, logical_size);
-
-                    let ttf_context = sdl2::ttf::init().unwrap();
-                    let font = ttf_context.load_font("assets/site/TerminalVector.ttf", 12).unwrap();
-                    let surface = font.render(&closest_node_id.to_string()).blended(Color::WHITE).unwrap();
-                    let texture = texture_creator.create_texture_from_surface(&surface).unwrap();
-                    let dest = Rect::new(x + 10, y - 5, texture.query().width, texture.query().height);
-                    debug_canvas.copy(&texture, None, dest).unwrap();
-                }
-            }
-
             // Render timing information in the top-left corner
-            render_timing_display(debug_canvas, &mut texture_creator, &timings);
+            render_timing_display(debug_canvas, &mut texture_creator, &timings, font);
         })
         .unwrap();
 

src/systems/input.rs

@@ -3,18 +3,28 @@ use std::collections::{HashMap, HashSet};
 use bevy_ecs::{
     event::EventWriter,
     resource::Resource,
-    system::{NonSendMut, ResMut},
+    system::{NonSendMut, Res, ResMut},
 };
 use glam::Vec2;
 use sdl2::{event::Event, keyboard::Keycode, EventPump};
 
-use crate::systems::debug::CursorPosition;
+use crate::systems::components::DeltaTime;
 use crate::{
     entity::direction::Direction,
     events::{GameCommand, GameEvent},
 };
 
-#[derive(Debug, Clone, Resource)]
+#[derive(Resource, Default, Debug, Copy, Clone)]
+pub enum CursorPosition {
+    #[default]
+    None,
+    Some {
+        position: Vec2,
+        remaining_time: f32,
+    },
+}
+
+#[derive(Resource, Debug, Clone)]
 pub struct Bindings {
     key_bindings: HashMap<Keycode, GameCommand>,
     movement_keys: HashSet<Keycode>,
@@ -63,12 +73,14 @@ impl Default for Bindings {
 }
 
 pub fn input_system(
+    delta_time: Res<DeltaTime>,
     mut bindings: ResMut<Bindings>,
     mut writer: EventWriter<GameEvent>,
     mut pump: NonSendMut<&'static mut EventPump>,
     mut cursor: ResMut<CursorPosition>,
 ) {
     let mut movement_key_pressed = false;
+    let mut cursor_seen = false;
 
     for event in pump.poll_iter() {
         match event {
@@ -76,7 +88,11 @@ pub fn input_system(
                 writer.write(GameEvent::Command(GameCommand::Exit));
             }
             Event::MouseMotion { x, y, .. } => {
-                cursor.0 = Vec2::new(x as f32, y as f32);
+                *cursor = CursorPosition::Some {
+                    position: Vec2::new(x as f32, y as f32),
+                    remaining_time: 0.20,
+                };
+                cursor_seen = true;
             }
             Event::KeyUp {
                 repeat: false,
@@ -117,4 +133,11 @@ pub fn input_system(
             }
         }
     }
+
+    if let (false, CursorPosition::Some { remaining_time, .. }) = (cursor_seen, &mut *cursor) {
+        *remaining_time -= delta_time.0;
+        if *remaining_time <= 0.0 {
+            *cursor = CursorPosition::None;
+        }
+    }
 }

tests/common/mod.rs

@@ -28,7 +28,7 @@ pub fn setup_sdl() -> Result<(Canvas<Window>, TextureCreator<WindowContext>, Sdl
 
 pub fn create_atlas(canvas: &mut sdl2::render::Canvas<sdl2::video::Window>) -> SpriteAtlas {
     let texture_creator = canvas.texture_creator();
-    let atlas_bytes = get_asset_bytes(Asset::Atlas).unwrap();
+    let atlas_bytes = get_asset_bytes(Asset::AtlasImage).unwrap();
 
     let texture = texture_creator.load_texture_bytes(&atlas_bytes).unwrap();
     let texture: Texture<'static> = unsafe { std::mem::transmute(texture) };

tests/debug_rendering.rs

@@ -1,34 +0,0 @@
-use glam::Vec2;
-use pacman::entity::graph::{Graph, Node};
-use pacman::map::render::MapRenderer;
-
-#[test]
-fn test_find_nearest_node() {
-    let mut graph = Graph::new();
-
-    // Add some test nodes
-    let node1 = graph.add_node(Node {
-        position: Vec2::new(10.0, 10.0),
-    });
-    let node2 = graph.add_node(Node {
-        position: Vec2::new(50.0, 50.0),
-    });
-    let node3 = graph.add_node(Node {
-        position: Vec2::new(100.0, 100.0),
-    });
-
-    // Test cursor near node1
-    let cursor_pos = Vec2::new(12.0, 8.0);
-    let nearest = MapRenderer::find_nearest_node(&graph, cursor_pos);
-    assert_eq!(nearest, Some(node1));
-
-    // Test cursor near node2
-    let cursor_pos = Vec2::new(45.0, 55.0);
-    let nearest = MapRenderer::find_nearest_node(&graph, cursor_pos);
-    assert_eq!(nearest, Some(node2));
-
-    // Test cursor near node3
-    let cursor_pos = Vec2::new(98.0, 102.0);
-    let nearest = MapRenderer::find_nearest_node(&graph, cursor_pos);
-    assert_eq!(nearest, Some(node3));
-}

tests/game.rs

@@ -1,12 +0,0 @@
-use pacman::constants::RAW_BOARD;
-use pacman::map::builder::Map;
-
-mod item;
-
-#[test]
-fn test_game_map_creation() {
-    let map = Map::new(RAW_BOARD).unwrap();
-
-    assert!(map.graph.node_count() > 0);
-    assert!(!map.grid_to_node.is_empty());
-}

tests/graph.rs

@@ -29,7 +29,7 @@ fn test_graph_basic_operations() {
         position: glam::Vec2::new(16.0, 0.0),
     });
 
-    assert_eq!(graph.node_count(), 2);
+    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());
@@ -102,7 +102,7 @@ fn should_add_connected_node() {
         )
         .unwrap();
 
-    assert_eq!(graph.node_count(), 2);
+    assert_eq!(graph.nodes().count(), 2);
     let edge = graph.find_edge(node1, node2);
     assert!(edge.is_some());
     assert_eq!(edge.unwrap().direction, Direction::Right);

tests/map_builder.rs

@@ -6,7 +6,7 @@ use pacman::map::builder::Map;
 fn test_map_creation() {
     let map = Map::new(RAW_BOARD).unwrap();
 
-    assert!(map.graph.node_count() > 0);
+    assert!(map.graph.nodes().count() > 0);
     assert!(!map.grid_to_node.is_empty());
 
     // Check that some connections were made

web.build.ts

@@ -1,7 +1,7 @@
 import { $ } from "bun";
 import { existsSync, promises as fs } from "fs";
 import { platform } from "os";
-import { dirname, join, relative, resolve } from "path";
+import { basename, dirname, join, relative, resolve } from "path";
 import { match, P } from "ts-pattern";
 import { configure, getConsoleSink, getLogger } from "@logtape/logtape";
 
@@ -79,16 +79,19 @@ async function build(release: boolean, env: Record<string, string> | null) {
 
   // The files to copy into 'dist'
   const files = [
-    ...["index.html", "favicon.ico", "build.css", "TerminalVector.ttf"].map(
-      (file) => ({
-        src: join(siteFolder, file),
-        dest: join(dist, file),
-        optional: false,
-      })
-    ),
+    ...[
+      "index.html",
+      "favicon.ico",
+      "build.css",
+      "../game/TerminalVector.ttf",
+    ].map((file) => ({
+      src: resolve(join(siteFolder, file)),
+      dest: join(dist, basename(file)),
+      optional: false,
+    })),
     ...["pacman.wasm", "pacman.js", "deps/pacman.data"].map((file) => ({
       src: join(outputFolder, file),
-      dest: join(dist, file.split("/").pop() || file),
+      dest: join(dist, basename(file)),
       optional: false,
     })),
     {