feat: add pre-comit configuration

.pre-commit-config.yaml

@@ -0,0 +1,22 @@
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v5.0.0
+    hooks:
+      - id: trailing-whitespace
+      - id: end-of-file-fixer
+      - id: check-added-large-files
+      - id: check-merge-conflict
+      - id: check-case-conflict
+      - id: check-toml
+      - id: check-yaml
+      - id: forbid-submodules
+      - id: mixed-line-ending
+
+  - repo: local
+    hooks:
+      - id: cargo-fmt
+        name: cargo fmt
+        entry: cargo fmt --all --
+        language: system
+        types: [rust]
+        pass_filenames: false

Cargo.lock

@@ -11,6 +11,12 @@ dependencies = [
  "memchr",
 ]
 
+[[package]]
+name = "anyhow"
+version = "1.0.98"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e16d2d3311acee920a9eb8d33b8cbc1787ce4a264e85f964c2404b969bdcd487"
+
 [[package]]
 name = "autocfg"
 version = "1.5.0"
@@ -150,9 +156,9 @@ dependencies = [
 
 [[package]]
 name = "once_cell"
-version = "1.18.0"
+version = "1.21.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd8b5dd2ae5ed71462c540258bedcb51965123ad7e7ccf4b9a8cafaa4a63576d"
+checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
 
 [[package]]
 name = "overload"
@@ -164,12 +170,15 @@ checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39"
 name = "pacman"
 version = "0.1.0"
 dependencies = [
+ "anyhow",
  "lazy_static",
  "libc",
+ "once_cell",
  "pathfinding",
  "rand",
  "sdl2",
  "spin_sleep",
+ "thiserror 1.0.69",
  "tracing",
  "tracing-error",
  "tracing-subscriber",
@@ -187,7 +196,7 @@ dependencies = [
  "integer-sqrt",
  "num-traits",
  "rustc-hash",
- "thiserror",
+ "thiserror 2.0.12",
 ]
 
 [[package]]
@@ -374,13 +383,33 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "thiserror"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
+dependencies = [
+ "thiserror-impl 1.0.69",
+]
+
 [[package]]
 name = "thiserror"
 version = "2.0.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "567b8a2dae586314f7be2a752ec7474332959c6460e02bde30d702a66d488708"
 dependencies = [
- "thiserror-impl",
+ "thiserror-impl 2.0.12",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
 ]
 
 [[package]]

Cargo.toml

@@ -14,6 +14,9 @@ sdl2 = { version = "0.38.0", features = ["image", "ttf"] }
 spin_sleep = "1.3.2"
 rand = "0.9.2"
 pathfinding = "4.14"
+once_cell = "1.21.3"
+thiserror = "1.0"
+anyhow = "1.0"
 
 [target.'cfg(target_os = "windows")'.dependencies.winapi]
 version = "0.3"

src/asset.rs

@@ -0,0 +1,74 @@
+//! Cross-platform asset loading abstraction.
+//! On desktop, assets are embedded using include_bytes!; on Emscripten, assets are loaded from the filesystem.
+
+use std::borrow::Cow;
+use std::io;
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum AssetError {
+    #[error("IO error: {0}")]
+    Io(#[from] io::Error),
+    #[error("Asset not found: {0}")]
+    NotFound(String),
+    #[error("Invalid asset format: {0}")]
+    InvalidFormat(String),
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum Asset {
+    Wav1,
+    Wav2,
+    Wav3,
+    Wav4,
+    Pacman,
+    Pellet,
+    Energizer,
+    Map,
+    FontKonami,
+    GhostBody,
+    GhostEyes,
+    // Add more as needed
+}
+
+#[cfg(not(target_os = "emscripten"))]
+mod imp {
+    use super::*;
+    macro_rules! asset_bytes_enum {
+        ( $asset:expr ) => {
+            match $asset {
+                Asset::Wav1 => Cow::Borrowed(include_bytes!("../assets/wav/1.ogg")),
+                Asset::Wav2 => Cow::Borrowed(include_bytes!("../assets/wav/2.ogg")),
+                Asset::Wav3 => Cow::Borrowed(include_bytes!("../assets/wav/3.ogg")),
+                Asset::Wav4 => Cow::Borrowed(include_bytes!("../assets/wav/4.ogg")),
+                Asset::Pacman => Cow::Borrowed(include_bytes!("../assets/32/pacman.png")),
+                Asset::Pellet => Cow::Borrowed(include_bytes!("../assets/24/pellet.png")),
+                Asset::Energizer => Cow::Borrowed(include_bytes!("../assets/24/energizer.png")),
+                Asset::Map => Cow::Borrowed(include_bytes!("../assets/map.png")),
+                Asset::FontKonami => Cow::Borrowed(include_bytes!("../assets/font/konami.ttf")),
+                Asset::GhostBody => Cow::Borrowed(include_bytes!("../assets/32/ghost_body.png")),
+                Asset::GhostEyes => Cow::Borrowed(include_bytes!("../assets/32/ghost_eyes.png")),
+            }
+        };
+    }
+    pub fn get_asset_bytes(asset: Asset) -> Result<Cow<'static, [u8]>, AssetError> {
+        Ok(asset_bytes_enum!(asset))
+    }
+}
+
+#[cfg(target_os = "emscripten")]
+mod imp {
+    use super::*;
+    use std::fs;
+    use std::path::Path;
+    pub fn get_asset_bytes(asset: Asset) -> Result<Cow<'static, [u8]>, AssetError> {
+        let path = Path::new("assets").join(asset.path());
+        if !path.exists() {
+            return Err(AssetError::NotFound(asset.path().to_string()));
+        }
+        let bytes = fs::read(&path)?;
+        Ok(Cow::Owned(bytes))
+    }
+}
+
+pub use imp::get_asset_bytes;

src/audio.rs

@@ -1,16 +1,11 @@
 //! This module handles the audio playback for the game.
+use crate::asset::{get_asset_bytes, Asset};
 use sdl2::{
     mixer::{self, Chunk, InitFlag, LoaderRWops, DEFAULT_FORMAT},
     rwops::RWops,
 };
 
-const SOUND_1_DATA: &[u8] = include_bytes!("../assets/wav/1.ogg");
+const SOUND_ASSETS: [Asset; 4] = [Asset::Wav1, Asset::Wav2, Asset::Wav3, Asset::Wav4];
-const SOUND_2_DATA: &[u8] = include_bytes!("../assets/wav/2.ogg");
-const SOUND_3_DATA: &[u8] = include_bytes!("../assets/wav/3.ogg");
-const SOUND_4_DATA: &[u8] = include_bytes!("../assets/wav/4.ogg");
-
-/// An array of all the sound effect data.
-const SOUND_DATA: [&[u8]; 4] = [SOUND_1_DATA, SOUND_2_DATA, SOUND_3_DATA, SOUND_4_DATA];
 
 /// The audio system for the game.
 ///
@@ -34,21 +29,21 @@ impl Audio {
 
         // set channel volume
         for i in 0..channels {
-            mixer::Channel(i as i32).set_volume(32);
+            mixer::Channel(i).set_volume(32);
         }
 
         let mixer_context = mixer::init(InitFlag::OGG).expect("Failed to initialize SDL2_mixer");
 
-        let sounds: Vec<Chunk> = SOUND_DATA
+        let sounds: Vec<Chunk> = SOUND_ASSETS
             .iter()
             .enumerate()
-            .map(|(i, data)| {
+            .map(|(i, asset)| {
-                let rwops = RWops::from_bytes(data)
+                let data = get_asset_bytes(*asset).expect("Failed to load sound asset");
-                    .expect(&format!("Failed to create RWops for sound {}", i + 1));
+                let rwops = RWops::from_bytes(&data)
-                rwops.load_wav().expect(&format!(
+                    .unwrap_or_else(|_| panic!("Failed to create RWops for sound {}", i + 1));
-                    "Failed to load sound {} from embedded data",
+                rwops
-                    i + 1
+                    .load_wav()
-                ))
+                    .unwrap_or_else(|_| panic!("Failed to load sound {} from asset API", i + 1))
             })
             .collect();
 

src/constants.rs

@@ -73,6 +73,19 @@ impl FruitType {
             FruitType::Key => 5000,
         }
     }
+
+    pub fn index(self) -> usize {
+        match self {
+            FruitType::Cherry => 0,
+            FruitType::Strawberry => 1,
+            FruitType::Orange => 2,
+            FruitType::Apple => 3,
+            FruitType::Melon => 4,
+            FruitType::Galaxian => 5,
+            FruitType::Bell => 6,
+            FruitType::Key => 7,
+        }
+    }
 }
 
 /// The raw layout of the game board, as a 2D array of characters.

src/debug.rs

@@ -1,7 +1,6 @@
 //! Debug rendering utilities for Pac-Man.
 use crate::{
     constants::{MapTile, BOARD_HEIGHT, BOARD_WIDTH},
-    direction::Direction,
     ghosts::blinky::Blinky,
     map::Map,
 };
@@ -18,16 +17,11 @@ pub enum DebugMode {
 pub struct DebugRenderer;
 
 impl DebugRenderer {
-    pub fn draw_cell(canvas: &mut Canvas<Window>, map: &Map, cell: (u32, u32), color: Color) {
+    pub fn draw_cell(canvas: &mut Canvas<Window>, _map: &Map, cell: (u32, u32), color: Color) {
         let position = Map::cell_to_pixel(cell);
         canvas.set_draw_color(color);
         canvas
-            .draw_rect(sdl2::rect::Rect::new(
+            .draw_rect(sdl2::rect::Rect::new(position.0, position.1, 24, 24))
-                position.0 as i32,
-                position.1 as i32,
-                24,
-                24,
-            ))
             .expect("Could not draw rectangle");
     }
 

src/edible.rs

@@ -2,7 +2,7 @@
 use crate::animation::{AtlasTexture, FrameDrawn};
 use crate::constants::{FruitType, MapTile, BOARD_HEIGHT, BOARD_WIDTH};
 use crate::direction::Direction;
-use crate::entity::{Entity, Renderable};
+use crate::entity::{Entity, Renderable, StaticEntity};
 use crate::map::Map;
 use sdl2::{render::Canvas, video::Window};
 use std::cell::RefCell;
@@ -16,33 +16,29 @@ pub enum EdibleKind {
 }
 
 pub struct Edible<'a> {
-    pub base: crate::entity::StaticEntity,
+    pub base: StaticEntity,
     pub kind: EdibleKind,
-    pub sprite: std::rc::Rc<AtlasTexture<'a>>,
+    pub sprite: Rc<AtlasTexture<'a>>,
 }
 
 impl<'a> Edible<'a> {
-    pub fn new(
+    pub fn new(kind: EdibleKind, cell_position: (u32, u32), sprite: Rc<AtlasTexture<'a>>) -> Self {
-        kind: EdibleKind,
+        let pixel_position = Map::cell_to_pixel(cell_position);
-        cell_position: (u32, u32),
-        sprite: std::rc::Rc<AtlasTexture<'a>>,
-    ) -> Self {
-        let pixel_position = crate::map::Map::cell_to_pixel(cell_position);
         Edible {
-            base: crate::entity::StaticEntity::new(pixel_position, cell_position),
+            base: StaticEntity::new(pixel_position, cell_position),
             kind,
             sprite,
         }
     }
 
     /// Checks collision with Pac-Man (or any entity)
-    pub fn collide(&self, pacman: &dyn crate::entity::Entity) -> bool {
+    pub fn collide(&self, pacman: &dyn Entity) -> bool {
         self.base.is_colliding(pacman)
     }
 }
 
 impl<'a> Entity for Edible<'a> {
-    fn base(&self) -> &crate::entity::StaticEntity {
+    fn base(&self) -> &StaticEntity {
         &self.base
     }
 }
@@ -57,9 +53,9 @@ impl<'a> Renderable for Edible<'a> {
 /// Reconstruct all edibles from the original map layout
 pub fn reconstruct_edibles<'a>(
     map: Rc<RefCell<Map>>,
-    pellet_sprite: std::rc::Rc<AtlasTexture<'a>>,
+    pellet_sprite: Rc<AtlasTexture<'a>>,
-    power_pellet_sprite: std::rc::Rc<AtlasTexture<'a>>,
+    power_pellet_sprite: Rc<AtlasTexture<'a>>,
-    fruit_sprite: std::rc::Rc<AtlasTexture<'a>>,
+    _fruit_sprite: Rc<AtlasTexture<'a>>,
 ) -> Vec<Edible<'a>> {
     let mut edibles = Vec::new();
     for x in 0..BOARD_WIDTH {

src/game.rs

@@ -10,32 +10,18 @@ use sdl2::rwops::RWops;
 use sdl2::ttf::Font;
 use sdl2::video::WindowContext;
 use sdl2::{pixels::Color, render::Canvas, video::Window};
-use tracing::event;
 
+use crate::animation::AtlasTexture;
+use crate::asset::{get_asset_bytes, Asset};
 use crate::audio::Audio;
-use crate::{
+use crate::constants::RAW_BOARD;
-    animation::{AtlasTexture, FrameDrawn},
-    constants::{MapTile, BOARD_HEIGHT, BOARD_WIDTH, RAW_BOARD},
-    direction::Direction,
-    entity::{Entity, Renderable},
-    ghosts::blinky::Blinky,
-    map::Map,
-    pacman::Pacman,
-};
-
 use crate::debug::{DebugMode, DebugRenderer};
+use crate::direction::Direction;
 use crate::edible::{reconstruct_edibles, Edible, EdibleKind};
-
+use crate::entity::Renderable;
-// Embed texture data directly into the executable
+use crate::ghosts::blinky::Blinky;
-static PACMAN_TEXTURE_DATA: &[u8] = include_bytes!("../assets/32/pacman.png");
+use crate::map::Map;
-static PELLET_TEXTURE_DATA: &[u8] = include_bytes!("../assets/24/pellet.png");
+use crate::pacman::Pacman;
-static POWER_PELLET_TEXTURE_DATA: &[u8] = include_bytes!("../assets/24/energizer.png");
-static MAP_TEXTURE_DATA: &[u8] = include_bytes!("../assets/map.png");
-static FONT_DATA: &[u8] = include_bytes!("../assets/font/konami.ttf");
-
-// Add ghost texture data
-static GHOST_BODY_TEXTURE_DATA: &[u8] = include_bytes!("../assets/32/ghost_body.png");
-static GHOST_EYES_TEXTURE_DATA: &[u8] = include_bytes!("../assets/32/ghost_eyes.png");
 
 /// The main game state.
 ///
@@ -48,15 +34,15 @@ pub struct Game<'a> {
     power_pellet_texture: Rc<AtlasTexture<'a>>,
     font: Font<'a, 'static>,
     pacman: Rc<RefCell<Pacman<'a>>>,
-    map: Rc<std::cell::RefCell<Map>>,
+    map: Rc<RefCell<Map>>,
     debug_mode: DebugMode,
     score: u32,
-    audio: crate::audio::Audio,
+    audio: Audio,
     blinky: Blinky<'a>,
     edibles: Vec<Edible<'a>>,
 }
 
-impl Game<'_> {
+impl<'a> Game<'a> {
     /// Creates a new `Game` instance.
     ///
     /// # Arguments
@@ -65,31 +51,34 @@ impl Game<'_> {
     /// * `texture_creator` - The SDL texture creator.
     /// * `ttf_context` - The SDL TTF context.
     /// * `_audio_subsystem` - The SDL audio subsystem (currently unused).
-    pub fn new<'a>(
+    pub fn new(
         canvas: &'a mut Canvas<Window>,
         texture_creator: &'a TextureCreator<WindowContext>,
         ttf_context: &'a sdl2::ttf::Sdl2TtfContext,
         _audio_subsystem: &'a sdl2::AudioSubsystem,
     ) -> Game<'a> {
-        let map = Rc::new(std::cell::RefCell::new(Map::new(RAW_BOARD)));
+        let map = Rc::new(RefCell::new(Map::new(RAW_BOARD)));
 
-        // Load Pacman texture from embedded data
+        // Load Pacman texture from asset API
+        let pacman_bytes = get_asset_bytes(Asset::Pacman).expect("Failed to load asset");
         let pacman_atlas = texture_creator
-            .load_texture_bytes(PACMAN_TEXTURE_DATA)
+            .load_texture_bytes(&pacman_bytes)
-            .expect("Could not load pacman texture from embedded data");
+            .expect("Could not load pacman texture from asset API");
-        let pacman = Rc::new(std::cell::RefCell::new(Pacman::new(
+        let pacman = Rc::new(RefCell::new(Pacman::new(
             (1, 1),
             pacman_atlas,
             Rc::clone(&map),
         )));
 
         // Load ghost textures
+        let ghost_body_bytes = get_asset_bytes(Asset::GhostBody).expect("Failed to load asset");
         let ghost_body = texture_creator
-            .load_texture_bytes(GHOST_BODY_TEXTURE_DATA)
+            .load_texture_bytes(&ghost_body_bytes)
-            .expect("Could not load ghost body texture from embedded data");
+            .expect("Could not load ghost body texture from asset API");
+        let ghost_eyes_bytes = get_asset_bytes(Asset::GhostEyes).expect("Failed to load asset");
         let ghost_eyes = texture_creator
-            .load_texture_bytes(GHOST_EYES_TEXTURE_DATA)
+            .load_texture_bytes(&ghost_eyes_bytes)
-            .expect("Could not load ghost eyes texture from embedded data");
+            .expect("Could not load ghost eyes texture from asset API");
 
         // Create Blinky
         let blinky = Blinky::new(
@@ -100,38 +89,48 @@ impl Game<'_> {
             Rc::clone(&pacman),
         );
 
-        // Load pellet texture from embedded data
+        // Load pellet texture from asset API
+        let pellet_bytes = get_asset_bytes(Asset::Pellet).expect("Failed to load asset");
         let pellet_texture = Rc::new(AtlasTexture::new(
             texture_creator
-                .load_texture_bytes(PELLET_TEXTURE_DATA)
+                .load_texture_bytes(&pellet_bytes)
-                .expect("Could not load pellet texture from embedded data"),
+                .expect("Could not load pellet texture from asset API"),
             1,
             24,
             24,
             None,
         ));
+        let power_pellet_bytes = get_asset_bytes(Asset::Energizer).expect("Failed to load asset");
         let power_pellet_texture = Rc::new(AtlasTexture::new(
             texture_creator
-                .load_texture_bytes(POWER_PELLET_TEXTURE_DATA)
+                .load_texture_bytes(&power_pellet_bytes)
-                .expect("Could not load power pellet texture from embedded data"),
+                .expect("Could not load power pellet texture from asset API"),
             1,
             24,
             24,
             None,
         ));
 
-        // Load font from embedded data
+        // Load font from asset API
-        let font_rwops = RWops::from_bytes(FONT_DATA).expect("Failed to create RWops for font");
+        let font = {
-        let font = ttf_context
+            let font_bytes = get_asset_bytes(Asset::FontKonami)
+                .expect("Failed to load asset")
+                .into_owned();
+            let font_bytes_static: &'static [u8] = Box::leak(font_bytes.into_boxed_slice());
+            let font_rwops =
+                RWops::from_bytes(font_bytes_static).expect("Failed to create RWops for font");
+            ttf_context
                 .load_font_from_rwops(font_rwops, 24)
-            .expect("Could not load font from embedded data");
+                .expect("Could not load font from asset API")
+        };
 
         let audio = Audio::new();
 
-        // Load map texture from embedded data
+        // Load map texture from asset API
+        let map_bytes = get_asset_bytes(Asset::Map).expect("Failed to load asset");
         let mut map_texture = texture_creator
-            .load_texture_bytes(MAP_TEXTURE_DATA)
+            .load_texture_bytes(&map_bytes)
-            .expect("Could not load map texture from embedded data");
+            .expect("Could not load map texture from asset API");
         map_texture.set_color_mod(0, 0, 255);
 
         let edibles = reconstruct_edibles(
@@ -184,7 +183,6 @@ impl Game<'_> {
         // Reset game
         if keycode == Keycode::R {
             self.reset();
-            return;
         }
     }
 
@@ -347,7 +345,7 @@ impl Game<'_> {
 
         // Render the score and high score
         self.render_text(
-            &format!("{}UP   HIGH SCORE   ", lives),
+            &format!("{lives}UP   HIGH SCORE   "),
             (24 * lives_offset + x_offset, y_offset),
             Color::WHITE,
         );

src/ghost.rs

@@ -1,15 +1,17 @@
 use pathfinding::prelude::dijkstra;
 use rand::Rng;
 
-use crate::{
+use crate::animation::{AnimatedAtlasTexture, FrameDrawn};
-    animation::{AnimatedAtlasTexture, FrameDrawn},
+use crate::constants::{MapTile, BOARD_WIDTH};
-    constants::{MapTile, BOARD_WIDTH},
+use crate::direction::Direction;
-    direction::Direction,
+use crate::entity::{Entity, MovableEntity, Moving, Renderable};
-    entity::{Entity, MovableEntity, Moving, Renderable, StaticEntity},
+use crate::map::Map;
-    map::Map,
+use crate::modulation::{SimpleTickModulator, TickModulator};
-    modulation::{SimpleTickModulator, TickModulator},
+use crate::pacman::Pacman;
-    pacman::Pacman,
+use sdl2::pixels::Color;
-};
+use sdl2::render::Texture;
+use std::cell::RefCell;
+use std::rc::Rc;
 
 /// The different modes a ghost can be in
 #[derive(Debug, Clone, Copy, PartialEq)]
@@ -37,12 +39,12 @@ pub enum GhostType {
 
 impl GhostType {
     /// Returns the color of the ghost.
-    pub fn color(&self) -> sdl2::pixels::Color {
+    pub fn color(&self) -> Color {
         match self {
-            GhostType::Blinky => sdl2::pixels::Color::RGB(255, 0, 0),
+            GhostType::Blinky => Color::RGB(255, 0, 0),
-            GhostType::Pinky => sdl2::pixels::Color::RGB(255, 184, 255),
+            GhostType::Pinky => Color::RGB(255, 184, 255),
-            GhostType::Inky => sdl2::pixels::Color::RGB(0, 255, 255),
+            GhostType::Inky => Color::RGB(0, 255, 255),
-            GhostType::Clyde => sdl2::pixels::Color::RGB(255, 184, 82),
+            GhostType::Clyde => Color::RGB(255, 184, 82),
         }
     }
 }
@@ -56,7 +58,7 @@ pub struct Ghost<'a> {
     /// The type/personality of this ghost
     pub ghost_type: GhostType,
     /// Reference to Pac-Man for targeting
-    pub pacman: std::rc::Rc<std::cell::RefCell<Pacman<'a>>>,
+    pub pacman: Rc<RefCell<Pacman<'a>>>,
     pub body_sprite: AnimatedAtlasTexture<'a>,
     pub eyes_sprite: AnimatedAtlasTexture<'a>,
 }
@@ -66,10 +68,10 @@ impl Ghost<'_> {
     pub fn new<'a>(
         ghost_type: GhostType,
         starting_position: (u32, u32),
-        body_texture: sdl2::render::Texture<'a>,
+        body_texture: Texture<'a>,
-        eyes_texture: sdl2::render::Texture<'a>,
+        eyes_texture: Texture<'a>,
-        map: std::rc::Rc<std::cell::RefCell<Map>>,
+        map: Rc<RefCell<Map>>,
-        pacman: std::rc::Rc<std::cell::RefCell<Pacman<'a>>>,
+        pacman: Rc<RefCell<Pacman<'a>>>,
     ) -> Ghost<'a> {
         let color = ghost_type.color();
         let mut body_sprite = AnimatedAtlasTexture::new(body_texture, 8, 2, 32, 32, Some((-4, -4)));
@@ -301,7 +303,7 @@ impl<'a> Moving for Ghost<'a> {
     }
 }
 
-impl Renderable for Ghost<'_> {
+impl<'a> Renderable for Ghost<'a> {
     fn render(&self, canvas: &mut sdl2::render::Canvas<sdl2::video::Window>) {
         let pos = self.base.base.pixel_position;
         self.body_sprite.render(canvas, pos, Direction::Right, None);

src/ghosts/blinky.rs

@@ -4,12 +4,11 @@ use std::rc::Rc;
 use sdl2::render::{Canvas, Texture};
 use sdl2::video::Window;
 
-use crate::{
+use crate::direction::Direction;
-    entity::{Entity, MovableEntity, Renderable},
+use crate::entity::{Entity, Moving, Renderable, StaticEntity};
-    ghost::{Ghost, GhostMode, GhostType},
+use crate::ghost::{Ghost, GhostMode, GhostType};
-    map::Map,
+use crate::map::Map;
-    pacman::Pacman,
+use crate::pacman::Pacman;
-};
 
 pub struct Blinky<'a> {
     ghost: Ghost<'a>,
@@ -51,29 +50,29 @@ impl<'a> Blinky<'a> {
     }
 }
 
-impl<'a> crate::entity::Entity for Blinky<'a> {
+impl<'a> Entity for Blinky<'a> {
-    fn base(&self) -> &crate::entity::StaticEntity {
+    fn base(&self) -> &StaticEntity {
         self.ghost.base.base()
     }
 }
 
-impl<'a> crate::entity::Renderable for Blinky<'a> {
+impl<'a> Renderable for Blinky<'a> {
     fn render(&self, canvas: &mut Canvas<Window>) {
         self.ghost.render(canvas);
     }
 }
 
-impl<'a> crate::entity::Moving for Blinky<'a> {
+impl<'a> Moving for Blinky<'a> {
     fn move_forward(&mut self) {
         self.ghost.move_forward();
     }
     fn update_cell_position(&mut self) {
         self.ghost.update_cell_position();
     }
-    fn next_cell(&self, direction: Option<crate::direction::Direction>) -> (i32, i32) {
+    fn next_cell(&self, direction: Option<Direction>) -> (i32, i32) {
         self.ghost.next_cell(direction)
     }
-    fn is_wall_ahead(&self, direction: Option<crate::direction::Direction>) -> bool {
+    fn is_wall_ahead(&self, direction: Option<Direction>) -> bool {
         self.ghost.is_wall_ahead(direction)
     }
     fn handle_tunnel(&mut self) -> bool {
@@ -82,7 +81,7 @@ impl<'a> crate::entity::Moving for Blinky<'a> {
     fn is_grid_aligned(&self) -> bool {
         self.ghost.is_grid_aligned()
     }
-    fn set_direction_if_valid(&mut self, new_direction: crate::direction::Direction) -> bool {
+    fn set_direction_if_valid(&mut self, new_direction: Direction) -> bool {
         self.ghost.set_direction_if_valid(new_direction)
     }
 }

src/helper.rs

@@ -13,16 +13,11 @@
 pub fn is_adjacent(a: (u32, u32), b: (u32, u32), diagonal: bool) -> bool {
     let (ax, ay) = a;
     let (bx, by) = b;
-
+    let dx = ax.abs_diff(bx);
-    // Calculate absolute differences between coordinates
+    let dy = ay.abs_diff(by);
-    let dx = if ax > bx { ax - bx } else { bx - ax };
-    let dy = if ay > by { ay - by } else { by - ay };
-
     if diagonal {
-        // For diagonal adjacency: both differences must be ≤ 1 and at least one > 0
+        dx <= 1 && dy <= 1 && (dx != 0 || dy != 0)
-        dx <= 1 && dy <= 1 && (dx + dy) > 0
     } else {
-        // For orthogonal adjacency: exactly one difference must be 1, the other 0
         (dx == 1 && dy == 0) || (dx == 0 && dy == 1)
     }
 }

src/main.rs

@@ -11,7 +11,7 @@ use tracing_subscriber::layer::SubscriberExt;
 
 #[cfg(windows)]
 use winapi::{
-    shared::{ntdef::NULL, windef::HWND},
+    shared::ntdef::NULL,
     um::{
         fileapi::{CreateFileA, OPEN_EXISTING},
         handleapi::INVALID_HANDLE_VALUE,
@@ -29,13 +29,13 @@ use winapi::{
 /// terminal, this function does nothing.
 #[cfg(windows)]
 unsafe fn attach_console() {
-    if GetConsoleWindow() != std::ptr::null_mut() as HWND {
+    if !std::ptr::eq(GetConsoleWindow(), std::ptr::null_mut()) {
         return;
     }
 
     if AttachConsole(winapi::um::wincon::ATTACH_PARENT_PROCESS) != 0 {
         let handle = CreateFileA(
-            "CONOUT$\0".as_ptr() as *const i8,
+            c"CONOUT$".as_ptr(),
             GENERIC_READ | GENERIC_WRITE,
             FILE_SHARE_READ | FILE_SHARE_WRITE,
             std::ptr::null_mut(),
@@ -55,7 +55,9 @@ unsafe fn attach_console() {
 mod animation;
 mod audio;
 mod constants;
+mod debug;
 mod direction;
+mod edible;
 mod entity;
 mod game;
 mod ghost;
@@ -64,8 +66,7 @@ mod helper;
 mod map;
 mod modulation;
 mod pacman;
-mod debug;
+mod asset;
-mod edible;
 
 /// The main entry point of the application.
 ///

src/map.rs

@@ -3,6 +3,7 @@ use rand::seq::IteratorRandom;
 
 use crate::constants::{MapTile, BOARD_OFFSET, CELL_SIZE};
 use crate::constants::{BOARD_HEIGHT, BOARD_WIDTH};
+use once_cell::sync::OnceCell;
 use std::collections::{HashSet, VecDeque};
 use std::ops::Add;
 
@@ -66,20 +67,8 @@ impl Map {
     pub fn new(raw_board: [&str; BOARD_HEIGHT as usize]) -> Map {
         let mut map = [[MapTile::Empty; BOARD_HEIGHT as usize]; BOARD_WIDTH as usize];
 
-        for y in 0..BOARD_HEIGHT as usize {
+        for (y, line) in raw_board.iter().enumerate().take(BOARD_HEIGHT as usize) {
-            let line = raw_board[y];
+            for (x, character) in line.chars().enumerate().take(BOARD_WIDTH as usize) {
-
-            for x in 0..BOARD_WIDTH as usize {
-                if x >= line.len() {
-                    break;
-                }
-
-                let i = (y * (BOARD_WIDTH as usize) + x) as usize;
-                let character = line
-                    .chars()
-                    .nth(x as usize)
-                    .unwrap_or_else(|| panic!("Could not get character at {} = ({}, {})", i, x, y));
-
                 let tile = match character {
                     '#' => MapTile::Wall,
                     '.' => MapTile::Pellet,
@@ -90,25 +79,29 @@ impl Map {
                         MapTile::StartingPosition(c.to_digit(10).unwrap() as u8)
                     }
                     '=' => MapTile::Empty,
-                    _ => panic!("Unknown character in board: {}", character),
+                    _ => panic!("Unknown character in board: {character}"),
                 };
-
+                map[x][y] = tile;
-                map[x as usize][y as usize] = tile;
             }
         }
 
         Map {
             current: map,
-            default: map.clone(),
+            default: map,
         }
     }
 
     /// Resets the map to its original state.
     pub fn reset(&mut self) {
         // Restore the map to its original state
-        for x in 0..BOARD_WIDTH as usize {
+        for (x, col) in self
-            for y in 0..BOARD_HEIGHT as usize {
+            .current
-                self.current[x][y] = self.default[x][y];
+            .iter_mut()
+            .enumerate()
+            .take(BOARD_WIDTH as usize)
+        {
+            for (y, cell) in col.iter_mut().enumerate().take(BOARD_HEIGHT as usize) {
+                *cell = self.default[x][y];
             }
         }
     }
@@ -163,19 +156,19 @@ impl Map {
     /// This is computed once using a flood fill from a random pellet, and then cached.
     pub fn get_valid_playable_positions(&mut self) -> &Vec<Position> {
         use MapTile::*;
-        static mut CACHE: Option<Vec<Position>> = None;
+        static CACHE: OnceCell<Vec<Position>> = OnceCell::new();
-        // SAFETY: This is only mutated once, and only in this function.
+        if let Some(cached) = CACHE.get() {
-        unsafe {
-            if let Some(ref cached) = CACHE {
             return cached;
         }
-        }
         // Find a random starting pellet
         let mut pellet_positions = vec![];
-        for x in 0..BOARD_WIDTH as u32 {
+        for (x, col) in self.current.iter().enumerate().take(BOARD_WIDTH as usize) {
-            for y in 0..BOARD_HEIGHT as u32 {
+            for (y, &cell) in col.iter().enumerate().take(BOARD_HEIGHT as usize) {
-                match self.current[x as usize][y as usize] {
+                match cell {
-                    Pellet | PowerPellet => pellet_positions.push(Position { x, y }),
+                    Pellet | PowerPellet => pellet_positions.push(Position {
+                        x: x as u32,
+                        y: y as u32,
+                    }),
                     _ => {}
                 }
             }
@@ -191,15 +184,12 @@ impl Map {
 
         queue.push_back(start);
         while let Some(pos) = queue.pop_front() {
-            // Mark visited, skip if already visited
             if !visited.insert(pos) {
                 continue;
             }
 
-            // Check if the current tile is valid
             match self.current[pos.x as usize][pos.y as usize] {
                 Empty | Pellet | PowerPellet => {
-                    // Valid, continue flood
                     for offset in [
                         SignedPosition { x: -1, y: 0 },
                         SignedPosition { x: 1, y: 0 },
@@ -207,7 +197,7 @@ impl Map {
                         SignedPosition { x: 0, y: 1 },
                     ] {
                         let neighbor = pos + offset;
-                        if neighbor.x < BOARD_WIDTH as u32 && neighbor.y < BOARD_HEIGHT as u32 {
+                        if neighbor.x < BOARD_WIDTH && neighbor.y < BOARD_HEIGHT {
                             let neighbor_tile =
                                 self.current[neighbor.x as usize][neighbor.y as usize];
                             if matches!(neighbor_tile, Empty | Pellet | PowerPellet) {
@@ -216,16 +206,11 @@ impl Map {
                         }
                     }
                 }
-                StartingPosition(_) | Wall | Tunnel => {
+                StartingPosition(_) | Wall | Tunnel => {}
-                    // Not valid, do not continue
-                }
             }
         }
         let mut result: Vec<Position> = visited.into_iter().collect();
         result.sort_unstable();
-        unsafe {
+        CACHE.get_or_init(|| result)
-            CACHE = Some(result);
-            CACHE.as_ref().unwrap()
-        }
     }
 }

src/pacman.rs

@@ -6,7 +6,6 @@ use sdl2::{
     render::{Canvas, Texture},
     video::Window,
 };
-use tracing::event;
 
 use crate::{
     animation::{AnimatedAtlasTexture, FrameDrawn},