fix: audio and other subsystems being dropped in App::new(), use Box::leak to ensure static ownership

Bumps the dependencies group with 1 update: [actions/checkout](https://github.com/actions/checkout).


Updates `actions/checkout` from 4 to 5
- [Release notes](https://github.com/actions/checkout/releases)
- [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md)
- [Commits](https://github.com/actions/checkout/compare/v4...v5)

---
updated-dependencies:
- dependency-name: actions/checkout
  dependency-version: '5'
  dependency-type: direct:production
  update-type: version-update:semver-major
  dependency-group: dependencies
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

.github/workflows/build.yaml

@@ -30,7 +30,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
 
       - name: Setup Rust Toolchain
         uses: dtolnay/rust-toolchain@master
@@ -64,15 +64,16 @@ jobs:
         run: cargo build --release
 
       - name: Acquire Package Version
-        shell: bash
+        id: get_version
+        shell: bash # required to prevent Windows runners from failing
         run: |
-          PACKAGE_VERSION=$(cargo metadata --format-version 1 --no-deps | jq '.packages[0].version' -r)
+          set -euo pipefail # exit on error
-          echo "PACKAGE_VERSION=${PACKAGE_VERSION}" >> $GITHUB_ENV
+          echo "version=$(cargo metadata --format-version 1 --no-deps | jq '.packages[0].version' -r)" >> $GITHUB_OUTPUT
 
       - name: Upload Artifact
         uses: actions/upload-artifact@v4
         with:
-          name: "pacman-${{ env.PACKAGE_VERSION }}-${{ matrix.target }}"
+          name: "pacman-${{ steps.get_version.outputs.version }}-${{ matrix.target }}"
           path: ./target/release/${{ matrix.artifact_name }}
           retention-days: 7
           if-no-files-found: error
@@ -83,10 +84,13 @@ jobs:
     permissions:
       pages: write
       id-token: write
+    # concurrency group is used to prevent multiple page deployments from being attempted at the same time
+    concurrency:
+      group: ${{ github.workflow }}-wasm
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
 
       - name: Setup Emscripten SDK
         uses: pyodide/setup-emsdk@v15
@@ -98,7 +102,7 @@ jobs:
         uses: dtolnay/rust-toolchain@master
         with:
           target: wasm32-unknown-emscripten
-          toolchain: 1.86.0 # we are unfortunately pinned to 1.86.0 for some reason, bulk-memory-opt related issues
+          toolchain: 1.86.0
 
       - name: Rust Cache
         uses: Swatinem/rust-cache@v2

.github/workflows/coverage.yaml

@@ -11,7 +11,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
 
       - name: Install Rust toolchain
         uses: dtolnay/rust-toolchain@master

.github/workflows/tests.yaml

@@ -12,7 +12,7 @@ jobs:
 
     steps:
       - name: Checkout code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
 
       - name: Install Rust toolchain
         uses: dtolnay/rust-toolchain@master

.gitignore

@@ -5,3 +5,4 @@ emsdk/
 rust-sdl2-emscripten/
 assets/site/build.css
 tailwindcss-*
+lcov.info

Cargo.lock

@@ -13,9 +13,9 @@ dependencies = [
 
 [[package]]
 name = "anyhow"
-version = "1.0.98"
+version = "1.0.99"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e16d2d3311acee920a9eb8d33b8cbc1787ce4a264e85f964c2404b969bdcd487"
+checksum = "b0674a1ddeecb70197781e945de4b3b8ffb61fa939a5597bcf48503737663100"
 
 [[package]]
 name = "autocfg"
@@ -79,9 +79,9 @@ dependencies = [
 
 [[package]]
 name = "glam"
-version = "0.30.4"
+version = "0.30.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "50a99dbe56b72736564cfa4b85bf9a33079f16ae8b74983ab06af3b1a3696b11"
+checksum = "f2d1aab06663bdce00d6ca5e5ed586ec8d18033a771906c993a1e3755b368d85"
 
 [[package]]
 name = "hashbrown"
@@ -89,6 +89,12 @@ version = "0.15.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5971ac85611da7067dbfcabef3c70ebb5606018acd9e2a3903a0da507521e0d5"
 
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
 [[package]]
 name = "indexmap"
 version = "2.10.0"
@@ -122,9 +128,9 @@ checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
 
 [[package]]
 name = "libc"
-version = "0.2.174"
+version = "0.2.175"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1171693293099992e19cddea4e8b849964e9846f4acee11b3948bcc337be8776"
+checksum = "6a82ae493e598baaea5209805c49bbf2ea7de956d50d7da0da1164f9c6d28543"
 
 [[package]]
 name = "log"
@@ -194,7 +200,9 @@ dependencies = [
  "serde_json",
  "smallvec",
  "spin_sleep",
- "thiserror 1.0.69",
+ "strum",
+ "strum_macros",
+ "thiserror",
  "tracing",
  "tracing-error",
  "tracing-subscriber",
@@ -212,7 +220,7 @@ dependencies = [
  "integer-sqrt",
  "num-traits",
  "rustc-hash",
- "thiserror 2.0.12",
+ "thiserror",
 ]
 
 [[package]]
@@ -372,9 +380,9 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.141"
+version = "1.0.142"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "30b9eff21ebe718216c6ec64e1d9ac57087aad11efc64e32002bce4a0d4c03d3"
+checksum = "030fedb782600dcbd6f02d479bf0d817ac3bb40d644745b769d6a96bc3afc5a7"
 dependencies = [
  "itoa",
  "memchr",
@@ -406,6 +414,24 @@ dependencies = [
  "windows-sys",
 ]
 
+[[package]]
+name = "strum"
+version = "0.27.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af23d6f6c1a224baef9d3f61e287d2761385a5b88fdab4eb4c6f11aeb54c4bcf"
+
+[[package]]
+name = "strum_macros"
+version = "0.27.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7695ce3845ea4b33927c055a39dc438a45b059f7c1b3d91d38d10355fb8cbca7"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "syn"
 version = "2.0.104"
@@ -417,33 +443,13 @@ 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 2.0.12",
+ "thiserror-impl",
-]
-
-[[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

@@ -15,12 +15,14 @@ spin_sleep = "1.3.2"
 rand = { version = "0.9.2", default-features = false, features = ["small_rng", "os_rng"] }
 pathfinding = "4.14"
 once_cell = "1.21.3"
-thiserror = "1.0"
+thiserror = "2.0"
 anyhow = "1.0"
-glam = { version = "0.30.4", features = [] }
+glam = { version = "0.30.5", features = [] }
 serde = { version = "1.0.219", features = ["derive"] }
-serde_json = "1.0.141"
+serde_json = "1.0.142"
 smallvec = "1.15.1"
+strum = "0.27.2"
+strum_macros = "0.27.2"
 
 [profile.release]
 lto = true
@@ -54,4 +56,4 @@ x86_64-apple-darwin = { triplet = "x64-osx" }
 aarch64-apple-darwin = { triplet = "arm64-osx" }
 
 [target.'cfg(target_os = "emscripten")'.dependencies]
-libc = "0.2.16"
+libc = "0.2.175"

README.md

@@ -72,6 +72,8 @@ I wanted to hit a log of goals and features, making it a 'perfect' project that
 
 Since this project is still in progress, I'm only going to cover non-obvious build details. By reading the code, build scripts, and copying the online build workflows, you should be able to replicate the build process.
 
+- We use rustc 1.86.0 for the build, due to bulk-memory-opt related issues on wasm32-unknown-emscripten.
+  - Technically, we could probably use stable or even nightly on desktop targets, but using different versions for different targets is a pain, mainly because of clippy warnings changing between versions.
 - Install `cargo-vcpkg` with `cargo install cargo-vcpkg`, then run `cargo vcpkg build` to build the requisite dependencies via vcpkg.
 - For the WASM build, you need to have the Emscripten SDK cloned; you can do so with `git clone https://github.com/emscripten-core/emsdk.git`
   - The first time you clone, you'll need to install the appropriate SDK version with `./emsdk install 3.1.43` and then activate it with `./emsdk activate 3.1.43`. On Windows, use `./emsdk/emsdk.ps1` instead.

rust-toolchain.toml

@@ -1,2 +1,4 @@
 [toolchain]
+# we are unfortunately pinned to 1.86.0 for some reason, bulk-memory-opt related issues on wasm32-unknown-emscripten
 channel = "1.86.0"
+components = ["rustfmt", "llvm-tools-preview", "clippy"]

src/app.rs

@@ -4,8 +4,9 @@ use glam::Vec2;
 use sdl2::event::{Event, WindowEvent};
 use sdl2::keyboard::Keycode;
 use sdl2::render::{Canvas, ScaleMode, Texture, TextureCreator};
+use sdl2::ttf::Sdl2TtfContext;
 use sdl2::video::{Window, WindowContext};
-use sdl2::EventPump;
+use sdl2::{AudioSubsystem, EventPump, Sdl, VideoSubsystem};
 use tracing::{error, event};
 
 use crate::error::{GameError, GameResult};
@@ -14,26 +15,31 @@ use crate::constants::{CANVAS_SIZE, LOOP_TIME, SCALE};
 use crate::game::Game;
 use crate::platform::get_platform;
 
-pub struct App<'a> {
+pub struct App {
     game: Game,
     canvas: Canvas<Window>,
-    event_pump: EventPump,
+    event_pump: &'static mut EventPump,
-    backbuffer: Texture<'a>,
+    backbuffer: Texture<'static>,
     paused: bool,
     last_tick: Instant,
     cursor_pos: Vec2,
 }
 
-impl App<'_> {
+impl App {
     pub fn new() -> GameResult<Self> {
+        let sdl_context: &'static Sdl = Box::leak(Box::new(sdl2::init().map_err(|e| GameError::Sdl(e.to_string()))?));
+        let video_subsystem: &'static VideoSubsystem =
+            Box::leak(Box::new(sdl_context.video().map_err(|e| GameError::Sdl(e.to_string()))?));
+        let audio_subsystem: &'static AudioSubsystem =
+            Box::leak(Box::new(sdl_context.audio().map_err(|e| GameError::Sdl(e.to_string()))?));
+        let ttf_context: &'static Sdl2TtfContext =
+            Box::leak(Box::new(sdl2::ttf::init().map_err(|e| GameError::Sdl(e.to_string()))?));
+        let event_pump: &'static mut EventPump =
+            Box::leak(Box::new(sdl_context.event_pump().map_err(|e| GameError::Sdl(e.to_string()))?));
+
         // Initialize platform-specific console
         get_platform().init_console()?;
 
-        let sdl_context = sdl2::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()))?;
-        let ttf_context = sdl2::ttf::init().map_err(|e| GameError::Sdl(e.to_string()))?;
-
         let window = video_subsystem
             .window(
                 "Pac-Man",
@@ -50,18 +56,16 @@ impl App<'_> {
             .set_logical_size(CANVAS_SIZE.x, CANVAS_SIZE.y)
             .map_err(|e| GameError::Sdl(e.to_string()))?;
 
-        let texture_creator_static: &'static TextureCreator<WindowContext> = Box::leak(Box::new(canvas.texture_creator()));
+        let texture_creator: &'static TextureCreator<WindowContext> = Box::leak(Box::new(canvas.texture_creator()));
 
-        let mut game = Game::new(texture_creator_static, &ttf_context, &audio_subsystem)?;
+        let mut game = Game::new(texture_creator, ttf_context, audio_subsystem)?;
-        game.audio.set_mute(cfg!(debug_assertions));
+        // game.audio.set_mute(cfg!(debug_assertions));
 
-        let mut backbuffer = texture_creator_static
+        let mut backbuffer = texture_creator
             .create_texture_target(None, CANVAS_SIZE.x, CANVAS_SIZE.y)
             .map_err(|e| GameError::Sdl(e.to_string()))?;
         backbuffer.set_scale_mode(ScaleMode::Nearest);
 
-        let event_pump = sdl_context.event_pump().map_err(|e| GameError::Sdl(e.to_string()))?;
-
         // Initial draw
         game.draw(&mut canvas, &mut backbuffer)
             .map_err(|e| GameError::Sdl(e.to_string()))?;

src/entity/item.rs

@@ -5,6 +5,7 @@ use crate::{
     texture::sprite::{Sprite, SpriteAtlas},
 };
 use sdl2::render::{Canvas, RenderTarget};
+use strum_macros::{EnumCount, EnumIter};
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum ItemType {
@@ -26,7 +27,7 @@ impl ItemType {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, EnumIter, EnumCount)]
 #[allow(dead_code)]
 pub enum FruitKind {
     Apple,
@@ -39,6 +40,19 @@ pub enum FruitKind {
 }
 
 impl FruitKind {
+    #[allow(dead_code)]
+    pub fn index(self) -> u8 {
+        match self {
+            FruitKind::Apple => 0,
+            FruitKind::Strawberry => 1,
+            FruitKind::Orange => 2,
+            FruitKind::Melon => 3,
+            FruitKind::Bell => 4,
+            FruitKind::Key => 5,
+            FruitKind::Galaxian => 6,
+        }
+    }
+
     pub fn get_score(self) -> u32 {
         match self {
             FruitKind::Apple => 100,

src/game.rs

@@ -25,7 +25,7 @@ use crate::{
     },
     map::Map,
     texture::{
-        sprite::{self, AtlasMapper, AtlasTile, SpriteAtlas},
+        sprite::{AtlasMapper, AtlasTile, SpriteAtlas},
         text::TextTexture,
     },
 };
@@ -59,7 +59,7 @@ pub struct Game {
 
 impl Game {
     pub fn new(
-        texture_creator: &TextureCreator<WindowContext>,
+        texture_creator: &'static TextureCreator<WindowContext>,
         _ttf_context: &sdl2::ttf::Sdl2TtfContext,
         _audio_subsystem: &sdl2::AudioSubsystem,
     ) -> GameResult<Game> {
@@ -74,19 +74,16 @@ impl Game {
             .ok_or_else(|| GameError::NotFound("Pac-Man starting position not found in graph".to_string()))?;
 
         let atlas_bytes = get_asset_bytes(Asset::Atlas)?;
-        let atlas_texture = unsafe {
+        let atlas_texture = Box::leak(Box::new(texture_creator.load_texture_bytes(&atlas_bytes).map_err(|e| {
-            let texture = texture_creator.load_texture_bytes(&atlas_bytes).map_err(|e| {
+            if e.to_string().contains("format") || e.to_string().contains("unsupported") {
-                if e.to_string().contains("format") || e.to_string().contains("unsupported") {
+                GameError::Texture(TextureError::InvalidFormat(format!("Unsupported texture format: {e}")))
-                    GameError::Texture(TextureError::InvalidFormat(format!("Unsupported texture format: {e}")))
+            } else {
-                } else {
+                GameError::Texture(TextureError::LoadFailed(e.to_string()))
-                    GameError::Texture(TextureError::LoadFailed(e.to_string()))
+            }
-                }
+        })?));
-            })?;
-            sprite::texture_to_static(texture)
-        };
         let atlas_json = get_asset_bytes(Asset::AtlasJson)?;
         let atlas_mapper: AtlasMapper = serde_json::from_slice(&atlas_json)?;
-        let atlas = SpriteAtlas::new(atlas_texture, atlas_mapper);
+        let atlas = SpriteAtlas::new(unsafe { std::mem::transmute_copy(atlas_texture) }, atlas_mapper);
 
         let mut map_texture = SpriteAtlas::get_tile(&atlas, "maze/full.png")
             .ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("maze/full.png".to_string())))?;
@@ -255,6 +252,7 @@ impl Game {
                     if !item.is_collected() {
                         item.collect();
                         self.score += item.get_score();
+                        self.audio.eat();
 
                         // Handle energizer effects
                         if matches!(item.item_type, crate::entity::item::ItemType::Energizer) {

src/texture/sprite.rs

@@ -138,20 +138,3 @@ impl SpriteAtlas {
         self.default_color
     }
 }
-
-/// Converts a `Texture` to a `Texture<'static>` using transmute.
-///
-/// # Safety
-///
-/// This function is unsafe because it uses `std::mem::transmute` to change the lifetime
-/// of the texture from the original lifetime to `'static`. The caller must ensure that:
-///
-/// - The original `Texture` will live for the entire duration of the program
-/// - No references to the original texture exist that could become invalid
-/// - The texture is not dropped while still being used as a `'static` reference
-///
-/// This is typically used when you have a texture that you know will live for the entire
-/// program duration and need to store it in a structure that requires a `'static` lifetime.
-pub unsafe fn texture_to_static(texture: Texture) -> Texture<'static> {
-    std::mem::transmute(texture)
-}

tests/collision.rs

@@ -0,0 +1,119 @@
+use pacman::entity::collision::{Collidable, CollisionSystem};
+use pacman::entity::traversal::Position;
+
+struct MockCollidable {
+    pos: Position,
+}
+
+impl Collidable for MockCollidable {
+    fn position(&self) -> Position {
+        self.pos
+    }
+}
+
+#[test]
+fn test_is_colliding_with() {
+    let entity1 = MockCollidable {
+        pos: Position::AtNode(1),
+    };
+    let entity2 = MockCollidable {
+        pos: Position::AtNode(1),
+    };
+    let entity3 = MockCollidable {
+        pos: Position::AtNode(2),
+    };
+    let entity4 = MockCollidable {
+        pos: Position::BetweenNodes {
+            from: 1,
+            to: 2,
+            traversed: 0.5,
+        },
+    };
+
+    assert!(entity1.is_colliding_with(&entity2));
+    assert!(!entity1.is_colliding_with(&entity3));
+    assert!(entity1.is_colliding_with(&entity4));
+    assert!(entity3.is_colliding_with(&entity4));
+}
+
+#[test]
+fn test_collision_system_register_and_query() {
+    let mut collision_system = CollisionSystem::default();
+
+    let pos1 = Position::AtNode(1);
+    let entity1 = collision_system.register_entity(pos1);
+
+    let pos2 = Position::BetweenNodes {
+        from: 1,
+        to: 2,
+        traversed: 0.5,
+    };
+    let entity2 = collision_system.register_entity(pos2);
+
+    let pos3 = Position::AtNode(3);
+    let entity3 = collision_system.register_entity(pos3);
+
+    // Test entities_at_node
+    assert_eq!(collision_system.entities_at_node(1), &[entity1, entity2]);
+    assert_eq!(collision_system.entities_at_node(2), &[entity2]);
+    assert_eq!(collision_system.entities_at_node(3), &[entity3]);
+    assert_eq!(collision_system.entities_at_node(4), &[] as &[u32]);
+
+    // Test potential_collisions
+    let mut collisions1 = collision_system.potential_collisions(&pos1);
+    collisions1.sort_unstable();
+    assert_eq!(collisions1, vec![entity1, entity2]);
+
+    let mut collisions2 = collision_system.potential_collisions(&pos2);
+    collisions2.sort_unstable();
+    assert_eq!(collisions2, vec![entity1, entity2]);
+
+    let mut collisions3 = collision_system.potential_collisions(&pos3);
+    collisions3.sort_unstable();
+    assert_eq!(collisions3, vec![entity3]);
+}
+
+#[test]
+fn test_collision_system_update() {
+    let mut collision_system = CollisionSystem::default();
+
+    let entity1 = collision_system.register_entity(Position::AtNode(1));
+
+    assert_eq!(collision_system.entities_at_node(1), &[entity1]);
+    assert_eq!(collision_system.entities_at_node(2), &[] as &[u32]);
+
+    collision_system.update_position(entity1, Position::AtNode(2));
+
+    assert_eq!(collision_system.entities_at_node(1), &[] as &[u32]);
+    assert_eq!(collision_system.entities_at_node(2), &[entity1]);
+
+    collision_system.update_position(
+        entity1,
+        Position::BetweenNodes {
+            from: 2,
+            to: 3,
+            traversed: 0.1,
+        },
+    );
+
+    assert_eq!(collision_system.entities_at_node(1), &[] as &[u32]);
+    assert_eq!(collision_system.entities_at_node(2), &[entity1]);
+    assert_eq!(collision_system.entities_at_node(3), &[entity1]);
+}
+
+#[test]
+fn test_collision_system_remove() {
+    let mut collision_system = CollisionSystem::default();
+
+    let entity1 = collision_system.register_entity(Position::AtNode(1));
+    let entity2 = collision_system.register_entity(Position::AtNode(1));
+
+    assert_eq!(collision_system.entities_at_node(1), &[entity1, entity2]);
+
+    collision_system.remove_entity(entity1);
+
+    assert_eq!(collision_system.entities_at_node(1), &[entity2]);
+
+    collision_system.remove_entity(entity2);
+    assert_eq!(collision_system.entities_at_node(1), &[] as &[u32]);
+}

tests/directional.rs

@@ -52,3 +52,26 @@ fn test_directional_texture_all_directions() {
         assert!(texture.has_direction(*direction));
     }
 }
+
+#[test]
+fn test_directional_texture_stopped() {
+    let mut stopped_textures = [None, None, None, None];
+    stopped_textures[Direction::Up.as_usize()] = Some(mock_animated_texture(1));
+
+    let texture = DirectionalAnimatedTexture::new([None, None, None, None], stopped_textures);
+
+    assert_eq!(texture.stopped_texture_count(), 1);
+    assert!(texture.has_stopped_direction(Direction::Up));
+    assert!(!texture.has_stopped_direction(Direction::Down));
+}
+
+#[test]
+fn test_directional_texture_tick() {
+    let mut textures = [None, None, None, None];
+    textures[Direction::Up.as_usize()] = Some(mock_animated_texture(1));
+    let mut texture = DirectionalAnimatedTexture::new(textures, [None, None, None, None]);
+
+    // This is a bit of a placeholder, since we can't inspect the inner state easily.
+    // We're just ensuring the tick method runs without panicking.
+    texture.tick(0.1);
+}

tests/game.rs

@@ -1,6 +1,9 @@
 use pacman::constants::RAW_BOARD;
 use pacman::map::Map;
 
+mod collision;
+mod item;
+
 #[test]
 fn test_game_map_creation() {
     let map = Map::new(RAW_BOARD).unwrap();

tests/item.rs

@@ -0,0 +1,53 @@
+use glam::U16Vec2;
+use pacman::{
+    entity::{
+        collision::Collidable,
+        item::{FruitKind, Item, ItemType},
+    },
+    texture::sprite::{AtlasTile, Sprite},
+};
+use strum::{EnumCount, IntoEnumIterator};
+
+#[test]
+fn test_item_type_get_score() {
+    assert_eq!(ItemType::Pellet.get_score(), 10);
+    assert_eq!(ItemType::Energizer.get_score(), 50);
+
+    let fruit = ItemType::Fruit { kind: FruitKind::Apple };
+    assert_eq!(fruit.get_score(), 100);
+}
+
+#[test]
+fn test_fruit_kind_increasing_score() {
+    // Build a list of fruit kinds, sorted by their index
+    let mut kinds = FruitKind::iter()
+        .map(|kind| (kind.index(), kind.get_score()))
+        .collect::<Vec<_>>();
+    kinds.sort_unstable_by_key(|(index, _)| *index);
+
+    assert_eq!(kinds.len(), FruitKind::COUNT);
+
+    // Check that the score increases as expected
+    for window in kinds.windows(2) {
+        let ((_, prev), (_, next)) = (window[0], window[1]);
+        assert!(prev < next, "Fruits should have increasing scores, but {prev:?} < {next:?}");
+    }
+}
+
+#[test]
+fn test_item_creation_and_collection() {
+    let atlas_tile = AtlasTile {
+        pos: U16Vec2::new(0, 0),
+        size: U16Vec2::new(16, 16),
+        color: None,
+    };
+    let sprite = Sprite::new(atlas_tile);
+    let mut item = Item::new(0, ItemType::Pellet, sprite);
+
+    assert!(!item.is_collected());
+    assert_eq!(item.get_score(), 10);
+    assert_eq!(item.position().from_node_id(), 0);
+
+    item.collect();
+    assert!(item.is_collected());
+}

tests/map_builder.rs

@@ -1,47 +1,11 @@
 use glam::Vec2;
-use pacman::constants::{BOARD_CELL_SIZE, CELL_SIZE};
+use pacman::constants::{BOARD_CELL_SIZE, CELL_SIZE, RAW_BOARD};
 use pacman::map::Map;
-
+use sdl2::render::Texture;
-fn create_minimal_test_board() -> [&'static str; BOARD_CELL_SIZE.y as usize] {
-    let mut board = [""; BOARD_CELL_SIZE.y as usize];
-    board[0] = "############################";
-    board[1] = "#............##............#";
-    board[2] = "#.####.#####.##.#####.####.#";
-    board[3] = "#o####.#####.##.#####.####o#";
-    board[4] = "#.####.#####.##.#####.####.#";
-    board[5] = "#..........................#";
-    board[6] = "#.####.##.########.##.####.#";
-    board[7] = "#.####.##.########.##.####.#";
-    board[8] = "#......##....##....##......#";
-    board[9] = "######.##### ## #####.######";
-    board[10] = "     #.##### ## #####.#     ";
-    board[11] = "     #.##    ==    ##.#     ";
-    board[12] = "     #.## ######## ##.#     ";
-    board[13] = "######.## ######## ##.######";
-    board[14] = "T     .   ########   .     T";
-    board[15] = "######.## ######## ##.######";
-    board[16] = "     #.## ######## ##.#     ";
-    board[17] = "     #.##          ##.#     ";
-    board[18] = "     #.## ######## ##.#     ";
-    board[19] = "######.## ######## ##.######";
-    board[20] = "#............##............#";
-    board[21] = "#.####.#####.##.#####.####.#";
-    board[22] = "#.####.#####.##.#####.####.#";
-    board[23] = "#o..##.......X .......##..o#";
-    board[24] = "###.##.##.########.##.##.###";
-    board[25] = "###.##.##.########.##.##.###";
-    board[26] = "#......##....##....##......#";
-    board[27] = "#.##########.##.##########.#";
-    board[28] = "#.##########.##.##########.#";
-    board[29] = "#..........................#";
-    board[30] = "############################";
-    board
-}
 
 #[test]
 fn test_map_creation() {
-    let board = create_minimal_test_board();
+    let map = Map::new(RAW_BOARD).unwrap();
-    let map = Map::new(board).unwrap();
 
     assert!(map.graph.node_count() > 0);
     assert!(!map.grid_to_node.is_empty());
@@ -59,8 +23,7 @@ fn test_map_creation() {
 
 #[test]
 fn test_map_starting_positions() {
-    let board = create_minimal_test_board();
+    let map = Map::new(RAW_BOARD).unwrap();
-    let map = Map::new(board).unwrap();
 
     let pacman_pos = map.find_starting_position(0);
     assert!(pacman_pos.is_some());
@@ -73,8 +36,7 @@ fn test_map_starting_positions() {
 
 #[test]
 fn test_map_node_positions() {
-    let board = create_minimal_test_board();
+    let map = Map::new(RAW_BOARD).unwrap();
-    let map = Map::new(board).unwrap();
 
     for (grid_pos, &node_id) in &map.grid_to_node {
         let node = map.graph.get_node(node_id).unwrap();
@@ -84,3 +46,61 @@ fn test_map_node_positions() {
         assert_eq!(node.position, expected_pos);
     }
 }
+
+#[test]
+fn test_generate_items() {
+    use pacman::texture::sprite::{AtlasMapper, MapperFrame, SpriteAtlas};
+    use std::collections::HashMap;
+
+    let map = Map::new(RAW_BOARD).unwrap();
+
+    // Create a minimal atlas for testing
+    let mut frames = HashMap::new();
+    frames.insert(
+        "maze/pellet.png".to_string(),
+        MapperFrame {
+            x: 0,
+            y: 0,
+            width: 8,
+            height: 8,
+        },
+    );
+    frames.insert(
+        "maze/energizer.png".to_string(),
+        MapperFrame {
+            x: 8,
+            y: 0,
+            width: 8,
+            height: 8,
+        },
+    );
+
+    let mapper = AtlasMapper { frames };
+    let texture = unsafe { std::mem::transmute::<usize, Texture<'static>>(0usize) };
+    let atlas = SpriteAtlas::new(texture, mapper);
+
+    let items = map.generate_items(&atlas).unwrap();
+
+    // Verify we have items
+    assert!(!items.is_empty());
+
+    // Count different types
+    let pellet_count = items
+        .iter()
+        .filter(|item| matches!(item.item_type, pacman::entity::item::ItemType::Pellet))
+        .count();
+    let energizer_count = items
+        .iter()
+        .filter(|item| matches!(item.item_type, pacman::entity::item::ItemType::Energizer))
+        .count();
+
+    // Should have both types
+    assert_eq!(pellet_count, 240);
+    assert_eq!(energizer_count, 4);
+
+    // All items should be uncollected initially
+    assert!(items.iter().all(|item| !item.is_collected()));
+
+    // All items should have valid node indices
+    assert!(items.iter().all(|item| item.node_index < map.graph.node_count()));
+}

tests/sprite.rs

@@ -1,4 +1,5 @@
-use pacman::texture::sprite::{AtlasMapper, MapperFrame, SpriteAtlas};
+use glam::U16Vec2;
+use pacman::texture::sprite::{AtlasMapper, AtlasTile, MapperFrame, Sprite, SpriteAtlas};
 use sdl2::pixels::Color;
 use std::collections::HashMap;
 
@@ -76,3 +77,27 @@ fn test_sprite_atlas_color() {
     atlas.set_color(color);
     assert_eq!(atlas.default_color(), Some(color));
 }
+
+#[test]
+fn test_atlas_tile_new_and_with_color() {
+    let pos = U16Vec2::new(10, 20);
+    let size = U16Vec2::new(30, 40);
+    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);
+
+    let tile_with_color = tile.with_color(color);
+    assert_eq!(tile_with_color.color, Some(color));
+}
+
+#[test]
+fn test_sprite_new() {
+    let atlas_tile = AtlasTile::new(U16Vec2::new(0, 0), U16Vec2::new(16, 16), None);
+    let sprite = Sprite::new(atlas_tile);
+
+    assert_eq!(sprite.atlas_tile.pos, atlas_tile.pos);
+    assert_eq!(sprite.atlas_tile.size, atlas_tile.size);
+}