feat: fullscreen toggle key

- Spawn HUD elements as Renderables with simple change-based entity updates
- Updated rendering systems to accommodate new precise pixel positioning for life sprites.

.cargo/config.toml

@@ -7,6 +7,8 @@ rustflags = [
 ]
 runner = "node"
 
+# despite being semantically identical to `target_os = "linux"`, the `cfg(linux)` syntax is not supported here. Who knows why...
+# https://github.com/Xevion/Pac-Man/actions/runs/17596477856
 [target.'cfg(target_os = "linux")']
 rustflags = [
     # Manually link zlib.

.config/nextest.toml

@@ -3,3 +3,10 @@ fail-fast = false
 
 [profile.coverage]
 status-level = "none"
+
+[[profile.default.overrides]]
+filter = 'test(pacman::game::)'
+test-group = 'serial'
+
+[test-groups]
+serial = { max-threads = 1 }

.gitattributes

@@ -1 +1,2 @@
 * text=auto eol=lf
+scripts/* linguist-detectable=false

.github/workflows/checks.yaml

@@ -0,0 +1,53 @@
+name: Checks
+
+on: ["push", "pull_request"]
+
+env:
+  CARGO_TERM_COLOR: always
+  RUST_TOOLCHAIN: 1.86.0
+
+jobs:
+  checks:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v5
+
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: ${{ env.RUST_TOOLCHAIN }}
+          components: clippy, rustfmt
+
+      - name: Rust Cache
+        uses: Swatinem/rust-cache@v2
+
+      - name: Cache vcpkg
+        uses: actions/cache@v4
+        with:
+          path: target/vcpkg
+          key: A-vcpkg-${{ runner.os }}-${{ hashFiles('Cargo.toml', 'Cargo.lock') }}
+          restore-keys: |
+            A-vcpkg-${{ runner.os }}-
+
+      - name: Vcpkg Linux Dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libltdl-dev
+
+      - name: Vcpkg
+        run: |
+          cargo install cargo-vcpkg
+          cargo vcpkg -v build
+
+      - name: Run clippy
+        run: cargo clippy -- -D warnings
+
+      - name: Check formatting
+        run: cargo fmt -- --check
+
+      - uses: taiki-e/install-action@cargo-audit
+
+      - name: Run security audit
+        run: cargo audit

.github/workflows/coverage.yaml

@@ -4,13 +4,11 @@ on: ["push", "pull_request"]
 
 env:
   CARGO_TERM_COLOR: always
-  RUST_TOOLCHAIN: 1.86.0
+  RUST_TOOLCHAIN: nightly
 
 jobs:
   coverage:
     runs-on: ubuntu-latest
-    env:
-      COVERALLS_REPO_TOKEN: ${{ secrets.COVERALLS_REPO_TOKEN }}
     steps:
       - name: Checkout code
         uses: actions/checkout@v5
@@ -50,33 +48,9 @@ jobs:
         run: |
           just coverage
 
-      - name: Download Coveralls CLI
-        if: ${{ env.COVERALLS_REPO_TOKEN != '' }}
-        run: |
-          # use GitHub Releases URL instead of coveralls.io because they can't maintain their own files; it 404s
-          curl -L https://github.com/coverallsapp/coverage-reporter/releases/download/v0.6.15/coveralls-linux-x86_64.tar.gz | tar -xz -C /usr/local/bin
-
-      - name: Upload coverage to Coveralls
-        if: ${{ env.COVERALLS_REPO_TOKEN != '' }}
-        run: |
-          if [ ! -f "lcov.info" ]; then
-            echo "Error: lcov.info file not found. Coverage generation may have failed."
-            exit 1
-          fi
-
-          for i in {1..10}; do
-            echo "Attempt $i: Uploading coverage to Coveralls..."
-            if coveralls -n report lcov.info; then
-              echo "Successfully uploaded coverage report."
-              exit 0
-            fi
-
-            if [ $i -lt 10 ]; then
-              delay=$((2**i))
-              echo "Attempt $i failed. Retrying in $delay seconds..."
-              sleep $delay
-            fi
-          done
-
-          echo "Failed to upload coverage report after 10 attempts."
-          exit 1
+      - name: Coveralls upload
+        uses: coverallsapp/github-action@v2
+        with:
+          github-token: ${{ secrets.COVERALLS_REPO_TOKEN }}
+          path-to-lcov: lcov.info
+          debug: true

.github/workflows/tests.yaml

@@ -1,4 +1,4 @@
-name: Tests & Checks
+name: Tests
 
 on: ["push", "pull_request"]
 
@@ -18,7 +18,6 @@ jobs:
         uses: dtolnay/rust-toolchain@master
         with:
           toolchain: ${{ env.RUST_TOOLCHAIN }}
-          components: clippy, rustfmt
 
       - name: Rust Cache
         uses: Swatinem/rust-cache@v2
@@ -45,14 +44,3 @@ jobs:
 
       - name: Run nextest
         run: cargo nextest run --workspace
-
-      - name: Run clippy
-        run: cargo clippy -- -D warnings
-
-      - name: Check formatting
-        run: cargo fmt -- --check
-
-      - uses: taiki-e/install-action@cargo-audit
-
-      - name: Run security audit
-        run: cargo audit

.gitignore

@@ -14,6 +14,7 @@ assets/site/build.css
 
 # Coverage reports
 lcov.info
+codecov.json
 coverage.html
 
 # Profiling output

.pre-commit-config.yaml

@@ -12,6 +12,13 @@ repos:
       - id: forbid-submodules
       - id: mixed-line-ending
 
+  - repo: https://github.com/compilerla/conventional-pre-commit
+    rev: v4.2.0
+    hooks:
+      - id: conventional-pre-commit
+        stages: [commit-msg]
+        args: []
+
   - repo: local
     hooks:
       - id: cargo-fmt
@@ -20,12 +27,14 @@ repos:
         language: system
         types: [rust]
         pass_filenames: false
+
       - id: cargo-check
         name: cargo check
         entry: cargo check --all-targets
         language: system
         types_or: [rust, cargo, cargo-lock]
         pass_filenames: false
+
       - id: cargo-check-wasm
         name: cargo check for wasm32-unknown-emscripten
         entry: cargo check --all-targets --target=wasm32-unknown-emscripten

Cargo.lock

@@ -228,6 +228,15 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
 [[package]]
 name = "bumpalo"
 version = "3.19.0"
@@ -268,6 +277,15 @@ dependencies = [
  "portable-atomic",
 ]
 
+[[package]]
+name = "cpufeatures"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "critical-section"
 version = "1.2.0"
@@ -289,6 +307,16 @@ version = "0.8.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
 
+[[package]]
+name = "crypto-common"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
 [[package]]
 name = "deprecate-until"
 version = "0.1.1"
@@ -337,6 +365,16 @@ version = "0.1.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "56254986775e3233ffa9c4d7d3faaf6d36a2c09d30b20687e9f88bc8bafc16c8"
 
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "crypto-common",
+]
+
 [[package]]
 name = "disqualified"
 version = "1.0.0"
@@ -408,6 +446,16 @@ dependencies = [
  "pin-project-lite",
 ]
 
+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
 [[package]]
 name = "getrandom"
 version = "0.3.3"
@@ -663,7 +711,7 @@ checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
 
 [[package]]
 name = "pacman"
-version = "0.2.0"
+version = "0.80.1"
 dependencies = [
  "anyhow",
  "bevy_ecs",
@@ -678,6 +726,7 @@ dependencies = [
  "phf",
  "pretty_assertions",
  "rand",
+ "rust-embed",
  "sdl2",
  "serde",
  "serde_json",
@@ -693,7 +742,7 @@ dependencies = [
  "tracing-error",
  "tracing-subscriber",
  "windows",
- "windows-sys 0.60.2",
+ "windows-sys 0.61.0",
 ]
 
 [[package]]
@@ -722,7 +771,7 @@ dependencies = [
  "libc",
  "redox_syscall",
  "smallvec",
- "windows-targets 0.52.6",
+ "windows-targets",
 ]
 
 [[package]]
@@ -907,6 +956,40 @@ version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
 
+[[package]]
+name = "rust-embed"
+version = "8.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "025908b8682a26ba8d12f6f2d66b987584a4a87bc024abc5bbc12553a8cd178a"
+dependencies = [
+ "rust-embed-impl",
+ "rust-embed-utils",
+ "walkdir",
+]
+
+[[package]]
+name = "rust-embed-impl"
+version = "8.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6065f1a4392b71819ec1ea1df1120673418bf386f50de1d6f54204d836d4349c"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "rust-embed-utils",
+ "syn",
+ "walkdir",
+]
+
+[[package]]
+name = "rust-embed-utils"
+version = "8.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6cc0c81648b20b70c491ff8cce00c1c3b223bb8ed2b5d41f0e54c6c4c0a3594"
+dependencies = [
+ "sha2",
+ "walkdir",
+]
+
 [[package]]
 name = "rustc-hash"
 version = "2.1.1"
@@ -925,6 +1008,15 @@ version = "1.0.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "28d3b2b1366ec20994f1fd18c3c594f05c5dd4bc44d8bb0c1c632c8d6829481f"
 
+[[package]]
+name = "same-file"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
+dependencies = [
+ "winapi-util",
+]
+
 [[package]]
 name = "scopeguard"
 version = "1.2.0"
@@ -994,6 +1086,17 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "sha2"
+version = "0.10.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
 [[package]]
 name = "sharded-slab"
 version = "0.1.4"
@@ -1051,11 +1154,11 @@ dependencies = [
 
 [[package]]
 name = "spin_sleep"
-version = "1.3.2"
+version = "1.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "14ac0e4b54d028c2000a13895bcd84cd02a1d63c4f78e08e4ec5ec8f53efd4b9"
+checksum = "9c07347b7c0301b9adba4350bdcf09c039d0e7160922050db0439b3c6723c8ab"
 dependencies = [
- "windows-sys 0.60.2",
+ "windows-sys 0.61.0",
 ]
 
 [[package]]
@@ -1253,6 +1356,12 @@ version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bc7d623258602320d5c55d1bc22793b57daff0ec7efc270ea7d55ce1d5f5471c"
 
+[[package]]
+name = "typenum"
+version = "1.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1dccffe3ce07af9386bfd29e80c0ab1a8205a2fc34e4bcd40364df902cfa8f3f"
+
 [[package]]
 name = "unicode-ident"
 version = "1.0.11"
@@ -1306,6 +1415,22 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "579a42fc0b8e0c63b76519a339be31bed574929511fa53c1a3acae26eb258f29"
 
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "walkdir"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b"
+dependencies = [
+ "same-file",
+ "winapi-util",
+]
+
 [[package]]
 name = "wasi"
 version = "0.14.2+wasi-0.2.4"
@@ -1397,10 +1522,19 @@ dependencies = [
 ]
 
 [[package]]
-name = "windows"
-version = "0.61.3"
+name = "winapi-util"
+version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9babd3a767a4c1aef6900409f85f5d53ce2544ccdfaa86dad48c91782c6d6893"
+checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
+dependencies = [
+ "windows-sys 0.61.0",
+]
+
+[[package]]
+name = "windows"
+version = "0.62.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9579d0e6970fd5250aa29aba5994052385ff55cf7b28a059e484bb79ea842e42"
 dependencies = [
  "windows-collections",
  "windows-core",
@@ -1411,18 +1545,18 @@ dependencies = [
 
 [[package]]
 name = "windows-collections"
-version = "0.2.0"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3beeceb5e5cfd9eb1d76b381630e82c4241ccd0d27f1a39ed41b2760b255c5e8"
+checksum = "a90dd7a7b86859ec4cdf864658b311545ef19dbcf17a672b52ab7cefe80c336f"
 dependencies = [
  "windows-core",
 ]
 
 [[package]]
 name = "windows-core"
-version = "0.61.2"
+version = "0.62.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0fdd3ddb90610c7638aa2b3a3ab2904fb9e5cdbecc643ddb3647212781c4ae3"
+checksum = "57fe7168f7de578d2d8a05b07fd61870d2e73b4020e9f49aa00da8471723497c"
 dependencies = [
  "windows-implement",
  "windows-interface",
@@ -1433,9 +1567,9 @@ dependencies = [
 
 [[package]]
 name = "windows-future"
-version = "0.2.1"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc6a41e98427b19fe4b73c550f060b59fa592d7d686537eebf9385621bfbad8e"
+checksum = "b2194dee901458cb79e1148a4e9aac2b164cc95fa431891e7b296ff0b2f1d8a6"
 dependencies = [
  "windows-core",
  "windows-link",
@@ -1466,15 +1600,15 @@ dependencies = [
 
 [[package]]
 name = "windows-link"
-version = "0.1.3"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e6ad25900d524eaabdbbb96d20b4311e1e7ae1699af4fb28c17ae66c80d798a"
+checksum = "45e46c0661abb7180e7b9c281db115305d49ca1709ab8242adf09666d2173c65"
 
 [[package]]
 name = "windows-numerics"
-version = "0.2.0"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9150af68066c4c5c07ddc0ce30421554771e528bde427614c61038bc2c92c2b1"
+checksum = "2ce3498fe0aba81e62e477408383196b4b0363db5e0c27646f932676283b43d8"
 dependencies = [
  "windows-core",
  "windows-link",
@@ -1482,18 +1616,18 @@ dependencies = [
 
 [[package]]
 name = "windows-result"
-version = "0.3.4"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56f42bd332cc6c8eac5af113fc0c1fd6a8fd2aa08a0119358686e5160d0586c6"
+checksum = "7084dcc306f89883455a206237404d3eaf961e5bd7e0f312f7c91f57eb44167f"
 dependencies = [
  "windows-link",
 ]
 
 [[package]]
 name = "windows-strings"
-version = "0.4.2"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56e6c93f3a0c3b36176cb1327a4958a0353d5d166c2a35cb268ace15e91d3b57"
+checksum = "7218c655a553b0bed4426cf54b20d7ba363ef543b52d515b3e48d7fd55318dda"
 dependencies = [
  "windows-link",
 ]
@@ -1504,16 +1638,16 @@ version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
 dependencies = [
- "windows-targets 0.52.6",
+ "windows-targets",
 ]
 
 [[package]]
 name = "windows-sys"
-version = "0.60.2"
+version = "0.61.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb"
+checksum = "e201184e40b2ede64bc2ea34968b28e33622acdbbf37104f0e4a33f7abe657aa"
 dependencies = [
- "windows-targets 0.53.2",
+ "windows-link",
 ]
 
 [[package]]
@@ -1522,37 +1656,21 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
 dependencies = [
- "windows_aarch64_gnullvm 0.52.6",
- "windows_aarch64_msvc 0.52.6",
- "windows_i686_gnu 0.52.6",
- "windows_i686_gnullvm 0.52.6",
- "windows_i686_msvc 0.52.6",
- "windows_x86_64_gnu 0.52.6",
- "windows_x86_64_gnullvm 0.52.6",
- "windows_x86_64_msvc 0.52.6",
-]
-
-[[package]]
-name = "windows-targets"
-version = "0.53.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c66f69fcc9ce11da9966ddb31a40968cad001c5bedeb5c2b82ede4253ab48aef"
-dependencies = [
- "windows_aarch64_gnullvm 0.53.0",
- "windows_aarch64_msvc 0.53.0",
- "windows_i686_gnu 0.53.0",
- "windows_i686_gnullvm 0.53.0",
- "windows_i686_msvc 0.53.0",
- "windows_x86_64_gnu 0.53.0",
- "windows_x86_64_gnullvm 0.53.0",
- "windows_x86_64_msvc 0.53.0",
+ "windows_aarch64_gnullvm",
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_gnullvm",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
+ "windows_x86_64_gnullvm",
+ "windows_x86_64_msvc",
 ]
 
 [[package]]
 name = "windows-threading"
-version = "0.1.0"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b66463ad2e0ea3bbf808b7f1d371311c80e115c0b71d60efc142cafbcfb057a6"
+checksum = "ab47f085ad6932defa48855254c758cdd0e2f2d48e62a34118a268d8f345e118"
 dependencies = [
  "windows-link",
 ]
@@ -1563,96 +1681,48 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
 
-[[package]]
-name = "windows_aarch64_gnullvm"
-version = "0.53.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "86b8d5f90ddd19cb4a147a5fa63ca848db3df085e25fee3cc10b39b6eebae764"
-
 [[package]]
 name = "windows_aarch64_msvc"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
 
-[[package]]
-name = "windows_aarch64_msvc"
-version = "0.53.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c7651a1f62a11b8cbd5e0d42526e55f2c99886c77e007179efff86c2b137e66c"
-
 [[package]]
 name = "windows_i686_gnu"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
 
-[[package]]
-name = "windows_i686_gnu"
-version = "0.53.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c1dc67659d35f387f5f6c479dc4e28f1d4bb90ddd1a5d3da2e5d97b42d6272c3"
-
 [[package]]
 name = "windows_i686_gnullvm"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
 
-[[package]]
-name = "windows_i686_gnullvm"
-version = "0.53.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ce6ccbdedbf6d6354471319e781c0dfef054c81fbc7cf83f338a4296c0cae11"
-
 [[package]]
 name = "windows_i686_msvc"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
 
-[[package]]
-name = "windows_i686_msvc"
-version = "0.53.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "581fee95406bb13382d2f65cd4a908ca7b1e4c2f1917f143ba16efe98a589b5d"
-
 [[package]]
 name = "windows_x86_64_gnu"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
 
-[[package]]
-name = "windows_x86_64_gnu"
-version = "0.53.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2e55b5ac9ea33f2fc1716d1742db15574fd6fc8dadc51caab1c16a3d3b4190ba"
-
 [[package]]
 name = "windows_x86_64_gnullvm"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
 
-[[package]]
-name = "windows_x86_64_gnullvm"
-version = "0.53.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0a6e035dd0599267ce1ee132e51c27dd29437f63325753051e71dd9e42406c57"
-
 [[package]]
 name = "windows_x86_64_msvc"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
 
-[[package]]
-name = "windows_x86_64_msvc"
-version = "0.53.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "271414315aff87387382ec3d271b52d7ae78726f5d44ac98b4f4030c91880486"
-
 [[package]]
 name = "winnow"
 version = "0.7.12"

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "pacman"
-version = "0.2.0"
+version = "0.80.1"
 authors = ["Xevion"]
 edition = "2021"
 rust-version = "1.86.0"
@@ -21,7 +21,7 @@ default-run = "pacman"
 bevy_ecs = "0.16.1"
 glam = "0.30.5"
 pathfinding = "4.14"
-tracing = { version = "0.1.41", features = ["max_level_debug", "release_max_level_debug"]}
+tracing = { version = "0.1.41", features = ["max_level_trace", "release_max_level_debug"]}
 tracing-error = "0.2.0"
 tracing-subscriber = {version = "0.3.20", features = ["env-filter"]}
 time = { version = "0.3.43", features = ["formatting", "macros"] }
@@ -40,17 +40,18 @@ num-width = "0.1.0"
 phf = { version = "0.13.1", features = ["macros"] }
 
 # Windows-specific dependencies
-[target.'cfg(target_os = "windows")'.dependencies]
+[target.'cfg(windows)'.dependencies]
 # Used for customizing console output on Windows; both are required due to the `windows` crate having poor Result handling with `GetStdHandle`.
-windows = { version = "0.61.3", features = ["Win32_Security", "Win32_Storage_FileSystem", "Win32_System_Console"] }
-windows-sys = { version = "0.60.2", features = ["Win32_System_Console"] }
+windows = { version = "0.62.0", features = ["Win32_Security", "Win32_Storage_FileSystem", "Win32_System_Console"] }
+windows-sys = { version = "0.61.0", features = ["Win32_System_Console"] }
 
 # Desktop-specific dependencies
 [target.'cfg(not(target_os = "emscripten"))'.dependencies]
 # On desktop platforms, build SDL2 with cargo-vcpkg
 sdl2 = { version = "0.38", default-features = false, features = ["image", "ttf", "gfx", "mixer", "unsafe_textures", "static-link", "use-vcpkg"] }
 rand = { version = "0.9.2", default-features = false, features = ["thread_rng"] }
-spin_sleep = "1.3.2"
+rust-embed = "8.7.2"
+spin_sleep = "1.3.3"
 
 # Browser-specific dependencies
 [target.'cfg(target_os = "emscripten")'.dependencies]
@@ -98,3 +99,6 @@ x86_64-pc-windows-msvc = { triplet = "x64-windows-static-md" }
 x86_64-unknown-linux-gnu = { triplet = "x64-linux" }
 x86_64-apple-darwin = { triplet = "x64-osx" }
 aarch64-apple-darwin = { triplet = "arm64-osx" }
+
+[lints.rust]
+unexpected_cfgs = { level = "warn", check-cfg = ['cfg(coverage,coverage_nightly)'] }

Justfile

@@ -1,9 +1,6 @@
 set shell := ["bash", "-c"]
 set windows-shell := ["powershell.exe", "-NoLogo", "-Command"]
 
-# Regex to exclude files from coverage report, double escapes for Justfile + CLI
-# You can use src\\\\..., but the filename alone is acceptable too
-coverage_exclude_pattern := "src\\\\app\\.rs|audio\\.rs|src\\\\error\\.rs|platform\\\\emscripten\\.rs|bin\\\\.+\\.rs|main\\.rs|platform\\\\desktop\\.rs|platform\\\\tracing_buffer\\.rs|platform\\\\buffered_writer\\.rs|systems\\\\debug\\.rs|systems\\\\profiling\\.rs"
 
 binary_extension := if os() == "windows" { ".exe" } else { "" }
 
@@ -14,22 +11,19 @@ binary_extension := if os() == "windows" { ".exe" } else { "" }
 html: coverage
     cargo llvm-cov report \
     --remap-path-prefix \
-    --ignore-filename-regex "{{ coverage_exclude_pattern }}" \
     --html \
     --open
 
 # Display report (for humans)
 report-coverage: coverage
-    cargo llvm-cov report \
-    --remap-path-prefix \
-    --ignore-filename-regex "{{ coverage_exclude_pattern }}"
+    cargo llvm-cov report --remap-path-prefix
 
-# Run & generate report (for CI)
+# Run & generate LCOV report (as base report)
 coverage:
-    cargo llvm-cov \
+    cargo +nightly llvm-cov \
     --lcov \
     --remap-path-prefix \
-    --ignore-filename-regex "{{ coverage_exclude_pattern }}" \
+    --workspace \
     --output-path lcov.info \
     --profile coverage \
     --no-fail-fast nextest
@@ -43,3 +37,8 @@ samply:
 web *args:
     bun run web.build.ts {{args}};
     caddy file-server --root dist
+
+# Run cargo fix
+fix:
+    cargo fix --workspace --lib --allow-dirty
+    cargo fmt --all

README.md

@@ -1,80 +1,94 @@
+<!-- markdownlint-disable MD033 -->
+<!-- markdownlint-disable MD041 -->
+
+<div align="center">
+  <img src="assets/repo/banner.png" alt="Pac-Man Banner Screenshot">
+</div>
+
 # Pac-Man
 
-[![Tests Status][badge-test]][test] [![Build Status][badge-build]][build] [![If you're seeing this, Coveralls.io is broken again and it's not my fault.][badge-coverage]][coverage] [![Online Demo][badge-online-demo]][demo] [![Last Commit][badge-last-commit]][commits]
+[![A project just for fun, no really!][badge-justforfunnoreally]][justforfunnoreally] ![Built with Rust][badge-built-with-rust] [![Build Status][badge-build]][build] [![Tests Status][badge-test]][test] [![Checks Status][badge-checks]][checks] [![If you're seeing this, Coveralls.io is broken again and it's not my fault.][badge-coverage]][coverage] [![Online Demo][badge-online-demo]][demo]
 
+[badge-built-with-rust]: https://img.shields.io/badge/Built_with-Rust-blue?logo=rust
+[badge-justforfunnoreally]: https://img.shields.io/badge/justforfunnoreally-dev-9ff
 [badge-test]: https://github.com/Xevion/Pac-Man/actions/workflows/tests.yaml/badge.svg
+[badge-checks]: https://github.com/Xevion/Pac-Man/actions/workflows/checks.yaml/badge.svg
 [badge-build]: https://github.com/Xevion/Pac-Man/actions/workflows/build.yaml/badge.svg
 [badge-coverage]: https://coveralls.io/repos/github/Xevion/Pac-Man/badge.svg?branch=master
-[badge-demo]: https://img.shields.io/github/deployments/Xevion/Pac-Man/github-pages?label=GitHub%20Pages
-[badge-online-demo]: https://img.shields.io/badge/GitHub%20Pages-Demo-brightgreen
-[badge-last-commit]: https://img.shields.io/github/last-commit/Xevion/Pac-Man
+[badge-online-demo]: https://img.shields.io/badge/Online%20Demo-Click%20Me!-brightgreen
+[justforfunnoreally]: https://justforfunnoreally.dev
 [build]: https://github.com/Xevion/Pac-Man/actions/workflows/build.yaml
 [test]: https://github.com/Xevion/Pac-Man/actions/workflows/tests.yaml
+[checks]: https://github.com/Xevion/Pac-Man/actions/workflows/checks.yaml
 [coverage]: https://coveralls.io/github/Xevion/Pac-Man?branch=master
 [demo]: https://xevion.github.io/Pac-Man/
-[commits]: https://github.com/Xevion/Pac-Man/commits/master
 
-A faithful recreation of the classic Pac-Man arcade game written in Rust. This project aims to replicate the original game's mechanics, graphics, sound, and behavior as accurately as possible while providing modern development features like cross-platform compatibility and WebAssembly support.
+A faithful recreation of the classic Pac-Man arcade game, written in Rust.
+
+This project aims to replicate the original game's mechanics, graphics, sound, and behavior as accurately as possible while providing modern development features like cross-platform compatibility and WebAssembly support.
 
 The game includes all the original features you'd expect from Pac-Man:
 
-- [x] Classic maze navigation and dot collection
+- [x] Classic maze navigation with tunnels and dot collection
 - [ ] Four ghosts with their unique AI behaviors (Blinky, Pinky, Inky, and Clyde)
-- [ ] Power pellets that allow Pac-Man to eat ghosts
-- [ ] Fruit bonuses that appear periodically
+- [x] Power pellets that allow Pac-Man to eat ghosts
+- [x] Fruit bonuses that appear periodically
 - [ ] Progressive difficulty with faster ghosts and shorter power pellet duration
 - [x] Authentic sound effects and sprites
 
-This cross-platform implementation is built with SDL2 for graphics, audio, and input handling. It can run on Windows, Linux, macOS, and in web browsers via WebAssembly.
+This cross-platform implementation is built with SDL2 for graphics, audio, and input handling. It can run on Windows, Linux, macOS, even web browsers via WebAssembly.
+
+## Quick Start
+
+The easiest way to play is to visit the [online demo][demo]. It is more or less identical to the desktop experience at this time.
+
+While I do plan to have desktop builds released automatically, the game is still a work in progress, and I'm not quite ready to start uploading releases.
+
+However, every commit has build artifacts, so you can grab the [latest build artifacts][build-workflow] if available.
+
+## Screenshots
+
+<div align="center">
+  <img src="assets/repo/screenshots/0.png" alt="Screenshot 0 - Starting Game">
+  <p><em>Starting a new game</em></p>
+
+  <img src="assets/repo/screenshots/1.png" alt="Screenshot 1 - Eating Dots">
+  <p><em>Pac-Man collecting dots and avoiding ghosts</em></p>
+
+  <img src="assets/repo/screenshots/2.png" alt="Screenshot 2 - Game Over">
+  <p><em>Game over screen after losing all lives</em></p>
+
+  <img src="assets/repo/screenshots/3.png" alt="Screenshot 3 - Debug Mode">
+  <p><em>Debug mode showing hitboxes, node graph, and performance details.</em></p>
+</div>
 
 ## Why?
 
-Just because. And because I wanted to learn more about Rust, inter-operability with C, and compiling to WebAssembly.
+[Just for fun.][justforfunnoreally] And because I wanted to learn more about Rust, inter-operability with C, and compiling to WebAssembly.
 
-I was inspired by a certain code review video on YouTube; [SOME UNIQUE C++ CODE // Pacman Clone Code Review](https://www.youtube.com/watch?v=OKs_JewEeOo) by The Cherno.
+Originally, I was inspired by a certain code review video on YouTube; [SOME UNIQUE C++ CODE // Pacman Clone Code Review](https://www.youtube.com/watch?v=OKs_JewEeOo). For some reason, I was inspired to try and replicate it in Rust, and it was uniquely challenging. It's not easy to integrate SDL2 with Rust, and even harder to get it working with Emscripten.
 
-For some reason, I was inspired to try and replicate it in Rust, and it was uniquely challenging.
+I wanted to hit a lot of goals and features, making it a 'perfect' project that I could be proud of.
 
-I wanted to hit a log of goals and features, making it a 'perfect' project that I could be proud of.
-
-- Near-perfect replication of logic, scoring, graphics, sound, and behaviors. No hacks, workarounds, or poor designs.
-- Written in Rust, buildable on Windows, Linux, Mac and WebAssembly. Statically linked, no runtime dependencies.
+- Near-perfect replication of logic, scoring, graphics, sound, and behaviors. No hacks, workarounds, or poor designs. Well documented, well-tested, and maintainable.
+- Written in Rust, buildable on Windows, Linux, Mac and WebAssembly. Statically linked, no runtime dependencies, automatically built with GitHub Actions.
 - Performant, low memory, CPU and GPU usage.
-- Online demo, playable in a browser.
-- Completely automatic build system with releases for all platforms.
-- Well documented, well-tested, and maintainable.
+- Online demo, playable in a browser, built automatically with GitHub Actions.
 
-## Experimental Ideas
+If you're curious about the journey of this project, you can read the [story](STORY.md) file. Eventually, I will be using this as the basis for some sort of blog post or more official page, but for now, I'm keeping it within the repository as a simple file.
 
-- Debug tooling
-  - Game state visualization
-  - Game speed controls + pausing
-  - Log tracing
-  - Performance details
-- Customized Themes & Colors
-  - Color-blind friendly
-- Perfected Ghost Algorithms
-- More than 4 ghosts
-- Custom Level Generation
-  - Multi-map tunnelling
-- Online Scoreboard
-  - An online axum server with a simple database and OAuth2 authentication.
-  - Integrates with GitHub, Discord, and Google OAuth2 to acquire an email identifier & avatar.
-    - Avatars are optional for score submission and can be disabled, instead using a blank avatar.
-    - Avatars are downscaled to a low resolution pixellated image to maintain the 8-bit aesthetic.
-    - A custom name is used for the score submission, which is checked for potential abusive language.
-      - A max length of 14 characters, and a min length of 3 characters.
-      - Names are checked for potential abusive language via an external API.
-  - The client implementation should require zero configuration, environment variables, or special secrets.
-    - It simply defaults to the pacman server API, or can be overriden manually.
+## Roadmap
+
+You can read the [roadmap](ROADMAP.md) file for more details on the project's goals and future plans.
 
 ## Build Notes
 
 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.
 
+- Install `cargo-vcpkg` with `cargo install cargo-vcpkg`, then run `cargo vcpkg build` to build the requisite dependencies via vcpkg.
+  - This is only required for the desktop builds, not the web build.
 - 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.
     - I'm still not sure _why_ 3.1.43 is required, but it is. Perhaps in the future I will attempt to use a more modern version.
@@ -87,3 +101,18 @@ Since this project is still in progress, I'm only going to cover non-obvious bui
     - `caddy file-server --root dist` (install with `[sudo apt|brew|choco] install caddy` or [a dozen other ways](https://caddyserver.com/docs/install))
 - `web.build.ts` auto installs dependencies, but you may need to pass `-i` or `--install=fallback|force` to install missing packages. My guess is that if you have some packages installed, it won't install any missing ones. If you have no packages installed, it will install all of them.
   - If you want to have TypeScript resolution for development, you can manually install the dependencies with `bun install` in the `assets/site` folder.
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a pull request or open an issue.
+
+- The code is not exactly stable or bulletproof, but it is functional and has a lot of tests.
+- I am not actively looking for contributors, but I will review pull requests and merge them if they are useful.
+- If you have any ideas, please feel free to submit an issue.
+- If you have any private issues, security concerns, or anything sensitive, you can email me at [xevion@xevion.dev](mailto:xevion@xevion.dev).
+
+## License
+
+This project is licensed under the GPLv3 license. See the [LICENSE](LICENSE) file for details.
+
+[build-workflow]: https://github.com/Xevion/Pac-Man/actions/workflows/build.yaml

ROADMAP.md

@@ -0,0 +1,164 @@
+# Roadmap
+
+A comprehensive list of features needed to complete the Pac-Man emulation, organized by priority and implementation complexity.
+
+## Core Game Features
+
+### Ghost AI & Behavior
+
+- [x] Core Ghost System Architecture
+  - [x] Ghost entity types (Blinky, Pinky, Inky, Clyde)
+  - [x] Ghost state management (Normal, Frightened, Eyes)
+  - [x] Ghost movement and pathfinding systems
+- [ ] Authentic Ghost AI Personalities
+  - [ ] Blinky (Red): Direct chase behavior
+  - [ ] Pinky (Pink): Target 4 tiles ahead of Pac-Man
+  - [ ] Inky (Cyan): Complex behavior based on Blinky's position
+  - [ ] Clyde (Orange): Chase when far, flee when close
+- [x] Mode Switching System
+  - [ ] Scatter/Chase pattern with proper timing
+  - [x] Frightened mode transitions
+  - [ ] Ghost house entry/exit mechanics
+- [x] Ghost House Behavior
+  - [x] Proper spawning sequence
+  - [ ] Exit timing and patterns
+  - [ ] House-specific movement rules
+
+### Fruit Bonus System
+
+- [x] Fruit Spawning Mechanics
+  - [x] Spawn at pellet counts 70 and 170
+  - [x] Fruit display in bottom-right corner
+  - [x] Fruit collection and scoring
+  - [x] Bonus point display system
+
+### Level Progression
+
+- [ ] Multiple Levels
+  - [ ] Level completion detection
+  - [ ] Progressive difficulty scaling
+  - [ ] Ghost speed increases per level
+  - [ ] Power pellet duration decreases
+- [ ] Intermission Screens
+  - [ ] Between-level cutscenes
+  - [ ] Proper graphics and timing
+
+### Audio System Completion
+
+- [x] Core Audio Infrastructure
+  - [x] Audio event system
+  - [x] Sound effect playback
+  - [x] Audio muting controls
+- [ ] Background Music
+  - [x] Intro jingle
+  - [ ] Continuous gameplay music
+  - [ ] Escalating siren based on remaining pellets
+  - [ ] Power pellet mode music
+  - [ ] Intermission music
+- [x] Sound Effects
+  - [x] Pellet eating sounds
+  - [x] Fruit collection sounds
+  - [x] Ghost eaten sounds
+  - [x] Pac-Man Death
+  - [ ] Ghost movement sounds
+  - [ ] Level completion fanfare
+
+### Game Mechanics
+
+- [ ] Bonus Lives
+  - [ ] Extra life at 10,000 points
+  - [x] Life counter display
+- [ ] High Score System
+  - [ ] High score tracking
+  - [x] High score display
+  - [ ] Score persistence
+
+## Secondary Features (Medium Priority)
+
+### Game Polish
+
+- [x] Core Input System
+  - [x] Keyboard controls
+  - [x] Direction buffering for responsive controls
+  - [x] Touch controls for mobile
+- [x] Pause System
+  - [x] Pause/unpause functionality
+  - [ ] Pause menu with options
+- [ ] Input System
+  - [ ] Input remapping
+  - [ ] Multiple input methods
+
+## Advanced Features (Lower Priority)
+
+### Difficulty Options
+
+- [ ] Easy/Normal/Hard modes
+- [ ] Customizable ghost speeds
+
+### Data Persistence
+
+- [ ] High Score Persistence
+  - [ ] Save high scores to file
+  - [ ] High score table display
+- [ ] Settings Storage
+  - [ ] Save user preferences
+  - [ ] Audio/visual settings
+- [ ] Statistics Tracking
+  - [ ] Game statistics
+  - [ ] Achievement system
+
+### Debug & Development Tools
+
+- [x] Performance details
+- [x] Core Debug Infrastructure
+  - [x] Debug mode toggle
+  - [x] Comprehensive game event logging
+  - [x] Performance profiling tools
+- [ ] Game State Visualization
+  - [ ] Ghost AI state display
+  - [ ] Pathfinding visualization
+  - [ ] Collision detection display
+- [ ] Game Speed Controls
+  - [ ] Variable game speed for testing
+  - [ ] Frame-by-frame stepping
+
+## Customization & Extensions
+
+### Visual Customization
+
+- [x] Core Rendering System
+  - [x] Sprite-based rendering
+  - [x] Layered rendering system
+  - [x] Animation system
+  - [x] HUD rendering
+- [ ] Display Options
+  - [ ] Fullscreen support
+  - [x] Window resizing
+    - [ ] Pause while resizing (SDL2 limitation mitigation)
+  - [ ] Multiple resolution support
+
+### Gameplay Extensions
+
+- [ ] Advanced Ghost AI
+  - [ ] Support for >4 ghosts
+  - [ ] Custom ghost behaviors
+- [ ] Level Generation
+  - [ ] Custom level creation
+  - [ ] Multi-map tunneling
+  - [ ] Level editor
+
+## Online Features (Future)
+
+### Scoreboard System
+
+- [ ] Backend Infrastructure
+  - [ ] Axum server with database
+  - [ ] OAuth2 authentication
+  - [ ] GitHub/Discord/Google auth
+- [ ] Profile Features
+  - [ ] Optional avatars (8-bit aesthetic)
+  - [ ] Custom names (3-14 chars, filtered)
+- [ ] Client Implementation
+  - [ ] Zero-config client
+  - [ ] Default API endpoint
+  - [ ] Manual override available

STORY.md

@@ -31,7 +31,7 @@ WebAssembly.
 The problem is that much of this work was done for pure-Rust applications - and SDL is C++.
 This requires a C++ WebAssembly compiler such as Emscripten; and it's a pain to get working.
 
-Luckily though, someone else has done this before, and they fully documented it - [RuggRouge][ruggrouge].
+Luckily though, someone else has done this before, and they fully documented it - [RuggRouge][ruggrogue].
 
 - Built with Rust
 - Uses SDL2
@@ -92,7 +92,7 @@ This was weird, and honestly, I'm confused as to why the 2-year old sample code
 
 After a bit of time, I noted that the `Instant` times were printing with only the whole seconds changing, and the nanoseconds were always 0.
 
-```
+```rust
 Instant { tv_sec: 0, tv_nsec: 0 }
 Instant { tv_sec: 1, tv_nsec: 0 }
 Instant { tv_sec: 2, tv_nsec: 0 }
@@ -357,7 +357,7 @@ Doing so required a full re-work of the animation and texture system, and I ende
 
 So, I ended up using `unsafe` to forcibly cast the lifetimes to `'static`, which was a bit of a gamble, but given that they essentially behave as `'static` in practice, there wasn't much risk as I see it. I might re-look into my understanding of lifetimes and this in the future, but for the time being, it's a good solution that makes the codebase far easier to work with.
 
-## Cross-platform Builds
+## Implementing Cross-platform Builds for Pac-Man
 
 Since the original `rust-sdl2-emscripten` demo project had cross-platform builds, I was ready to get it working for this project. For the most part, it wasn't hard, things tended to click into place, but unfortunately, the `emscripten` os target and somehow, the `linux` os target were both failing.
 
@@ -412,8 +412,8 @@ The bigger downside was that I had to toss out almost all the existing code for
 
 This ended up being okay though, as I was able to clean up a lot of gross code, and the system ended up being easier to work with by comparison.
 
-[code-review-video]: https://www.youtube.com/watch?v=OKs_JewEeOo
 [code-review-thumbnail]: https://img.youtube.com/vi/OKs_JewEeOo/hqdefault.jpg
+[code-review-video]: https://www.youtube.com/watch?v=OKs_JewEeOo
 [fighting-lifetimes-1]: https://devcry.heiho.net/html/2022/20220709-rust-and-sdl2-fighting-with-lifetimes.html
 [fighting-lifetimes-2]: https://devcry.heiho.net/html/2022/20220716-rust-and-sdl2-fighting-with-lifetimes-2.html
 [fighting-lifetimes-3]: https://devcry.heiho.net/html/2022/20220724-rust-and-sdl2-fighting-with-lifetimes-3.html

bacon.toml

@@ -28,16 +28,18 @@ need_stdout = false
 
 [jobs.test]
 command = [
-    "cargo", "nextest", "run",
-    "--hide-progress-bar", "--failure-output", "final"
+    "cargo",
+    "nextest",
+    "run",
+    "--hide-progress-bar",
+    "--failure-output",
+    "final",
 ]
 need_stdout = true
 analyzer = "nextest"
 
 [jobs.coverage]
-command = [
-    "just", "report-coverage"
-]
+command = ["just", "report-coverage"]
 need_stdout = true
 ignored_lines = [
     "info:",
@@ -54,7 +56,7 @@ ignored_lines = [
     "\\s*Finished.+in \\d+",
     "\\s*Summary\\s+\\[",
     "\\s*Blocking",
-    "Finished report saved to"
+    "Finished report saved to",
 ]
 on_change_strategy = "wait_then_restart"
 
@@ -66,21 +68,26 @@ need_stdout = false
 [jobs.doc-open]
 command = ["cargo", "doc", "--no-deps", "--open"]
 need_stdout = false
-on_success = "back" # so that we don't open the browser at each change
+on_success = "back"                               # so that we don't open the browser at each change
 
 [jobs.run]
-command = [
-    "cargo", "run",
-]
+command = ["cargo", "run"]
 need_stdout = true
 allow_warnings = true
 background = false
 on_change_strategy = "kill_then_restart"
 # kill = ["pkill", "-TERM", "-P"]'
 
+[jobs.precommit]
+command = ["pre-commit", "run", "--all-files"]
+need_stdout = true
+background = false
+on_change_strategy = "kill_then_restart"
+
 [keybindings]
 c = "job:clippy"
 alt-c = "job:check"
 ctrl-alt-c = "job:check-all"
 shift-c = "job:clippy-all"
 f = "job:coverage"
+p = "job:precommit"

src/app.rs

@@ -10,7 +10,7 @@ use crate::platform;
 use sdl2::pixels::PixelFormatEnum;
 use sdl2::render::RendererInfo;
 use sdl2::{AudioSubsystem, Sdl};
-use tracing::debug;
+use tracing::{debug, info, trace};
 
 /// Main application wrapper that manages SDL initialization, window lifecycle, and the game loop.
 pub struct App {
@@ -30,12 +30,20 @@ impl App {
     /// Returns `GameError::Sdl` if any SDL initialization step fails, or propagates
     /// errors from `Game::new()` during game state setup.
     pub fn new() -> GameResult<Self> {
+        info!("Initializing SDL2 application");
         let sdl_context = sdl2::init().map_err(|e| GameError::Sdl(e.to_string()))?;
+        debug!("Initializing SDL2 subsystems");
         let ttf_context = sdl2::ttf::init().map_err(|e| GameError::Sdl(e.to_string()))?;
         let video_subsystem = sdl_context.video().map_err(|e| GameError::Sdl(e.to_string()))?;
         let audio_subsystem = sdl_context.audio().map_err(|e| GameError::Sdl(e.to_string()))?;
         let event_pump = sdl_context.event_pump().map_err(|e| GameError::Sdl(e.to_string()))?;
 
+        trace!(
+            width = (CANVAS_SIZE.x as f32 * SCALE).round() as u32,
+            height = (CANVAS_SIZE.y as f32 * SCALE).round() as u32,
+            scale = SCALE,
+            "Creating game window"
+        );
         let window = video_subsystem
             .window(
                 "Pac-Man",
@@ -64,7 +72,7 @@ impl App {
         {
             let mut names = drivers.keys().collect::<Vec<_>>();
             names.sort_by_key(|k| get_driver(k));
-            debug!("Drivers: {names:?}")
+            trace!("Drivers: {names:?}")
         }
 
         // Count the number of times each pixel format is supported by each driver
@@ -76,11 +84,12 @@ impl App {
                 counts
             });
 
-        debug!("Pixel format counts: {pixel_format_counts:?}");
+        trace!(pixel_format_counts = ?pixel_format_counts, "Available pixel formats per driver");
 
         let index = get_driver("direct3d");
-        debug!("Driver index: {index:?}");
+        trace!(driver_index = ?index, "Selected graphics driver");
 
+        trace!("Creating hardware-accelerated canvas");
         let mut canvas = window
             .into_canvas()
             .accelerated()
@@ -88,15 +97,23 @@ impl App {
             .build()
             .map_err(|e| GameError::Sdl(e.to_string()))?;
 
+        trace!(
+            logical_width = CANVAS_SIZE.x,
+            logical_height = CANVAS_SIZE.y,
+            "Setting canvas logical size"
+        );
         canvas
             .set_logical_size(CANVAS_SIZE.x, CANVAS_SIZE.y)
             .map_err(|e| GameError::Sdl(e.to_string()))?;
-        debug!("Renderer: {:?}", canvas.info());
+        debug!(renderer_info = ?canvas.info(), "Canvas renderer initialized");
 
+        trace!("Creating texture factory");
         let texture_creator = canvas.texture_creator();
 
+        info!("Starting game initialization");
         let game = Game::new(canvas, ttf_context, texture_creator, event_pump)?;
 
+        info!("Application initialization completed successfully");
         Ok(App {
             game,
             focused: true,

src/asset.rs

@@ -1,24 +1,64 @@
-#![allow(dead_code)]
 //! 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 strum_macros::EnumIter;
+use std::iter;
+
+use crate::audio::Sound;
+use crate::error::AssetError;
 
 /// Enumeration of all game assets with cross-platform loading support.
 ///
 /// Each variant corresponds to a specific file that can be loaded either from
 /// binary-embedded data or embedded filesystem (Emscripten).
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, EnumIter)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum Asset {
-    Wav1,
-    Wav2,
-    Wav3,
-    Wav4,
     /// Main sprite atlas containing all game graphics (atlas.png)
     AtlasImage,
     /// Terminal Vector font for text rendering (TerminalVector.ttf)
     Font,
+    /// Sound file assets
+    SoundFile(Sound),
+}
+
+use strum::IntoEnumIterator;
+
+impl Asset {
+    #[allow(dead_code)]
+    pub fn into_iter() -> AssetIter {
+        AssetIter {
+            sound_iter: None,
+            state: 0,
+        }
+    }
+}
+
+#[allow(clippy::type_complexity)]
+pub struct AssetIter {
+    sound_iter: Option<iter::Map<<Sound as IntoEnumIterator>::Iterator, fn(Sound) -> Asset>>,
+    state: u8,
+}
+
+impl Iterator for AssetIter {
+    type Item = Asset;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        match self.state {
+            0 => {
+                self.state = 1;
+                Some(Asset::AtlasImage)
+            }
+            1 => {
+                self.state = 2;
+                Some(Asset::Font)
+            }
+            2 => self
+                .sound_iter
+                .get_or_insert_with(|| Sound::iter().map(Asset::SoundFile))
+                .next(),
+            _ => None,
+        }
+    }
 }
 
 impl Asset {
@@ -27,39 +67,71 @@ impl Asset {
     /// Paths are consistent across platforms and used by the Emscripten backend
     /// for filesystem loading. Desktop builds embed assets directly and don't
     /// use these paths at runtime.
-    #[allow(dead_code)]
     pub fn path(&self) -> &str {
         use Asset::*;
         match self {
-            Wav1 => "sound/waka/1.ogg",
-            Wav2 => "sound/waka/2.ogg",
-            Wav3 => "sound/waka/3.ogg",
-            Wav4 => "sound/waka/4.ogg",
+            SoundFile(Sound::Waka(0)) => "sound/pacman/waka/1.ogg",
+            SoundFile(Sound::Waka(1)) => "sound/pacman/waka/2.ogg",
+            SoundFile(Sound::Waka(2)) => "sound/pacman/waka/3.ogg",
+            SoundFile(Sound::Waka(3..=u8::MAX)) => "sound/pacman/waka/4.ogg",
+            SoundFile(Sound::PacmanDeath) => "sound/pacman/death.ogg",
+            SoundFile(Sound::ExtraLife) => "sound/pacman/extra_life.ogg",
+            SoundFile(Sound::Fruit) => "sound/pacman/fruit.ogg",
+            SoundFile(Sound::Ghost) => "sound/pacman/ghost.ogg",
+            SoundFile(Sound::Beginning) => "sound/begin.ogg",
+            SoundFile(Sound::Intermission) => "sound/intermission.ogg",
             AtlasImage => "atlas.png",
             Font => "TerminalVector.ttf",
         }
     }
-}
-
-mod imp {
-    use super::*;
-    use crate::error::AssetError;
-    use crate::platform;
 
     /// Loads asset bytes using the appropriate platform-specific method.
     ///
-    /// On desktop platforms, returns embedded compile-time data via `include_bytes!`.
+    /// On desktop platforms, returns embedded compile-time data via `rust-embed`.
     /// On Emscripten, loads from the filesystem using the asset's path. The returned
     /// `Cow` allows zero-copy access to embedded data while supporting owned data
     /// when loaded from disk.
     ///
     /// # Errors
     ///
-    /// Returns `AssetError::NotFound` if the asset file cannot be located (Emscripten only),
+    /// Returns `AssetError::NotFound` if the asset file cannot be located,
     /// or `AssetError::Io` for filesystem I/O failures.
-    pub fn get_asset_bytes(asset: Asset) -> Result<Cow<'static, [u8]>, AssetError> {
-        platform::get_asset_bytes(asset)
+    pub fn get_bytes(&self) -> Result<Cow<'static, [u8]>, AssetError> {
+        use tracing::trace;
+        trace!(asset = ?self, "Loading game asset");
+        let result = self.get_bytes_platform();
+        match &result {
+            Ok(bytes) => trace!(asset = ?self, size_bytes = bytes.len(), "Asset loaded successfully"),
+            Err(e) => trace!(asset = ?self, error = ?e, "Asset loading failed"),
+        }
+        result
+    }
+
+    #[cfg(not(target_os = "emscripten"))]
+    fn get_bytes_platform(&self) -> Result<Cow<'static, [u8]>, AssetError> {
+        #[derive(rust_embed::Embed)]
+        #[folder = "assets/game/"]
+        struct EmbeddedAssets;
+
+        let path = self.path();
+        EmbeddedAssets::get(path)
+            .map(|file| file.data)
+            .ok_or_else(|| AssetError::NotFound(path.to_string()))
+    }
+
+    #[cfg(target_os = "emscripten")]
+    fn get_bytes_platform(&self) -> Result<Cow<'static, [u8]>, AssetError> {
+        use sdl2::rwops::RWops;
+        use std::io::{self, Read};
+
+        let path = format!("assets/game/{}", self.path());
+        let mut rwops = RWops::from_file(&path, "rb").map_err(|_| AssetError::NotFound(self.path().to_string()))?;
+
+        let len = rwops.len().ok_or_else(|| AssetError::NotFound(self.path().to_string()))?;
+
+        let mut buf = vec![0u8; len];
+        rwops.read_exact(&mut buf).map_err(|e| AssetError::Io(io::Error::other(e)))?;
+
+        Ok(Cow::Owned(buf))
     }
 }
-
-pub use imp::get_asset_bytes;

src/audio.rs

@@ -1,22 +1,53 @@
 //! This module handles the audio playback for the game.
-use crate::asset::{get_asset_bytes, Asset};
+use std::collections::HashMap;
+
+use crate::asset::Asset;
 use sdl2::{
-    mixer::{self, Chunk, InitFlag, LoaderRWops, DEFAULT_FORMAT},
+    mixer::{self, Chunk, InitFlag, LoaderRWops, AUDIO_S16LSB, DEFAULT_CHANNELS},
     rwops::RWops,
 };
+use strum::IntoEnumIterator;
 
-const SOUND_ASSETS: [Asset; 4] = [Asset::Wav1, Asset::Wav2, Asset::Wav3, Asset::Wav4];
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum Sound {
+    Waka(u8),
+    PacmanDeath,
+    ExtraLife,
+    Fruit,
+    Ghost,
+    Beginning,
+    Intermission,
+}
+
+impl IntoEnumIterator for Sound {
+    type Iterator = std::vec::IntoIter<Sound>;
+
+    fn iter() -> Self::Iterator {
+        vec![
+            Sound::Waka(0),
+            Sound::Waka(1),
+            Sound::Waka(2),
+            Sound::Waka(3),
+            Sound::PacmanDeath,
+            Sound::ExtraLife,
+            Sound::Fruit,
+            Sound::Ghost,
+            Sound::Beginning,
+            Sound::Intermission,
+        ]
+        .into_iter()
+    }
+}
 
 /// The audio system for the game.
 ///
 /// This struct is responsible for initializing the audio device, loading sounds,
 /// and playing them. If audio fails to initialize, it will be disabled and all
 /// functions will silently do nothing.
-#[allow(dead_code)]
 pub struct Audio {
     _mixer_context: Option<mixer::Sdl2MixerContext>,
-    sounds: Vec<Chunk>,
-    next_sound_index: usize,
+    sounds: HashMap<Sound, Chunk>,
+    next_waka_index: u8,
     muted: bool,
     disabled: bool,
 }
@@ -33,24 +64,36 @@ impl Audio {
     /// If audio fails to initialize, the audio system will be disabled and
     /// all functions will silently do nothing.
     pub fn new() -> Self {
-        let frequency = 44100;
-        let format = DEFAULT_FORMAT;
-        let channels = 4;
-        let chunk_size = 256; // 256 is minimum for emscripten
+        let frequency = 16_000;
+        let format = AUDIO_S16LSB;
+        let chunk_size = {
+            // 256 is the minimum for Emscripten, but in practice 1024 is much more reliable
+            #[cfg(target_os = "emscripten")]
+            {
+                1024
+            }
+
+            // Otherwise, 256 is plenty safe.
+            #[cfg(not(target_os = "emscripten"))]
+            {
+                256
+            }
+        };
 
         // Try to open audio, but don't panic if it fails
-        if let Err(e) = mixer::open_audio(frequency, format, 1, chunk_size) {
+        if let Err(e) = mixer::open_audio(frequency, format, DEFAULT_CHANNELS, chunk_size) {
             tracing::warn!("Failed to open audio: {}. Audio will be disabled.", e);
             return Self {
                 _mixer_context: None,
-                sounds: Vec::new(),
-                next_sound_index: 0,
+                sounds: HashMap::new(),
+                next_waka_index: 0u8,
                 muted: false,
                 disabled: true,
             };
         }
 
-        mixer::allocate_channels(channels);
+        let channels = 4;
+        mixer::allocate_channels(4);
 
         // set channel volume
         for i in 0..channels {
@@ -64,8 +107,8 @@ impl Audio {
                 tracing::warn!("Failed to initialize SDL2_mixer: {}. Audio will be disabled.", e);
                 return Self {
                     _mixer_context: None,
-                    sounds: Vec::new(),
-                    next_sound_index: 0,
+                    sounds: HashMap::new(),
+                    next_waka_index: 0u8,
                     muted: false,
                     disabled: true,
                 };
@@ -73,12 +116,15 @@ impl Audio {
         };
 
         // Try to load sounds, but don't panic if any fail
-        let mut sounds = Vec::new();
-        for (i, asset) in SOUND_ASSETS.iter().enumerate() {
-            match get_asset_bytes(*asset) {
+        let mut sounds = HashMap::new();
+        for (i, sound_type) in Sound::iter().enumerate() {
+            let asset = Asset::SoundFile(sound_type);
+            match asset.get_bytes() {
                 Ok(data) => match RWops::from_bytes(&data) {
                     Ok(rwops) => match rwops.load_wav() {
-                        Ok(chunk) => sounds.push(chunk),
+                        Ok(chunk) => {
+                            sounds.insert(sound_type, chunk);
+                        }
                         Err(e) => {
                             tracing::warn!("Failed to load sound {} from asset API: {}", i + 1, e);
                         }
@@ -93,13 +139,33 @@ impl Audio {
             }
         }
 
+        let death_sound = match Asset::SoundFile(Sound::PacmanDeath).get_bytes() {
+            Ok(data) => match RWops::from_bytes(&data) {
+                Ok(rwops) => match rwops.load_wav() {
+                    Ok(chunk) => Some(chunk),
+                    Err(e) => {
+                        tracing::warn!("Failed to load death sound from asset API: {}", e);
+                        None
+                    }
+                },
+                Err(e) => {
+                    tracing::warn!("Failed to create RWops for death sound: {}", e);
+                    None
+                }
+            },
+            Err(e) => {
+                tracing::warn!("Failed to load death sound asset: {}", e);
+                None
+            }
+        };
+
         // If no sounds loaded successfully, disable audio
-        if sounds.is_empty() {
+        if sounds.is_empty() && death_sound.is_none() {
             tracing::warn!("No sounds loaded successfully. Audio will be disabled.");
             return Self {
                 _mixer_context: Some(mixer_context),
-                sounds: Vec::new(),
-                next_sound_index: 0,
+                sounds: HashMap::new(),
+                next_waka_index: 0u8,
                 muted: false,
                 disabled: true,
             };
@@ -108,7 +174,7 @@ impl Audio {
         Audio {
             _mixer_context: Some(mixer_context),
             sounds,
-            next_sound_index: 0,
+            next_waka_index: 0u8,
             muted: false,
             disabled: false,
         }
@@ -119,23 +185,54 @@ impl Audio {
     /// Automatically rotates through the four eating sound assets. The sound plays on channel 0 and the internal sound index
     /// advances to the next variant. Silently returns if audio is disabled, muted,
     /// or no sounds were loaded successfully.
-    #[allow(dead_code)]
-    pub fn eat(&mut self) {
+    pub fn waka(&mut self) {
         if self.disabled || self.muted || self.sounds.is_empty() {
             return;
         }
 
-        if let Some(chunk) = self.sounds.get(self.next_sound_index) {
-            match mixer::Channel(0).play(chunk, 0) {
+        if let Some(chunk) = self.sounds.get(&Sound::Waka(self.next_waka_index)) {
+            match mixer::Channel::all().play(chunk, 0) {
                 Ok(channel) => {
-                    tracing::trace!("Playing sound #{} on channel {:?}", self.next_sound_index + 1, channel);
+                    tracing::trace!("Playing sound #{} on channel {:?}", self.next_waka_index + 1, channel);
                 }
                 Err(e) => {
-                    tracing::warn!("Could not play sound #{}: {}", self.next_sound_index + 1, e);
+                    tracing::warn!("Could not play sound #{}: {}", self.next_waka_index + 1, e);
                 }
             }
         }
-        self.next_sound_index = (self.next_sound_index + 1) % self.sounds.len();
+        self.next_waka_index = (self.next_waka_index + 1) & 3;
+    }
+
+    /// Plays the provided sound effect once.
+    pub fn play(&mut self, sound: Sound) {
+        if self.disabled || self.muted {
+            return;
+        }
+
+        if let Some(chunk) = self.sounds.get(&sound) {
+            let _ = mixer::Channel::all().play(chunk, 0);
+        }
+    }
+
+    /// Halts all currently playing audio channels.
+    pub fn stop_all(&mut self) {
+        if !self.disabled {
+            mixer::Channel::all().halt();
+        }
+    }
+
+    /// Pauses all currently playing audio channels.
+    pub fn pause_all(&mut self) {
+        if !self.disabled {
+            mixer::Channel::all().pause();
+        }
+    }
+
+    /// Resumes all currently playing audio channels.
+    pub fn resume_all(&mut self) {
+        if !self.disabled {
+            mixer::Channel::all().resume();
+        }
     }
 
     /// Instantly mutes or unmutes all audio channels by adjusting their volume.
@@ -168,7 +265,6 @@ impl Audio {
     /// Audio can be disabled due to SDL2_mixer initialization failures, missing
     /// audio device, or failure to load any sound assets. When disabled, all
     /// audio operations become no-ops.
-    #[allow(dead_code)]
     pub fn is_disabled(&self) -> bool {
         self.disabled
     }

src/bin/aspect_demo.rs

@@ -1,3 +1,6 @@
+#![cfg_attr(coverage_nightly, feature(coverage_attribute))]
+#![cfg_attr(coverage_nightly, coverage(off))]
+
 use std::time::{Duration, Instant};
 
 use sdl2::event::Event;

src/bin/timing_demo.rs

@@ -1,3 +1,6 @@
+#![cfg_attr(coverage_nightly, feature(coverage_attribute))]
+#![cfg_attr(coverage_nightly, coverage(off))]
+
 use circular_buffer::CircularBuffer;
 use pacman::constants::CANVAS_SIZE;
 use sdl2::event::Event;

src/constants.rs

@@ -25,12 +25,25 @@ pub const SCALE: f32 = 2.6;
 /// screen for score display, player lives, and other UI elements.
 pub const BOARD_CELL_OFFSET: UVec2 = UVec2::new(0, 3);
 
+/// Bottom HUD row offset to reserve space below the game board.
+///
+/// The 2-cell vertical offset (16 pixels) provides space at the bottom of the
+/// screen for displaying Pac-Man's lives (left) and fruit symbols (right).
+pub const BOARD_BOTTOM_CELL_OFFSET: UVec2 = UVec2::new(0, 2);
+
 /// Pixel-space equivalent of `BOARD_CELL_OFFSET` for rendering calculations.
 ///
 /// Automatically calculated from the cell offset to maintain consistency
 /// when the cell size changes. Used for positioning sprites and debug overlays.
 pub const BOARD_PIXEL_OFFSET: UVec2 = UVec2::new(BOARD_CELL_OFFSET.x * CELL_SIZE, BOARD_CELL_OFFSET.y * CELL_SIZE);
 
+/// Pixel-space equivalent of `BOARD_BOTTOM_CELL_OFFSET` for rendering calculations.
+///
+/// Automatically calculated from the cell offset to maintain consistency
+/// when the cell size changes. Used for positioning bottom HUD elements.
+pub const BOARD_BOTTOM_PIXEL_OFFSET: UVec2 =
+    UVec2::new(BOARD_BOTTOM_CELL_OFFSET.x * CELL_SIZE, BOARD_BOTTOM_CELL_OFFSET.y * CELL_SIZE);
+
 /// Animation timing constants for ghost state management
 pub mod animation {
     /// Normal ghost movement animation speed (ticks per frame at 60 ticks/sec)
@@ -39,21 +52,23 @@ pub mod animation {
     pub const GHOST_EATEN_SPEED: u16 = 6;
     /// Frightened ghost animation speed (ticks per frame at 60 ticks/sec)
     pub const GHOST_FRIGHTENED_SPEED: u16 = 12;
-
-    /// Time in ticks when frightened ghosts start flashing (2 seconds at 60 FPS)
-    pub const FRIGHTENED_FLASH_START_TICKS: u32 = 120;
+    /// Time in ticks for frightened ghosts to return to normal
+    pub const GHOST_FRIGHTENED_TICKS: u32 = 300;
+    /// Time in ticks when frightened ghosts start flashing
+    pub const GHOST_FRIGHTENED_FLASH_START_TICKS: u32 = GHOST_FRIGHTENED_TICKS - 120;
 }
+
 /// The size of the canvas, in pixels.
 pub const CANVAS_SIZE: UVec2 = UVec2::new(
-    (BOARD_CELL_SIZE.x + BOARD_CELL_OFFSET.x) * CELL_SIZE,
-    (BOARD_CELL_SIZE.y + BOARD_CELL_OFFSET.y) * CELL_SIZE,
+    (BOARD_CELL_SIZE.x + BOARD_CELL_OFFSET.x + BOARD_BOTTOM_CELL_OFFSET.x) * CELL_SIZE,
+    (BOARD_CELL_SIZE.y + BOARD_CELL_OFFSET.y + BOARD_BOTTOM_CELL_OFFSET.y) * CELL_SIZE,
 );
 
 pub const LARGE_SCALE: f32 = 2.6;
 
 pub const LARGE_CANVAS_SIZE: UVec2 = UVec2::new(
-    (((BOARD_CELL_SIZE.x + BOARD_CELL_OFFSET.x) * CELL_SIZE) as f32 * LARGE_SCALE) as u32,
-    (((BOARD_CELL_SIZE.y + BOARD_CELL_OFFSET.y) * CELL_SIZE) as f32 * LARGE_SCALE) as u32,
+    (((BOARD_CELL_SIZE.x + BOARD_CELL_OFFSET.x + BOARD_BOTTOM_CELL_OFFSET.x) * CELL_SIZE) as f32 * LARGE_SCALE) as u32,
+    (((BOARD_CELL_SIZE.y + BOARD_CELL_OFFSET.y + BOARD_BOTTOM_CELL_OFFSET.y) * CELL_SIZE) as f32 * LARGE_SCALE) as u32,
 );
 
 /// Collider size constants for different entity types
@@ -66,6 +81,8 @@ pub mod collider {
     pub const PELLET_SIZE: f32 = CELL_SIZE as f32 * 0.4;
     /// Collider size for power pellets/energizers (0.95x cell size)
     pub const POWER_PELLET_SIZE: f32 = CELL_SIZE as f32 * 0.95;
+    /// Collider size for fruits (0.8x cell size)
+    pub const FRUIT_SIZE: f32 = CELL_SIZE as f32 * 1.375;
 }
 
 /// UI and rendering constants
@@ -132,8 +149,6 @@ pub const RAW_BOARD: [&str; BOARD_CELL_SIZE.y as usize] = [
 pub mod startup {
     /// Number of frames for the startup sequence (3 seconds at 60 FPS)
     pub const STARTUP_FRAMES: u32 = 60 * 3;
-    /// Number of ticks per frame during startup
-    pub const STARTUP_TICKS_PER_FRAME: u32 = 60;
 }
 
 /// Game mechanics constants

src/error.rs

@@ -46,19 +46,16 @@ pub enum AssetError {
     #[error("IO error: {0}")]
     Io(#[from] io::Error),
 
-    #[allow(dead_code)]
     #[error("Asset not found: {0}")]
     NotFound(String),
 }
 
 /// Platform-specific errors.
 #[derive(thiserror::Error, Debug)]
-#[allow(dead_code)]
 pub enum PlatformError {
     #[error("Console initialization failed: {0}")]
+    #[cfg(any(windows, target_os = "emscripten"))]
     ConsoleInit(String),
-    #[error("Platform-specific error: {0}")]
-    Other(String),
 }
 
 /// Error type for map parsing operations.
@@ -110,55 +107,3 @@ pub enum MapError {
 
 /// Result type for game operations.
 pub type GameResult<T> = Result<T, GameError>;
-
-/// Helper trait for converting other error types to GameError.
-pub trait IntoGameError<T> {
-    #[allow(dead_code)]
-    fn into_game_error(self) -> GameResult<T>;
-}
-
-impl<T, E> IntoGameError<T> for Result<T, E>
-where
-    E: std::error::Error + Send + Sync + 'static,
-{
-    fn into_game_error(self) -> GameResult<T> {
-        self.map_err(|e| GameError::InvalidState(e.to_string()))
-    }
-}
-
-/// Helper trait for converting Option to GameResult with a custom error.
-pub trait OptionExt<T> {
-    #[allow(dead_code)]
-    fn ok_or_game_error<F>(self, f: F) -> GameResult<T>
-    where
-        F: FnOnce() -> GameError;
-}
-
-impl<T> OptionExt<T> for Option<T> {
-    fn ok_or_game_error<F>(self, f: F) -> GameResult<T>
-    where
-        F: FnOnce() -> GameError,
-    {
-        self.ok_or_else(f)
-    }
-}
-
-/// Helper trait for converting Result to GameResult with context.
-pub trait ResultExt<T, E> {
-    #[allow(dead_code)]
-    fn with_context<F>(self, f: F) -> GameResult<T>
-    where
-        F: FnOnce(&E) -> GameError;
-}
-
-impl<T, E> ResultExt<T, E> for Result<T, E>
-where
-    E: std::error::Error + Send + Sync + 'static,
-{
-    fn with_context<F>(self, f: F) -> GameResult<T>
-    where
-        F: FnOnce(&E) -> GameError,
-    {
-        self.map_err(|e| f(&e))
-    }
-}

src/events.rs

@@ -1,6 +1,6 @@
 use bevy_ecs::{entity::Entity, event::Event};
 
-use crate::map::direction::Direction;
+use crate::{map::direction::Direction, systems::Ghost};
 
 /// Player input commands that trigger specific game actions.
 ///
@@ -19,20 +19,20 @@ pub enum GameCommand {
     /// Restart the current level with fresh entity positions and items
     ResetLevel,
     /// Pause or resume game ticking logic
+    /// TODO: Display pause state, fix debug rendering pause distress
     TogglePause,
+    /// Toggle fullscreen mode (desktop only)
+    ToggleFullscreen,
 }
 
 /// Global events that flow through the ECS event system to coordinate game behavior.
 ///
-/// Events enable loose coupling between systems - input generates commands, collision
-/// detection reports overlaps, and various systems respond appropriately without
-/// direct dependencies.
+/// Events enable loose coupling between systems - input generates commands and
+/// various systems respond appropriately without direct dependencies.
 #[derive(Event, Clone, Copy, Debug, PartialEq, Eq)]
 pub enum GameEvent {
     /// Player input command to be processed by relevant game systems
     Command(GameCommand),
-    /// Physical overlap detected between two entities requiring gameplay response
-    Collision(Entity, Entity),
 }
 
 impl From<GameCommand> for GameEvent {
@@ -40,3 +40,22 @@ impl From<GameCommand> for GameEvent {
         GameEvent::Command(command)
     }
 }
+
+/// Data for requesting stage transitions; processed centrally in stage_system
+#[derive(Event, Clone, Copy, Debug, PartialEq, Eq)]
+pub enum StageTransition {
+    GhostEatenPause { ghost_entity: Entity, ghost_type: Ghost },
+}
+
+/// Collision triggers for immediate collision handling via observers
+#[derive(Event, Clone, Copy, Debug, PartialEq, Eq)]
+pub enum CollisionTrigger {
+    /// Pac-Man collided with a ghost
+    GhostCollision {
+        pacman: Entity,
+        ghost: Entity,
+        ghost_type: Ghost,
+    },
+    /// Pac-Man collided with an item
+    ItemCollision { item: Entity },
+}

src/formatter.rs

@@ -150,11 +150,3 @@ pub fn increment_tick() {
 pub fn get_tick_count() -> u64 {
     TICK_COUNTER.load(Ordering::Relaxed)
 }
-
-/// Reset the tick counter to 0
-///
-/// This can be used for testing or when restarting the game
-#[allow(dead_code)]
-pub fn reset_tick_counter() {
-    TICK_COUNTER.store(0, Ordering::Relaxed);
-}

src/game.rs

@@ -3,38 +3,36 @@
 include!(concat!(env!("OUT_DIR"), "/atlas_data.rs"));
 
 use std::collections::HashMap;
+use std::ops::Not;
+use tracing::{debug, info, trace, warn};
 
 use crate::constants::{self, animation, MapTile, CANVAS_SIZE};
 use crate::error::{GameError, GameResult};
-use crate::events::GameEvent;
+use crate::events::{CollisionTrigger, GameEvent, StageTransition};
 use crate::map::builder::Map;
 use crate::map::direction::Direction;
-use crate::systems::blinking::Blinking;
-use crate::systems::components::{GhostAnimation, GhostState, LastAnimationState};
-use crate::systems::movement::{BufferedDirection, Position, Velocity};
-use crate::systems::profiling::{SystemId, Timing};
-use crate::systems::render::touch_ui_render_system;
-use crate::systems::render::RenderDirty;
+use crate::systems::item::PelletCount;
+use crate::systems::state::IntroPlayed;
 use crate::systems::{
-    self, combined_render_system, ghost_collision_system, present_system, Hidden, LinearAnimation, MovementModifiers, NodeId,
-    TouchState,
-};
-use crate::systems::{
-    audio_system, blinking_system, collision_system, directional_render_system, dirty_render_system, eaten_ghost_system,
-    ghost_movement_system, ghost_state_system, hud_render_system, item_system, linear_render_system, profile, AudioEvent,
-    AudioResource, AudioState, BackbufferResource, Collider, DebugState, DebugTextureResource, DeltaTime, DirectionalAnimation,
-    EntityType, Frozen, Ghost, GhostAnimations, GhostBundle, GhostCollider, GlobalState, ItemBundle, ItemCollider,
-    MapTextureResource, PacmanCollider, PlayerBundle, PlayerControlled, Renderable, ScoreResource, StartupSequence,
-    SystemTimings,
+    self, audio_system, blinking_system, collision_system, combined_render_system, directional_render_system,
+    dirty_render_system, eaten_ghost_system, fruit_sprite_system, ghost_collision_observer, ghost_movement_system,
+    ghost_state_system, hud_render_system, item_collision_observer, linear_render_system, player_life_sprite_system,
+    present_system, profile, time_to_live_system, touch_ui_render_system, AudioEvent, AudioResource, AudioState,
+    BackbufferResource, Blinking, BufferedDirection, Collider, DebugState, DebugTextureResource, DeltaTime, DirectionalAnimation,
+    EntityType, Frozen, FruitSprites, GameStage, Ghost, GhostAnimation, GhostAnimations, GhostBundle, GhostCollider, GhostState,
+    GlobalState, ItemBundle, ItemCollider, LastAnimationState, LinearAnimation, MapTextureResource, MovementModifiers, NodeId,
+    PacmanCollider, Paused, PlayerAnimation, PlayerBundle, PlayerControlled, PlayerDeathAnimation, PlayerLives, Position,
+    RenderDirty, Renderable, ScoreResource, StartupSequence, SystemId, SystemTimings, Timing, TouchState, Velocity, Visibility,
 };
+
 use crate::texture::animated::{DirectionalTiles, TileSequence};
 use crate::texture::sprite::AtlasTile;
 use crate::texture::sprites::{FrightenedColor, GameSprite, GhostSprite, MazeSprite, PacmanSprite};
+use bevy_ecs::change_detection::DetectChanges;
 use bevy_ecs::event::EventRegistry;
 use bevy_ecs::observer::Trigger;
-use bevy_ecs::schedule::common_conditions::resource_changed;
-use bevy_ecs::schedule::{Condition, IntoScheduleConfigs, Schedule, SystemSet};
-use bevy_ecs::system::{Local, ResMut};
+use bevy_ecs::schedule::{IntoScheduleConfigs, Schedule, SystemSet};
+use bevy_ecs::system::{Local, Res, ResMut};
 use bevy_ecs::world::World;
 use sdl2::event::EventType;
 use sdl2::image::LoadTexture;
@@ -44,17 +42,31 @@ use sdl2::video::{Window, WindowContext};
 use sdl2::EventPump;
 
 use crate::{
-    asset::{get_asset_bytes, Asset},
+    asset::Asset,
     events::GameCommand,
     map::render::MapRenderer,
-    systems::debug::{BatchedLinesResource, TtfAtlasResource},
-    systems::input::{Bindings, CursorPosition},
+    systems::{BatchedLinesResource, Bindings, CursorPosition, TtfAtlasResource},
     texture::sprite::{AtlasMapper, SpriteAtlas},
 };
 
+/// System set for all gameplay systems to ensure they run after input processing
+#[derive(SystemSet, Debug, Hash, PartialEq, Eq, Clone)]
+enum GameplaySet {
+    /// Gameplay systems that process inputs
+    Input,
+    /// Gameplay systems that update the game state
+    Update,
+    /// Gameplay systems that respond to events
+    Respond,
+}
+
 /// System set for all rendering systems to ensure they run after gameplay logic
 #[derive(SystemSet, Debug, Hash, PartialEq, Eq, Clone)]
-pub struct RenderSet;
+enum RenderSet {
+    Animation,
+    Draw,
+    Present,
+}
 
 /// Core game state manager built on the Bevy ECS architecture.
 ///
@@ -93,29 +105,47 @@ impl Game {
         texture_creator: TextureCreator<WindowContext>,
         mut event_pump: EventPump,
     ) -> GameResult<Game> {
+        info!("Starting game initialization");
+
+        debug!("Disabling unnecessary SDL events");
         Self::disable_sdl_events(&mut event_pump);
 
+        debug!("Setting up textures and fonts");
         let (backbuffer, mut map_texture, debug_texture, ttf_atlas) =
             Self::setup_textures_and_fonts(&mut canvas, &texture_creator, ttf_context)?;
 
+        debug!("Initializing audio subsystem");
         let audio = crate::audio::Audio::new();
 
+        debug!("Loading sprite atlas and map tiles");
         let (mut atlas, map_tiles) = Self::load_atlas_and_map_tiles(&texture_creator)?;
+        debug!("Rendering static map to texture cache");
         canvas
             .with_texture_canvas(&mut map_texture, |map_canvas| {
                 MapRenderer::render_map(map_canvas, &mut atlas, &map_tiles);
             })
             .map_err(|e| GameError::Sdl(e.to_string()))?;
 
+        debug!("Building navigation graph from map layout");
         let map = Map::new(constants::RAW_BOARD)?;
 
+        debug!("Creating player animations and bundle");
         let (player_animation, player_start_sprite) = Self::create_player_animations(&atlas)?;
         let player_bundle = Self::create_player_bundle(&map, player_animation, player_start_sprite);
 
+        debug!("Creating death animation sequence");
+        let death_animation = Self::create_death_animation(&atlas)?;
+
+        debug!("Initializing ECS world and system schedule");
         let mut world = World::default();
         let mut schedule = Schedule::default();
 
+        debug!("Setting up ECS event registry and observers");
         Self::setup_ecs(&mut world);
+
+        world.add_observer(systems::spawn_fruit_observer);
+
+        debug!("Inserting resources into ECS world");
         Self::insert_resources(
             &mut world,
             map,
@@ -127,13 +157,20 @@ impl Game {
             map_texture,
             debug_texture,
             ttf_atlas,
+            death_animation,
         )?;
+
+        debug!("Configuring system execution schedule");
         Self::configure_schedule(&mut schedule);
 
-        world.spawn(player_bundle).insert((Frozen, Hidden));
+        debug!("Spawning player entity");
+        world.spawn(player_bundle).insert((Frozen, Visibility::hidden()));
+
+        info!("Spawning game entities");
         Self::spawn_ghosts(&mut world)?;
         Self::spawn_items(&mut world)?;
 
+        info!("Game initialization completed successfully");
         Ok(Game { world, schedule })
     }
 
@@ -212,7 +249,7 @@ impl Game {
         debug_texture.set_blend_mode(BlendMode::Blend);
         debug_texture.set_scale_mode(ScaleMode::Nearest);
 
-        let font_data: &'static [u8] = get_asset_bytes(Asset::Font)?.to_vec().leak();
+        let font_data: &'static [u8] = Asset::Font.get_bytes()?.to_vec().leak();
         let font_asset = RWops::from_bytes(font_data).map_err(|_| GameError::Sdl("Failed to load font".to_string()))?;
         let debug_font = ttf_context
             .load_font_from_rwops(font_asset, constants::ui::DEBUG_FONT_SIZE)
@@ -225,7 +262,8 @@ impl Game {
     }
 
     fn load_atlas_and_map_tiles(texture_creator: &TextureCreator<WindowContext>) -> GameResult<(SpriteAtlas, Vec<AtlasTile>)> {
-        let atlas_bytes = get_asset_bytes(Asset::AtlasImage)?;
+        trace!("Loading atlas image from embedded assets");
+        let atlas_bytes = Asset::AtlasImage.get_bytes()?;
         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!(
@@ -236,11 +274,13 @@ impl Game {
             }
         })?;
 
+        debug!(frame_count = ATLAS_FRAMES.len(), "Creating sprite atlas from texture");
         let atlas_mapper = AtlasMapper {
             frames: ATLAS_FRAMES.into_iter().map(|(k, v)| (k.to_string(), *v)).collect(),
         };
         let atlas = SpriteAtlas::new(atlas_texture, atlas_mapper);
 
+        trace!("Extracting map tile sprites from atlas");
         let mut map_tiles = Vec::with_capacity(35);
         for i in 0..35 {
             let tile_name = GameSprite::Maze(MazeSprite::Tile(i)).to_path();
@@ -310,6 +350,18 @@ impl Game {
         Ok((player_animation, player_start_sprite))
     }
 
+    fn create_death_animation(atlas: &SpriteAtlas) -> GameResult<LinearAnimation> {
+        let mut death_tiles = Vec::new();
+        for i in 0..=10 {
+            // Assuming death animation has 11 frames named pacman/die_0, pacman/die_1, etc.
+            let tile = atlas.get_tile(&GameSprite::Pacman(PacmanSprite::Dying(i)).to_path())?;
+            death_tiles.push(tile);
+        }
+
+        let tile_sequence = TileSequence::new(&death_tiles);
+        Ok(LinearAnimation::new(tile_sequence, 8)) // 8 ticks per frame, non-looping
+    }
+
     fn create_player_bundle(map: &Map, player_animation: DirectionalAnimation, player_start_sprite: AtlasTile) -> PlayerBundle {
         PlayerBundle {
             player: PlayerControlled,
@@ -339,6 +391,8 @@ impl Game {
         EventRegistry::register_event::<GameError>(world);
         EventRegistry::register_event::<GameEvent>(world);
         EventRegistry::register_event::<AudioEvent>(world);
+        EventRegistry::register_event::<StageTransition>(world);
+        EventRegistry::register_event::<CollisionTrigger>(world);
 
         world.add_observer(
             |event: Trigger<GameEvent>, mut state: ResMut<GlobalState>, _score: ResMut<ScoreResource>| {
@@ -347,6 +401,9 @@ impl Game {
                 }
             },
         );
+
+        world.add_observer(ghost_collision_observer);
+        world.add_observer(item_collision_observer);
     }
 
     #[allow(clippy::too_many_arguments)]
@@ -361,14 +418,21 @@ impl Game {
         map_texture: sdl2::render::Texture,
         debug_texture: sdl2::render::Texture,
         ttf_atlas: crate::texture::ttf::TtfAtlas,
+        death_animation: LinearAnimation,
     ) -> GameResult<()> {
         world.insert_non_send_resource(atlas);
         world.insert_resource(Self::create_ghost_animations(world.non_send_resource::<SpriteAtlas>())?);
+        let player_animation = Self::create_player_animations(world.non_send_resource::<SpriteAtlas>())?.0;
+        world.insert_resource(PlayerAnimation(player_animation));
+        world.insert_resource(PlayerDeathAnimation(death_animation));
 
+        world.insert_resource(FruitSprites::default());
         world.insert_resource(BatchedLinesResource::new(&map, constants::LARGE_SCALE));
         world.insert_resource(map);
         world.insert_resource(GlobalState { exit: false });
+        world.insert_resource(PlayerLives::default());
         world.insert_resource(ScoreResource(0));
+        world.insert_resource(PelletCount(0));
         world.insert_resource(SystemTimings::default());
         world.insert_resource(Timing::default());
         world.insert_resource(Bindings::default());
@@ -376,12 +440,13 @@ impl Game {
         world.insert_resource(RenderDirty::default());
         world.insert_resource(DebugState::default());
         world.insert_resource(AudioState::default());
+        world.insert_resource(IntroPlayed::default());
         world.insert_resource(CursorPosition::default());
         world.insert_resource(TouchState::default());
-        world.insert_resource(StartupSequence::new(
-            constants::startup::STARTUP_FRAMES,
-            constants::startup::STARTUP_TICKS_PER_FRAME,
-        ));
+        world.insert_resource(GameStage::Starting(StartupSequence::TextOnly {
+            remaining_ticks: constants::startup::STARTUP_FRAMES,
+        }));
+        world.insert_resource(Paused(false));
 
         world.insert_non_send_resource(event_pump);
         world.insert_non_send_resource::<&mut Canvas<Window>>(Box::leak(Box::new(canvas)));
@@ -394,63 +459,90 @@ impl Game {
     }
 
     fn configure_schedule(schedule: &mut Schedule) {
+        let stage_system = profile(SystemId::Stage, systems::stage_system);
         let input_system = profile(SystemId::Input, systems::input::input_system);
+        let pause_system = profile(SystemId::Input, systems::handle_pause_command);
         let player_control_system = profile(SystemId::PlayerControls, systems::player_control_system);
         let player_movement_system = profile(SystemId::PlayerMovement, systems::player_movement_system);
-        let startup_stage_system = profile(SystemId::Stage, systems::startup_stage_system);
         let player_tunnel_slowdown_system = profile(SystemId::PlayerMovement, systems::player::player_tunnel_slowdown_system);
         let ghost_movement_system = profile(SystemId::Ghost, ghost_movement_system);
         let collision_system = profile(SystemId::Collision, collision_system);
-        let ghost_collision_system = profile(SystemId::GhostCollision, ghost_collision_system);
-
-        let item_system = profile(SystemId::Item, item_system);
         let audio_system = profile(SystemId::Audio, audio_system);
         let blinking_system = profile(SystemId::Blinking, blinking_system);
         let directional_render_system = profile(SystemId::DirectionalRender, directional_render_system);
         let linear_render_system = profile(SystemId::LinearRender, linear_render_system);
         let dirty_render_system = profile(SystemId::DirtyRender, dirty_render_system);
         let hud_render_system = profile(SystemId::HudRender, hud_render_system);
+        let player_life_sprite_system = profile(SystemId::HudRender, player_life_sprite_system);
+        let fruit_sprite_system = profile(SystemId::HudRender, fruit_sprite_system);
         let present_system = profile(SystemId::Present, present_system);
         let unified_ghost_state_system = profile(SystemId::GhostStateAnimation, ghost_state_system);
+        let eaten_ghost_system = profile(SystemId::EatenGhost, eaten_ghost_system);
+        let time_to_live_system = profile(SystemId::TimeToLive, time_to_live_system);
 
-        let forced_dirty_system = |mut dirty: ResMut<RenderDirty>| {
-            dirty.0 = true;
-        };
+        // Input system should always run to prevent SDL event pump from blocking
+        let input_systems = (
+            input_system.run_if(|mut local: Local<u8>| {
+                *local = local.wrapping_add(1u8);
+                // run every nth frame
+                *local % 2 == 0
+            }),
+            player_control_system,
+            pause_system,
+            #[cfg(not(target_os = "emscripten"))]
+            profile(SystemId::Input, systems::handle_fullscreen_command),
+        )
+            .chain();
 
-        schedule.add_systems((
-            forced_dirty_system.run_if(resource_changed::<ScoreResource>.or(resource_changed::<StartupSequence>)),
-            (
-                input_system.run_if(|mut local: Local<u8>| {
-                    *local = local.wrapping_add(1u8);
-                    // run every nth frame
-                    *local % 2 == 0
-                }),
-                player_control_system,
-                player_movement_system,
-                startup_stage_system,
-            )
-                .chain(),
-            player_tunnel_slowdown_system,
-            ghost_movement_system,
-            profile(SystemId::EatenGhost, eaten_ghost_system),
-            unified_ghost_state_system,
-            (collision_system, ghost_collision_system, item_system).chain(),
-            audio_system,
-            blinking_system,
-            (
-                directional_render_system,
-                linear_render_system,
-                dirty_render_system,
-                combined_render_system,
-                hud_render_system,
-                touch_ui_render_system,
-                present_system,
-            )
-                .chain(),
-        ));
+        // .run_if(|game_state: Res<GameStage>| matches!(*game_state, GameStage::Playing));
+
+        schedule
+            .add_systems((
+                input_systems.in_set(GameplaySet::Input),
+                time_to_live_system.before(GameplaySet::Update),
+                (
+                    player_movement_system,
+                    player_tunnel_slowdown_system,
+                    ghost_movement_system,
+                    eaten_ghost_system,
+                    collision_system,
+                    unified_ghost_state_system,
+                )
+                    .in_set(GameplaySet::Update),
+                (
+                    blinking_system,
+                    directional_render_system,
+                    linear_render_system,
+                    player_life_sprite_system,
+                    fruit_sprite_system,
+                )
+                    .in_set(RenderSet::Animation),
+                stage_system.in_set(GameplaySet::Respond),
+                (
+                    (|mut dirty: ResMut<RenderDirty>, score: Res<ScoreResource>, stage: Res<GameStage>| {
+                        dirty.0 = score.is_changed() || stage.is_changed();
+                    }),
+                    dirty_render_system.run_if(|dirty: Res<RenderDirty>| dirty.0.not()),
+                    combined_render_system,
+                    hud_render_system,
+                    touch_ui_render_system,
+                )
+                    .chain()
+                    .in_set(RenderSet::Draw),
+                (present_system, audio_system).chain().in_set(RenderSet::Present),
+            ))
+            .configure_sets((
+                GameplaySet::Input,
+                GameplaySet::Update.run_if(|paused: Res<Paused>| !paused.0),
+                GameplaySet::Respond.run_if(|paused: Res<Paused>| !paused.0),
+                RenderSet::Animation.run_if(|paused: Res<Paused>| !paused.0),
+                RenderSet::Draw,
+                RenderSet::Present,
+            ));
     }
 
     fn spawn_items(world: &mut World) -> GameResult<()> {
+        trace!("Loading item sprites from atlas");
         let pellet_sprite = SpriteAtlas::get_tile(
             world.non_send_resource::<SpriteAtlas>(),
             &GameSprite::Maze(MazeSprite::Pellet).to_path(),
@@ -475,6 +567,12 @@ impl Game {
             })
             .collect();
 
+        info!(
+            pellet_count = nodes.iter().filter(|(_, t, _, _)| *t == EntityType::Pellet).count(),
+            power_pellet_count = nodes.iter().filter(|(_, t, _, _)| *t == EntityType::PowerPellet).count(),
+            "Spawning collectible items"
+        );
+
         for (id, item_type, sprite, size) in nodes {
             let mut item = world.spawn(ItemBundle {
                 position: Position::Stopped { node: id },
@@ -498,6 +596,7 @@ impl Game {
     /// Returns `GameError::Texture` if any ghost sprite cannot be found in the atlas,
     /// typically indicating missing or misnamed sprite files.
     fn spawn_ghosts(world: &mut World) -> GameResult<()> {
+        trace!("Spawning ghost entities with AI personalities");
         // Extract the data we need first to avoid borrow conflicts
         let ghost_start_positions = {
             let map = world.resource::<Map>();
@@ -512,7 +611,7 @@ impl Game {
         for (ghost_type, start_node) in ghost_start_positions {
             // Create the ghost bundle in a separate scope to manage borrows
             let ghost = {
-                let animations = *world.resource::<GhostAnimations>().get_normal(&ghost_type).unwrap();
+                let animations = world.resource::<GhostAnimations>().get_normal(&ghost_type).unwrap().clone();
                 let atlas = world.non_send_resource::<SpriteAtlas>();
                 let sprite_path = GameSprite::Ghost(GhostSprite::Normal(ghost_type, Direction::Left, 0)).to_path();
 
@@ -538,9 +637,11 @@ impl Game {
                 }
             };
 
-            world.spawn(ghost).insert((Frozen, Hidden));
+            let entity = world.spawn(ghost).insert((Frozen, Visibility::hidden())).id();
+            trace!(ghost = ?ghost_type, entity = ?entity, start_node, "Spawned ghost entity");
         }
 
+        info!("All ghost entities spawned successfully");
         Ok(())
     }
 
@@ -557,7 +658,7 @@ impl Game {
             TileSequence::new(&[left_eye]),
             TileSequence::new(&[right_eye]),
         );
-        let eyes = DirectionalAnimation::new(eyes_tiles, eyes_tiles, animation::GHOST_EATEN_SPEED);
+        let eyes = DirectionalAnimation::new(eyes_tiles.clone(), eyes_tiles, animation::GHOST_EATEN_SPEED);
 
         let mut animations = HashMap::new();
 
@@ -586,7 +687,7 @@ impl Game {
                 TileSequence::new(&left_tiles),
                 TileSequence::new(&right_tiles),
             );
-            let normal = DirectionalAnimation::new(normal_moving, normal_moving, animation::GHOST_NORMAL_SPEED);
+            let normal = DirectionalAnimation::new(normal_moving.clone(), normal_moving, animation::GHOST_NORMAL_SPEED);
 
             animations.insert(ghost_type, normal);
         }
@@ -649,6 +750,28 @@ impl Game {
         ) {
             let new_tick = timing.increment_tick();
             timings.add_total_timing(total_duration, new_tick);
+
+            // Log performance warnings for slow frames
+            if total_duration.as_millis() > 17 {
+                // Warn if frame takes too long
+                let slowest_systems = timings.get_slowest_systems();
+                let systems_context = if slowest_systems.is_empty() {
+                    "No specific systems identified".to_string()
+                } else {
+                    slowest_systems
+                        .iter()
+                        .map(|(id, duration)| format!("{} ({:.2?})", id, duration))
+                        .collect::<Vec<String>>()
+                        .join(", ")
+                };
+
+                warn!(
+                    total = format!("{:.3?}", total_duration),
+                    tick = new_tick,
+                    systems = systems_context,
+                    "Frame took longer than expected"
+                );
+            }
         }
 
         let state = self
@@ -658,68 +781,4 @@ impl Game {
 
         state.exit
     }
-
-    // /// Renders pathfinding debug lines from each ghost to Pac-Man.
-    // ///
-    // /// Each ghost's path is drawn in its respective color with a small offset
-    // /// to prevent overlapping lines.
-    // fn render_pathfinding_debug<T: sdl2::render::RenderTarget>(&self, canvas: &mut Canvas<T>) -> GameResult<()> {
-    //     let pacman_node = self.state.pacman.current_node_id();
-
-    //     for ghost in self.state.ghosts.iter() {
-    //         if let Ok(path) = ghost.calculate_path_to_target(&self.state.map.graph, pacman_node) {
-    //             if path.len() < 2 {
-    //                 continue; // Skip if path is too short
-    //             }
-
-    //             // Set the ghost's color
-    //             canvas.set_draw_color(ghost.debug_color());
-
-    //             // Calculate offset based on ghost index to prevent overlapping lines
-    //             // let offset = (i as f32) * 2.0 - 3.0; // Offset range: -3.0 to 3.0
-
-    //             // Calculate a consistent offset direction for the entire path
-    //             // let first_node = self.map.graph.get_node(path[0]).unwrap();
-    //             // let last_node = self.map.graph.get_node(path[path.len() - 1]).unwrap();
-
-    //             // Use the overall direction from start to end to determine the perpendicular offset
-    //             let offset = match ghost.ghost_type {
-    //                 GhostType::Blinky => glam::Vec2::new(0.25, 0.5),
-    //                 GhostType::Pinky => glam::Vec2::new(-0.25, -0.25),
-    //                 GhostType::Inky => glam::Vec2::new(0.5, -0.5),
-    //                 GhostType::Clyde => glam::Vec2::new(-0.5, 0.25),
-    //             } * 5.0;
-
-    //             // Calculate offset positions for all nodes using the same perpendicular direction
-    //             let mut offset_positions = Vec::new();
-    //             for &node_id in &path {
-    //                 let node = self
-    //                     .state
-    //                     .map
-    //                     .graph
-    //                     .get_node(node_id)
-    //                     .ok_or(crate::error::EntityError::NodeNotFound(node_id))?;
-    //                 let pos = node.position + crate::constants::BOARD_PIXEL_OFFSET.as_vec2();
-    //                 offset_positions.push(pos + offset);
-    //             }
-
-    //             // Draw lines between the offset positions
-    //             for window in offset_positions.windows(2) {
-    //                 if let (Some(from), Some(to)) = (window.first(), window.get(1)) {
-    //                     // Skip if the distance is too far (used for preventing lines between tunnel portals)
-    //                     if from.distance_squared(*to) > (crate::constants::CELL_SIZE * 16).pow(2) as f32 {
-    //                         continue;
-    //                     }
-
-    //                     // Draw the line
-    //                     canvas
-    //                         .draw_line((from.x as i32, from.y as i32), (to.x as i32, to.y as i32))
-    //                         .map_err(|e| crate::error::GameError::Sdl(e.to_string()))?;
-    //                 }
-    //             }
-    //         }
-    //     }
-
-    //     Ok(())
-    // }
 }

src/lib.rs

@@ -1,14 +1,22 @@
 //! Pac-Man game library crate.
+#![cfg_attr(coverage_nightly, feature(coverage_attribute))]
 
+#[cfg_attr(coverage_nightly, coverage(off))]
 pub mod app;
-pub mod asset;
+#[cfg_attr(coverage_nightly, coverage(off))]
 pub mod audio;
-pub mod constants;
+#[cfg_attr(coverage_nightly, coverage(off))]
 pub mod error;
+#[cfg_attr(coverage_nightly, coverage(off))]
 pub mod events;
+#[cfg_attr(coverage_nightly, coverage(off))]
 pub mod formatter;
+#[cfg_attr(coverage_nightly, coverage(off))]
+pub mod platform;
+
+pub mod asset;
+pub mod constants;
 pub mod game;
 pub mod map;
-pub mod platform;
 pub mod systems;
 pub mod texture;

src/main.rs

@@ -1,20 +1,29 @@
 // Note: This disables the console window on Windows. We manually re-attach to the parent terminal or process later on.
 #![windows_subsystem = "windows"]
+#![cfg_attr(coverage_nightly, feature(coverage_attribute))]
+#![cfg_attr(coverage_nightly, coverage(off))]
 
 use crate::{app::App, constants::LOOP_TIME};
 use tracing::info;
 
+// These modules are excluded from coverage.
+#[cfg_attr(coverage_nightly, coverage(off))]
 mod app;
-mod asset;
+#[cfg_attr(coverage_nightly, coverage(off))]
 mod audio;
-mod constants;
-
+#[cfg_attr(coverage_nightly, coverage(off))]
 mod error;
+#[cfg_attr(coverage_nightly, coverage(off))]
 mod events;
+#[cfg_attr(coverage_nightly, coverage(off))]
 mod formatter;
+#[cfg_attr(coverage_nightly, coverage(off))]
+mod platform;
+
+mod asset;
+mod constants;
 mod game;
 mod map;
-mod platform;
 mod systems;
 mod texture;
 

src/map/builder.rs

@@ -3,7 +3,7 @@ use crate::constants::{MapTile, BOARD_CELL_SIZE, CELL_SIZE};
 use crate::map::direction::Direction;
 use crate::map::graph::{Graph, Node, TraversalFlags};
 use crate::map::parser::MapTileParser;
-use crate::systems::movement::NodeId;
+use crate::systems::{NodeId, Position};
 use bevy_ecs::resource::Resource;
 use glam::{I8Vec2, IVec2, Vec2};
 use std::collections::{HashMap, VecDeque};
@@ -25,6 +25,8 @@ pub struct NodePositions {
     pub inky: NodeId,
     /// Clyde starts in the center of the ghost house
     pub clyde: NodeId,
+    /// Fruit spawn location directly below the ghost house
+    pub fruit_spawn: Position,
 }
 
 /// Complete maze representation combining visual layout with navigation pathfinding.
@@ -56,11 +58,17 @@ impl Map {
     /// This function will panic if the board layout contains unknown characters or if
     /// the house door is not defined by exactly two '=' characters.
     pub fn new(raw_board: [&str; BOARD_CELL_SIZE.y as usize]) -> GameResult<Map> {
+        debug!("Starting map construction from character layout");
         let parsed_map = MapTileParser::parse_board(raw_board)?;
 
         let map = parsed_map.tiles;
         let house_door = parsed_map.house_door;
         let tunnel_ends = parsed_map.tunnel_ends;
+        debug!(
+            house_door_count = house_door.len(),
+            tunnel_ends_count = tunnel_ends.len(),
+            "Parsed map special locations"
+        );
 
         let mut graph = Graph::new();
         let mut grid_to_node = HashMap::new();
@@ -148,17 +156,39 @@ impl Map {
         let (house_entrance_node_id, left_center_node_id, center_center_node_id, right_center_node_id) =
             Self::build_house(&mut graph, &grid_to_node, &house_door)?;
 
+        // Find fruit spawn location (directly below ghost house)
+        let left_node_position = I8Vec2::new(13, 17);
+        let left_node_id = grid_to_node.get(&left_node_position).unwrap();
+        let right_node_position = I8Vec2::new(14, 17);
+        let right_node_id = grid_to_node.get(&right_node_position).unwrap();
+
+        let distance = graph
+            .get_node(*right_node_id)
+            .unwrap()
+            .position
+            .distance(graph.get_node(*left_node_id).unwrap().position);
+
+        // interpolate between the two nodes
+        let fruit_spawn_position: Position = Position::Moving {
+            from: *left_node_id,
+            to: *right_node_id,
+            remaining_distance: distance / 2.0,
+        };
+
         let start_positions = NodePositions {
             pacman: grid_to_node[&start_pos],
             blinky: house_entrance_node_id,
             pinky: left_center_node_id,
             inky: right_center_node_id,
             clyde: center_center_node_id,
+            fruit_spawn: fruit_spawn_position,
         };
 
         // Build tunnel connections
+        debug!("Building tunnel connections");
         Self::build_tunnels(&mut graph, &grid_to_node, &tunnel_ends)?;
 
+        debug!(node_count = graph.nodes().count(), "Map construction completed successfully");
         Ok(Map {
             graph,
             grid_to_node,
@@ -359,12 +389,7 @@ impl Map {
                             + IVec2::from(Direction::Left.as_ivec2()).as_vec2() * (CELL_SIZE as f32 * 2.0),
                     },
                 )
-                .map_err(|e| {
-                    MapError::InvalidConfig(format!(
-                        "Failed to connect left tunnel entrance to left tunnel hidden node: {}",
-                        e
-                    ))
-                })?
+                .expect("Failed to connect left tunnel entrance to left tunnel hidden node")
         };
 
         // Create the right tunnel nodes
@@ -384,12 +409,7 @@ impl Map {
                             + IVec2::from(Direction::Right.as_ivec2()).as_vec2() * (CELL_SIZE as f32 * 2.0),
                     },
                 )
-                .map_err(|e| {
-                    MapError::InvalidConfig(format!(
-                        "Failed to connect right tunnel entrance to right tunnel hidden node: {}",
-                        e
-                    ))
-                })?
+                .expect("Failed to connect right tunnel entrance to right tunnel hidden node")
         };
 
         // Connect the left tunnel hidden node to the right tunnel hidden node
@@ -401,12 +421,7 @@ impl Map {
                 Some(0.0),
                 Direction::Left,
             )
-            .map_err(|e| {
-                MapError::InvalidConfig(format!(
-                    "Failed to connect left tunnel hidden node to right tunnel hidden node: {}",
-                    e
-                ))
-            })?;
+            .expect("Failed to connect left tunnel hidden node to right tunnel hidden node");
 
         Ok(())
     }

src/map/graph.rs

@@ -1,6 +1,6 @@
 use glam::Vec2;
 
-use crate::systems::movement::NodeId;
+use crate::systems::NodeId;
 
 use super::direction::Direction;
 

src/platform/desktop.rs

@@ -1,12 +1,15 @@
 //! Desktop platform implementation.
 
-use std::borrow::Cow;
 use std::time::Duration;
 
 use rand::rngs::ThreadRng;
+use rust_embed::Embed;
 
-use crate::asset::Asset;
-use crate::error::{AssetError, PlatformError};
+use crate::error::PlatformError;
+
+#[derive(Embed)]
+#[folder = "assets/game/"]
+struct EmbeddedAssets;
 
 /// Desktop platform implementation.
 pub fn sleep(duration: Duration, focused: bool) {
@@ -21,7 +24,7 @@ pub fn init_console() -> Result<(), PlatformError> {
     #[cfg(windows)]
     {
         use crate::platform::tracing_buffer::setup_switchable_subscriber;
-        use tracing::{debug, info};
+        use tracing::{debug, info, trace};
         use windows::Win32::System::Console::GetConsoleWindow;
 
         // Setup buffered tracing subscriber that will buffer logs until console is ready
@@ -32,13 +35,13 @@ pub fn init_console() -> Result<(), PlatformError> {
             debug!("Already have a console window");
             return Ok(());
         } else {
-            debug!("No existing console window found");
+            trace!("No existing console window found");
         }
 
         if let Some(file_type) = is_output_setup()? {
-            debug!(r#type = file_type, "Existing output detected");
+            trace!(r#type = file_type, "Existing output detected");
         } else {
-            debug!("No existing output detected");
+            trace!("No existing output detected");
 
             // Try to attach to parent console for direct cargo run
             attach_to_parent_console()?;
@@ -46,7 +49,7 @@ pub fn init_console() -> Result<(), PlatformError> {
         }
 
         // Now that console is initialized, flush buffered logs and switch to direct output
-        debug!("Switching to direct logging mode and flushing buffer...");
+        trace!("Switching to direct logging mode and flushing buffer...");
         if let Err(error) = switchable_writer.switch_to_direct_mode() {
             use tracing::warn;
 
@@ -57,17 +60,6 @@ pub fn init_console() -> Result<(), PlatformError> {
     Ok(())
 }
 
-pub fn get_asset_bytes(asset: Asset) -> Result<Cow<'static, [u8]>, AssetError> {
-    match asset {
-        Asset::Wav1 => Ok(Cow::Borrowed(include_bytes!("../../assets/game/sound/waka/1.ogg"))),
-        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::AtlasImage => Ok(Cow::Borrowed(include_bytes!("../../assets/game/atlas.png"))),
-        Asset::Font => Ok(Cow::Borrowed(include_bytes!("../../assets/game/TerminalVector.ttf"))),
-    }
-}
-
 pub fn rng() -> ThreadRng {
     rand::rng()
 }
@@ -78,7 +70,7 @@ pub fn rng() -> ThreadRng {
 /// Windows-only
 #[cfg(windows)]
 fn is_output_setup() -> Result<Option<&'static str>, PlatformError> {
-    use tracing::{debug, warn};
+    use tracing::{trace, warn};
 
     use windows::Win32::Storage::FileSystem::{
         GetFileType, FILE_TYPE_CHAR, FILE_TYPE_DISK, FILE_TYPE_PIPE, FILE_TYPE_REMOTE, FILE_TYPE_UNKNOWN,
@@ -113,7 +105,7 @@ fn is_output_setup() -> Result<Option<&'static str>, PlatformError> {
         }
     };
 
-    debug!("File type: {file_type:?}, well known: {well_known}");
+    trace!("File type: {file_type:?}, well known: {well_known}");
 
     // If it's anything recognizable and valid, assume that a parent process has setup an output stream
     Ok(well_known.then_some(file_type))

src/platform/emscripten.rs

@@ -1,21 +1,15 @@
 //! Emscripten platform implementation.
 
-use crate::asset::Asset;
-use crate::error::{AssetError, PlatformError};
+use crate::error::PlatformError;
 use crate::formatter::CustomFormatter;
 use rand::{rngs::SmallRng, SeedableRng};
-use sdl2::rwops::RWops;
-use std::borrow::Cow;
 use std::ffi::CString;
-use std::io::{self, Read, Write};
+use std::io::{self, Write};
 use std::time::Duration;
 
 // Emscripten FFI functions
-#[allow(dead_code)]
 extern "C" {
     fn emscripten_sleep(ms: u32);
-    fn emscripten_get_element_css_size(target: *const u8, width: *mut f64, height: *mut f64) -> i32;
-    // Standard C functions that Emscripten redirects to console
     fn printf(format: *const u8, ...) -> i32;
 }
 
@@ -65,32 +59,6 @@ impl Write for EmscriptenConsoleWriter {
     }
 }
 
-#[allow(dead_code)]
-pub fn get_canvas_size() -> Option<(u32, u32)> {
-    let mut width = 0.0;
-    let mut height = 0.0;
-
-    unsafe {
-        emscripten_get_element_css_size(c"canvas".as_ptr().cast(), &mut width, &mut height);
-        if width == 0.0 || height == 0.0 {
-            return None;
-        }
-    }
-    Some((width as u32, height as u32))
-}
-
-pub fn get_asset_bytes(asset: Asset) -> Result<Cow<'static, [u8]>, AssetError> {
-    let path = format!("assets/game/{}", asset.path());
-    let mut rwops = RWops::from_file(&path, "rb").map_err(|_| AssetError::NotFound(asset.path().to_string()))?;
-
-    let len = rwops.len().ok_or_else(|| AssetError::NotFound(asset.path().to_string()))?;
-
-    let mut buf = vec![0u8; len];
-    rwops.read_exact(&mut buf).map_err(|e| AssetError::Io(io::Error::other(e)))?;
-
-    Ok(Cow::Owned(buf))
-}
-
 pub fn rng() -> SmallRng {
     SmallRng::from_os_rng()
 }

src/platform/mod.rs

@@ -3,10 +3,12 @@
 #[cfg(not(target_os = "emscripten"))]
 mod desktop;
 #[cfg(not(target_os = "emscripten"))]
-pub mod tracing_buffer;
-#[cfg(not(target_os = "emscripten"))]
 pub use desktop::*;
 
+/// Tracing buffer is only used on Windows.
+#[cfg(windows)]
+pub mod tracing_buffer;
+
 #[cfg(target_os = "emscripten")]
 pub use emscripten::*;
 #[cfg(target_os = "emscripten")]

src/platform/tracing_buffer.rs

@@ -1,4 +1,3 @@
-#![allow(dead_code)]
 //! Buffered tracing setup for handling logs before console attachment.
 
 use crate::formatter::CustomFormatter;

src/systems/animation/blinking.rs

@@ -1,14 +1,10 @@
 use bevy_ecs::{
     component::Component,
-    entity::Entity,
     query::{Has, With},
-    system::{Commands, Query, Res},
+    system::{Query, Res},
 };
 
-use crate::systems::{
-    components::{DeltaTime, Renderable},
-    Frozen, Hidden,
-};
+use crate::systems::{DeltaTime, Frozen, Renderable, Visibility};
 
 #[derive(Component, Debug)]
 pub struct Blinking {
@@ -31,18 +27,11 @@ impl Blinking {
 /// accumulating ticks and toggling visibility when the specified interval is reached.
 /// Uses integer arithmetic for deterministic behavior.
 #[allow(clippy::type_complexity)]
-pub fn blinking_system(
-    mut commands: Commands,
-    time: Res<DeltaTime>,
-    mut query: Query<(Entity, &mut Blinking, Has<Hidden>, Has<Frozen>), With<Renderable>>,
-) {
-    for (entity, mut blinking, hidden, frozen) in query.iter_mut() {
-        // If the entity is frozen, blinking is disabled and the entity is unhidden (if it was hidden)
+pub fn blinking_system(time: Res<DeltaTime>, mut query: Query<(&mut Blinking, &mut Visibility, Has<Frozen>), With<Renderable>>) {
+    for (mut blinking, mut visibility, frozen) in query.iter_mut() {
+        // If the entity is frozen, blinking is disabled and the entity is made visible
         if frozen {
-            if hidden {
-                commands.entity(entity).remove::<Hidden>();
-            }
-
+            visibility.show();
             continue;
         }
 
@@ -52,11 +41,7 @@ pub fn blinking_system(
         // Handle zero interval case (immediate toggling)
         if blinking.interval_ticks == 0 {
             if time.ticks > 0 {
-                if hidden {
-                    commands.entity(entity).remove::<Hidden>();
-                } else {
-                    commands.entity(entity).insert(Hidden);
-                }
+                visibility.toggle();
             }
             continue;
         }
@@ -72,14 +57,10 @@ pub fn blinking_system(
         // Update the timer to the remainder after complete intervals
         blinking.tick_timer %= blinking.interval_ticks;
 
-        // Toggle the Hidden component for each complete interval
+        // Toggle the visibility for each complete interval
         // Since toggling twice is a no-op, we only need to toggle if the count is odd
         if complete_intervals % 2 == 1 {
-            if hidden {
-                commands.entity(entity).remove::<Hidden>();
-            } else {
-                commands.entity(entity).insert(Hidden);
-            }
+            visibility.toggle();
         }
     }
 }

src/systems/animation/directional.rs

@@ -0,0 +1,104 @@
+use bevy_ecs::{
+    component::Component,
+    query::{Has, Or, With, Without},
+    system::{Query, Res},
+};
+
+use crate::{
+    systems::{DeltaTime, Dying, Frozen, LinearAnimation, Looping, Position, Renderable, Velocity},
+    texture::animated::DirectionalTiles,
+};
+
+/// Directional animation component with shared timing across all directions
+#[derive(Component, Clone)]
+pub struct DirectionalAnimation {
+    pub moving_tiles: DirectionalTiles,
+    pub stopped_tiles: DirectionalTiles,
+    pub current_frame: usize,
+    pub time_bank: u16,
+    pub frame_duration: u16,
+}
+
+impl DirectionalAnimation {
+    /// Creates a new directional animation with the given tiles and frame duration
+    pub fn new(moving_tiles: DirectionalTiles, stopped_tiles: DirectionalTiles, frame_duration: u16) -> Self {
+        Self {
+            moving_tiles,
+            stopped_tiles,
+            current_frame: 0,
+            time_bank: 0,
+            frame_duration,
+        }
+    }
+}
+
+/// Updates directional animated entities with synchronized timing across directions.
+///
+/// This runs before the render system to update sprites based on current direction and movement state.
+/// All directions share the same frame timing to ensure perfect synchronization.
+pub fn directional_render_system(
+    dt: Res<DeltaTime>,
+    mut query: Query<(&Position, &Velocity, &mut DirectionalAnimation, &mut Renderable, Has<Frozen>)>,
+) {
+    let ticks = (dt.seconds * 60.0).round() as u16; // Convert from seconds to ticks at 60 ticks/sec
+
+    for (position, velocity, mut anim, mut renderable, frozen) in query.iter_mut() {
+        let stopped = matches!(position, Position::Stopped { .. });
+
+        // Only tick animation when moving to preserve stopped frame
+        if !stopped && !frozen {
+            // Tick shared animation state
+            anim.time_bank += ticks;
+            while anim.time_bank >= anim.frame_duration {
+                anim.time_bank -= anim.frame_duration;
+                anim.current_frame += 1;
+            }
+        }
+
+        // Get tiles for current direction and movement state
+        let tiles = if stopped {
+            anim.stopped_tiles.get(velocity.direction)
+        } else {
+            anim.moving_tiles.get(velocity.direction)
+        };
+
+        if !tiles.is_empty() {
+            let new_tile = tiles.get_tile(anim.current_frame);
+            if renderable.sprite != new_tile {
+                renderable.sprite = new_tile;
+            }
+        }
+    }
+}
+
+/// System that updates `Renderable` sprites for entities with `LinearAnimation`.
+#[allow(clippy::type_complexity)]
+pub fn linear_render_system(
+    dt: Res<DeltaTime>,
+    mut query: Query<(&mut LinearAnimation, &mut Renderable, Has<Looping>), Or<(Without<Frozen>, With<Dying>)>>,
+) {
+    for (mut anim, mut renderable, looping) in query.iter_mut() {
+        if anim.finished {
+            continue;
+        }
+
+        anim.time_bank += dt.ticks as u16;
+        let frames_to_advance = (anim.time_bank / anim.frame_duration) as usize;
+
+        if frames_to_advance == 0 {
+            continue;
+        }
+
+        let total_frames = anim.tiles.len();
+
+        if !looping && anim.current_frame + frames_to_advance >= total_frames {
+            anim.finished = true;
+            anim.current_frame = total_frames - 1;
+        } else {
+            anim.current_frame += frames_to_advance;
+        }
+
+        anim.time_bank %= anim.frame_duration;
+        renderable.sprite = anim.tiles.get_tile(anim.current_frame);
+    }
+}

src/systems/animation/linear.rs

@@ -0,0 +1,30 @@
+use crate::texture::animated::TileSequence;
+use bevy_ecs::component::Component;
+use bevy_ecs::resource::Resource;
+
+/// Tag component to mark animations that should loop when they reach the end
+#[derive(Component, Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Looping;
+
+/// Linear animation component for non-directional animations (frightened ghosts)
+#[derive(Component, Resource, Clone)]
+pub struct LinearAnimation {
+    pub tiles: TileSequence,
+    pub current_frame: usize,
+    pub time_bank: u16,
+    pub frame_duration: u16,
+    pub finished: bool,
+}
+
+impl LinearAnimation {
+    /// Creates a new linear animation with the given tiles and frame duration
+    pub fn new(tiles: TileSequence, frame_duration: u16) -> Self {
+        Self {
+            tiles,
+            current_frame: 0,
+            time_bank: 0,
+            frame_duration,
+            finished: false,
+        }
+    }
+}

src/systems/animation/mod.rs

@@ -0,0 +1,7 @@
+mod blinking;
+mod directional;
+mod linear;
+
+pub use self::blinking::*;
+pub use self::directional::*;
+pub use self::linear::*;

src/systems/audio.rs

@@ -9,8 +9,9 @@ use bevy_ecs::{
     resource::Resource,
     system::{NonSendMut, ResMut},
 };
+use tracing::{debug, trace};
 
-use crate::{audio::Audio, error::GameError};
+use crate::{audio::Audio, audio::Sound, error::GameError};
 
 /// Resource for tracking audio state
 #[derive(Resource, Debug, Clone, Default)]
@@ -24,8 +25,16 @@ pub struct AudioState {
 /// Events for triggering audio playback
 #[derive(Event, Debug, Clone, Copy, PartialEq, Eq)]
 pub enum AudioEvent {
-    /// Play the "eat" sound when Pac-Man consumes a pellet
-    PlayEat,
+    /// Play a specific sound effect
+    PlaySound(Sound),
+    /// Play the cycling waka sound variant
+    Waka,
+    /// Stop all currently playing sounds
+    StopAll,
+    /// Pause all sounds
+    Pause,
+    /// Resume all sounds
+    Resume,
 }
 
 /// Non-send resource wrapper for SDL2 audio system
@@ -45,18 +54,62 @@ pub fn audio_system(
 ) {
     // Set mute state if it has changed
     if audio.0.is_muted() != audio_state.muted {
+        debug!(muted = audio_state.muted, "Audio mute state changed");
         audio.0.set_mute(audio_state.muted);
     }
 
     // Process audio events
     for event in audio_events.read() {
         match event {
-            AudioEvent::PlayEat => {
+            AudioEvent::Waka => {
                 if !audio.0.is_disabled() && !audio_state.muted {
-                    audio.0.eat();
+                    trace!(sound_index = audio_state.sound_index, "Playing eat sound");
+                    audio.0.waka();
                     // Update the sound index for cycling through sounds
                     audio_state.sound_index = (audio_state.sound_index + 1) % 4;
                     // 4 eat sounds available
+                } else {
+                    debug!(
+                        disabled = audio.0.is_disabled(),
+                        muted = audio_state.muted,
+                        "Skipping eat sound due to audio state"
+                    );
+                }
+            }
+            AudioEvent::PlaySound(sound) => {
+                if !audio.0.is_disabled() && !audio_state.muted {
+                    trace!(?sound, "Playing sound");
+                    audio.0.play(*sound);
+                } else {
+                    debug!(
+                        disabled = audio.0.is_disabled(),
+                        muted = audio_state.muted,
+                        "Skipping sound due to audio state"
+                    );
+                }
+            }
+            AudioEvent::StopAll => {
+                if !audio.0.is_disabled() {
+                    debug!("Stopping all audio");
+                    audio.0.stop_all();
+                } else {
+                    debug!("Audio disabled, ignoring stop all request");
+                }
+            }
+            AudioEvent::Pause => {
+                if !audio.0.is_disabled() {
+                    debug!("Pausing all audio");
+                    audio.0.pause_all();
+                } else {
+                    debug!("Audio disabled, ignoring pause all request");
+                }
+            }
+            AudioEvent::Resume => {
+                if !audio.0.is_disabled() {
+                    debug!("Resuming all audio");
+                    audio.0.resume_all();
+                } else {
+                    debug!("Audio disabled, ignoring resume all request");
                 }
             }
         }

src/systems/collision.rs

@@ -1,15 +1,26 @@
-use bevy_ecs::component::Component;
-use bevy_ecs::entity::Entity;
-use bevy_ecs::event::{EventReader, EventWriter};
-use bevy_ecs::query::With;
-use bevy_ecs::system::{Query, Res, ResMut};
+use bevy_ecs::{
+    component::Component,
+    entity::Entity,
+    event::EventWriter,
+    observer::Trigger,
+    query::With,
+    system::{Commands, Query, Res, ResMut},
+};
+use tracing::{debug, trace, warn};
 
-use crate::error::GameError;
-use crate::events::GameEvent;
-use crate::map::builder::Map;
-use crate::systems::movement::Position;
-use crate::systems::{AudioEvent, Ghost, GhostState, PlayerControlled, ScoreResource};
+use crate::audio::Sound;
+use crate::{
+    constants,
+    systems::{movement::Position, AudioEvent, DyingSequence, FruitSprites, GameStage, Ghost, ScoreResource, SpawnTrigger},
+};
+use crate::{error::GameError, systems::GhostState};
+use crate::{
+    events::{CollisionTrigger, StageTransition},
+    systems::PelletCount,
+};
+use crate::{map::builder::Map, systems::EntityType};
 
+/// A component for defining the collision area of an entity.
 #[derive(Component)]
 pub struct Collider {
     pub size: f32,
@@ -52,22 +63,23 @@ pub fn check_collision(
     Ok(collider1.collides_with(collider2.size, distance))
 }
 
-/// Detects overlapping entities and generates collision events for gameplay systems.
+/// Detects overlapping entities and triggers collision observers immediately.
 ///
 /// Performs distance-based collision detection between Pac-Man and collectible items
-/// using each entity's position and collision radius. When entities overlap, emits
-/// a `GameEvent::Collision` for the item system to handle scoring and removal.
+/// using each entity's position and collision radius. When entities overlap, triggers
+/// collision observers for immediate handling without race conditions.
 /// Collision detection accounts for both entities being in motion and supports
 /// circular collision boundaries for accurate gameplay feel.
 ///
 /// Also detects collisions between Pac-Man and ghosts for gameplay mechanics like
 /// power pellet effects, ghost eating, and player death.
+#[allow(clippy::too_many_arguments)]
 pub fn collision_system(
     map: Res<Map>,
     pacman_query: Query<(Entity, &Position, &Collider), With<PacmanCollider>>,
     item_query: Query<(Entity, &Position, &Collider), With<ItemCollider>>,
-    ghost_query: Query<(Entity, &Position, &Collider), With<GhostCollider>>,
-    mut events: EventWriter<GameEvent>,
+    ghost_query: Query<(Entity, &Position, &Collider, &Ghost, &GhostState), With<GhostCollider>>,
+    mut commands: Commands,
     mut errors: EventWriter<GameError>,
 ) {
     // Check PACMAN × ITEM collisions
@@ -76,7 +88,8 @@ pub fn collision_system(
             match check_collision(pacman_pos, pacman_collider, item_pos, item_collider, &map) {
                 Ok(colliding) => {
                     if colliding {
-                        events.write(GameEvent::Collision(pacman_entity, item_entity));
+                        trace!("Item collision detected");
+                        commands.trigger(CollisionTrigger::ItemCollision { item: item_entity });
                     }
                 }
                 Err(e) => {
@@ -89,12 +102,19 @@ pub fn collision_system(
         }
 
         // Check PACMAN × GHOST collisions
-        for (ghost_entity, ghost_pos, ghost_collider) in ghost_query.iter() {
+        for (ghost_entity, ghost_pos, ghost_collider, ghost, ghost_state) in ghost_query.iter() {
             match check_collision(pacman_pos, pacman_collider, ghost_pos, ghost_collider, &map) {
                 Ok(colliding) => {
-                    if colliding {
-                        events.write(GameEvent::Collision(pacman_entity, ghost_entity));
+                    if !colliding || matches!(*ghost_state, GhostState::Eyes) {
+                        continue;
                     }
+
+                    trace!(ghost = ?ghost, "Ghost collision detected");
+                    commands.trigger(CollisionTrigger::GhostCollision {
+                        pacman: pacman_entity,
+                        ghost: ghost_entity,
+                        ghost_type: *ghost,
+                    });
                 }
                 Err(e) => {
                     errors.write(GameError::InvalidState(format!(
@@ -107,43 +127,136 @@ pub fn collision_system(
     }
 }
 
-pub fn ghost_collision_system(
-    mut collision_events: EventReader<GameEvent>,
+/// Observer for handling ghost collisions immediately when they occur
+#[allow(clippy::too_many_arguments)]
+pub fn ghost_collision_observer(
+    trigger: Trigger<CollisionTrigger>,
+    mut stage_events: EventWriter<StageTransition>,
     mut score: ResMut<ScoreResource>,
-    pacman_query: Query<(), With<PlayerControlled>>,
-    ghost_query: Query<(Entity, &Ghost), With<GhostCollider>>,
+    mut game_state: ResMut<GameStage>,
     mut ghost_state_query: Query<&mut GhostState>,
     mut events: EventWriter<AudioEvent>,
 ) {
-    for event in collision_events.read() {
-        if let GameEvent::Collision(entity1, entity2) = event {
-            // Check if one is Pacman and the other is a ghost
-            let (_pacman_entity, ghost_entity) = if pacman_query.get(*entity1).is_ok() && ghost_query.get(*entity2).is_ok() {
-                (*entity1, *entity2)
-            } else if pacman_query.get(*entity2).is_ok() && ghost_query.get(*entity1).is_ok() {
-                (*entity2, *entity1)
+    if let CollisionTrigger::GhostCollision {
+        pacman: _pacman,
+        ghost,
+        ghost_type,
+    } = *trigger
+    {
+        // Check if Pac-Man is already dying
+        if matches!(*game_state, GameStage::PlayerDying(_)) {
+            return;
+        }
+
+        // Check if the ghost is frightened
+        if let Ok(mut ghost_state) = ghost_state_query.get_mut(ghost) {
+            // Check if ghost is in frightened state
+            if matches!(*ghost_state, GhostState::Frightened { .. }) {
+                // Pac-Man eats the ghost
+                // Add score (200 points per ghost eaten)
+                debug!(ghost = ?ghost_type, score_added = 200, new_score = score.0 + 200, "Pacman ate frightened ghost");
+                score.0 += 200;
+
+                *ghost_state = GhostState::Eyes;
+
+                // Enter short pause to show bonus points, hide ghost, then set Eyes after pause
+                // Request transition via event so stage_system can process it
+                stage_events.write(StageTransition::GhostEatenPause {
+                    ghost_entity: ghost,
+                    ghost_type,
+                });
+
+                // Play ghost eaten sound
+                events.write(AudioEvent::PlaySound(Sound::Ghost));
+            } else if matches!(*ghost_state, GhostState::Normal) {
+                // Pac-Man dies
+                warn!(ghost = ?ghost_type, "Pacman hit by normal ghost, player dies");
+                *game_state = GameStage::PlayerDying(DyingSequence::Frozen { remaining_ticks: 60 });
+                events.write(AudioEvent::StopAll);
             } else {
-                continue;
-            };
+                trace!(ghost_state = ?*ghost_state, "Ghost collision ignored due to state");
+            }
+        }
+    }
+}
 
-            // Check if the ghost is frightened
-            if let Ok((ghost_ent, _ghost_type)) = ghost_query.get(ghost_entity) {
-                if let Ok(mut ghost_state) = ghost_state_query.get_mut(ghost_ent) {
-                    // Check if ghost is in frightened state
-                    if matches!(*ghost_state, GhostState::Frightened { .. }) {
-                        // Pac-Man eats the ghost
-                        // Add score (200 points per ghost eaten)
-                        score.0 += 200;
+/// Observer for handling item collisions immediately when they occur
+#[allow(clippy::too_many_arguments)]
+pub fn item_collision_observer(
+    trigger: Trigger<CollisionTrigger>,
+    mut commands: Commands,
+    mut score: ResMut<ScoreResource>,
+    mut pellet_count: ResMut<PelletCount>,
+    item_query: Query<(Entity, &EntityType, &Position), With<ItemCollider>>,
+    mut ghost_query: Query<&mut GhostState, With<GhostCollider>>,
+    mut fruit_sprites: ResMut<FruitSprites>,
+    mut events: EventWriter<AudioEvent>,
+) {
+    if let CollisionTrigger::ItemCollision { item } = *trigger {
+        // Get the item type and update score
+        if let Ok((item_ent, entity_type, position)) = item_query.get(item) {
+            if let Some(score_value) = entity_type.score_value() {
+                trace!(item_entity = ?item_ent, item_type = ?entity_type, score_value, new_score = score.0 + score_value, "Item collected by player");
+                score.0 += score_value;
 
-                        // Set ghost state to Eyes
-                        *ghost_state = GhostState::Eyes;
+                // Remove the collected item
+                commands.entity(item_ent).despawn();
 
-                        // Play eat sound
-                        events.write(AudioEvent::PlayEat);
-                    } else {
-                        // Pac-Man dies (this would need a death system)
+                // Track pellet consumption for fruit spawning
+                if *entity_type == EntityType::Pellet {
+                    pellet_count.0 += 1;
+                    trace!(pellet_count = pellet_count.0, "Pellet consumed");
+
+                    // Check if we should spawn a fruit
+                    if pellet_count.0 == 5 || pellet_count.0 == 170 {
+                        debug!(pellet_count = pellet_count.0, "Fruit spawn milestone reached");
+                        commands.trigger(SpawnTrigger::Fruit);
                     }
                 }
+
+                // Trigger bonus points effect if a fruit is collected
+                if let EntityType::Fruit(fruit) = *entity_type {
+                    fruit_sprites.0.push(fruit);
+
+                    commands.trigger(SpawnTrigger::Bonus {
+                        position: *position,
+                        value: entity_type.score_value().unwrap(),
+                        ttl: 60 * 2,
+                    });
+                }
+
+                // Trigger audio if appropriate
+                if entity_type.is_collectible() {
+                    match *entity_type {
+                        EntityType::Fruit(_) => {
+                            events.write(AudioEvent::PlaySound(Sound::Fruit));
+                        }
+                        EntityType::Pellet | EntityType::PowerPellet => {
+                            events.write(AudioEvent::Waka);
+                        }
+                        _ => {}
+                    }
+                }
+
+                // Make non-eaten ghosts frightened when power pellet is collected
+                if matches!(*entity_type, EntityType::PowerPellet) {
+                    debug!(
+                        duration_ticks = constants::animation::GHOST_FRIGHTENED_TICKS,
+                        "Power pellet collected, frightening ghosts"
+                    );
+                    for mut ghost_state in ghost_query.iter_mut() {
+                        if matches!(*ghost_state, GhostState::Normal) {
+                            *ghost_state = GhostState::new_frightened(
+                                constants::animation::GHOST_FRIGHTENED_TICKS,
+                                constants::animation::GHOST_FRIGHTENED_FLASH_START_TICKS,
+                            );
+                        }
+                    }
+                    debug!(
+                        frightened_count = ghost_query.iter().count(),
+                        "Ghosts set to frightened state"
+                    );
+                }
             }
         }
     }

src/systems/common/bundles.rs

@@ -0,0 +1,43 @@
+use bevy_ecs::bundle::Bundle;
+
+use crate::systems::{
+    BufferedDirection, Collider, DirectionalAnimation, EntityType, Ghost, GhostCollider, GhostState, ItemCollider,
+    LastAnimationState, MovementModifiers, PacmanCollider, PlayerControlled, Position, Renderable, Velocity,
+};
+
+#[derive(Bundle)]
+pub struct PlayerBundle {
+    pub player: PlayerControlled,
+    pub position: Position,
+    pub velocity: Velocity,
+    pub buffered_direction: BufferedDirection,
+    pub sprite: Renderable,
+    pub directional_animation: DirectionalAnimation,
+    pub entity_type: EntityType,
+    pub collider: Collider,
+    pub movement_modifiers: MovementModifiers,
+    pub pacman_collider: PacmanCollider,
+}
+
+#[derive(Bundle)]
+pub struct ItemBundle {
+    pub position: Position,
+    pub sprite: Renderable,
+    pub entity_type: EntityType,
+    pub collider: Collider,
+    pub item_collider: ItemCollider,
+}
+
+#[derive(Bundle)]
+pub struct GhostBundle {
+    pub ghost: Ghost,
+    pub position: Position,
+    pub velocity: Velocity,
+    pub sprite: Renderable,
+    pub directional_animation: DirectionalAnimation,
+    pub entity_type: EntityType,
+    pub collider: Collider,
+    pub ghost_collider: GhostCollider,
+    pub ghost_state: GhostState,
+    pub last_animation_state: LastAnimationState,
+}

src/systems/common/components.rs

@@ -0,0 +1,106 @@
+use bevy_ecs::{component::Component, resource::Resource};
+
+use crate::{map::graph::TraversalFlags, systems::FruitType};
+
+/// A tag component denoting the type of entity.
+#[derive(Component, Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum EntityType {
+    Player,
+    Ghost,
+    Pellet,
+    PowerPellet,
+    Fruit(FruitType),
+    Effect,
+}
+
+impl EntityType {
+    /// Returns the traversal flags for this entity type.
+    pub fn traversal_flags(&self) -> TraversalFlags {
+        match self {
+            EntityType::Player => TraversalFlags::PACMAN,
+            EntityType::Ghost => TraversalFlags::GHOST,
+            _ => TraversalFlags::empty(), // Static entities don't traverse
+        }
+    }
+    pub fn score_value(&self) -> Option<u32> {
+        match self {
+            EntityType::Pellet => Some(10),
+            EntityType::PowerPellet => Some(50),
+            EntityType::Fruit(fruit_type) => Some(fruit_type.score_value()),
+            _ => None,
+        }
+    }
+
+    pub fn is_collectible(&self) -> bool {
+        matches!(self, EntityType::Pellet | EntityType::PowerPellet | EntityType::Fruit(_))
+    }
+}
+
+#[derive(Resource)]
+pub struct GlobalState {
+    pub exit: bool,
+}
+
+#[derive(Resource)]
+pub struct ScoreResource(pub u32);
+
+#[derive(Resource)]
+pub struct DeltaTime {
+    /// Floating-point delta time in seconds
+    pub seconds: f32,
+    /// Integer tick delta (usually 1, but can be different for testing)
+    pub ticks: u32,
+}
+
+#[allow(dead_code)]
+impl DeltaTime {
+    /// Creates a new DeltaTime from a floating-point delta time in seconds
+    ///
+    /// While this method exists as a helper, it does not mean that seconds and ticks are interchangeable.
+    pub fn from_seconds(seconds: f32) -> Self {
+        Self {
+            seconds,
+            ticks: (seconds * 60.0).round() as u32,
+        }
+    }
+
+    /// Creates a new DeltaTime from an integer tick delta
+    ///
+    /// While this method exists as a helper, it does not mean that seconds and ticks are interchangeable.
+    pub fn from_ticks(ticks: u32) -> Self {
+        Self {
+            seconds: ticks as f32 / 60.0,
+            ticks,
+        }
+    }
+}
+
+/// Movement modifiers that can affect Pac-Man's speed or handling.
+#[derive(Component, Debug, Clone, Copy)]
+pub struct MovementModifiers {
+    /// Multiplier applied to base speed (e.g., tunnels)
+    pub speed_multiplier: f32,
+    /// True when currently in a tunnel slowdown region
+    pub tunnel_slowdown_active: bool,
+}
+
+impl Default for MovementModifiers {
+    fn default() -> Self {
+        Self {
+            speed_multiplier: 1.0,
+            tunnel_slowdown_active: false,
+        }
+    }
+}
+
+/// Tag component for entities that should be frozen during startup
+#[derive(Component, Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Frozen;
+
+/// Component for HUD life sprite entities.
+/// Each life sprite entity has an index indicating its position from left to right (0, 1, 2, etc.).
+/// This mostly functions as a tag component for sprites.
+#[derive(Component, Debug, Clone, Copy)]
+pub struct PlayerLife {
+    pub index: u32,
+}

src/systems/common/mod.rs

@@ -0,0 +1,5 @@
+pub mod bundles;
+pub mod components;
+
+pub use self::bundles::*;
+pub use self::components::*;

src/systems/components.rs

@@ -1,392 +0,0 @@
-use std::collections::HashMap;
-
-use bevy_ecs::{bundle::Bundle, component::Component, resource::Resource};
-use bitflags::bitflags;
-
-use crate::{
-    map::graph::TraversalFlags,
-    systems::{
-        movement::{BufferedDirection, Position, Velocity},
-        Collider, GhostCollider, ItemCollider, PacmanCollider,
-    },
-    texture::{
-        animated::{DirectionalTiles, TileSequence},
-        sprite::AtlasTile,
-    },
-};
-
-/// A tag component for entities that are controlled by the player.
-#[derive(Default, Component)]
-pub struct PlayerControlled;
-
-#[derive(Component, Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub enum Ghost {
-    Blinky,
-    Pinky,
-    Inky,
-    Clyde,
-}
-
-impl Ghost {
-    /// Returns the ghost type name for atlas lookups.
-    pub fn as_str(self) -> &'static str {
-        match self {
-            Ghost::Blinky => "blinky",
-            Ghost::Pinky => "pinky",
-            Ghost::Inky => "inky",
-            Ghost::Clyde => "clyde",
-        }
-    }
-
-    /// Returns the base movement speed for this ghost type.
-    pub fn base_speed(self) -> f32 {
-        match self {
-            Ghost::Blinky => 1.0,
-            Ghost::Pinky => 0.95,
-            Ghost::Inky => 0.9,
-            Ghost::Clyde => 0.85,
-        }
-    }
-
-    /// Returns the ghost's color for debug rendering.
-    #[allow(dead_code)]
-    pub fn debug_color(&self) -> sdl2::pixels::Color {
-        match self {
-            Ghost::Blinky => sdl2::pixels::Color::RGB(255, 0, 0),    // Red
-            Ghost::Pinky => sdl2::pixels::Color::RGB(255, 182, 255), // Pink
-            Ghost::Inky => sdl2::pixels::Color::RGB(0, 255, 255),    // Cyan
-            Ghost::Clyde => sdl2::pixels::Color::RGB(255, 182, 85),  // Orange
-        }
-    }
-}
-
-/// A tag component denoting the type of entity.
-#[derive(Component, Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub enum EntityType {
-    Player,
-    Ghost,
-    Pellet,
-    PowerPellet,
-}
-
-impl EntityType {
-    /// Returns the traversal flags for this entity type.
-    pub fn traversal_flags(&self) -> TraversalFlags {
-        match self {
-            EntityType::Player => TraversalFlags::PACMAN,
-            EntityType::Ghost => TraversalFlags::GHOST,
-            _ => TraversalFlags::empty(), // Static entities don't traverse
-        }
-    }
-    pub fn score_value(&self) -> Option<u32> {
-        match self {
-            EntityType::Pellet => Some(10),
-            EntityType::PowerPellet => Some(50),
-            _ => None,
-        }
-    }
-
-    pub fn is_collectible(&self) -> bool {
-        matches!(self, EntityType::Pellet | EntityType::PowerPellet)
-    }
-}
-
-/// A component for entities that have a sprite, with a layer for ordering.
-///
-/// This is intended to be modified by other entities allowing animation.
-#[derive(Component)]
-pub struct Renderable {
-    pub sprite: AtlasTile,
-    pub layer: u8,
-}
-
-/// Directional animation component with shared timing across all directions
-#[derive(Component, Clone, Copy)]
-pub struct DirectionalAnimation {
-    pub moving_tiles: DirectionalTiles,
-    pub stopped_tiles: DirectionalTiles,
-    pub current_frame: usize,
-    pub time_bank: u16,
-    pub frame_duration: u16,
-}
-
-impl DirectionalAnimation {
-    /// Creates a new directional animation with the given tiles and frame duration
-    pub fn new(moving_tiles: DirectionalTiles, stopped_tiles: DirectionalTiles, frame_duration: u16) -> Self {
-        Self {
-            moving_tiles,
-            stopped_tiles,
-            current_frame: 0,
-            time_bank: 0,
-            frame_duration,
-        }
-    }
-}
-
-/// Linear animation component for non-directional animations (frightened ghosts)
-#[derive(Component, Clone, Copy)]
-pub struct LinearAnimation {
-    pub tiles: TileSequence,
-    pub current_frame: usize,
-    pub time_bank: u16,
-    pub frame_duration: u16,
-}
-
-impl LinearAnimation {
-    /// Creates a new linear animation with the given tiles and frame duration
-    pub fn new(tiles: TileSequence, frame_duration: u16) -> Self {
-        Self {
-            tiles,
-            current_frame: 0,
-            time_bank: 0,
-            frame_duration,
-        }
-    }
-}
-
-bitflags! {
-    #[derive(Component, Default, Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
-    pub struct CollisionLayer: u8 {
-        const PACMAN = 1 << 0;
-        const GHOST = 1 << 1;
-        const ITEM = 1 << 2;
-    }
-}
-
-#[derive(Resource)]
-pub struct GlobalState {
-    pub exit: bool,
-}
-
-#[derive(Resource)]
-pub struct ScoreResource(pub u32);
-
-#[derive(Resource)]
-pub struct DeltaTime {
-    /// Floating-point delta time in seconds
-    pub seconds: f32,
-    /// Integer tick delta (usually 1, but can be different for testing)
-    pub ticks: u32,
-}
-
-#[allow(dead_code)]
-impl DeltaTime {
-    /// Creates a new DeltaTime from a floating-point delta time in seconds
-    ///
-    /// While this method exists as a helper, it does not mean that seconds and ticks are interchangeable.
-    pub fn from_seconds(seconds: f32) -> Self {
-        Self {
-            seconds,
-            ticks: (seconds * 60.0).round() as u32,
-        }
-    }
-
-    /// Creates a new DeltaTime from an integer tick delta
-    ///
-    /// While this method exists as a helper, it does not mean that seconds and ticks are interchangeable.
-    pub fn from_ticks(ticks: u32) -> Self {
-        Self {
-            seconds: ticks as f32 / 60.0,
-            ticks,
-        }
-    }
-}
-
-/// Movement modifiers that can affect Pac-Man's speed or handling.
-#[derive(Component, Debug, Clone, Copy)]
-pub struct MovementModifiers {
-    /// Multiplier applied to base speed (e.g., tunnels)
-    pub speed_multiplier: f32,
-    /// True when currently in a tunnel slowdown region
-    pub tunnel_slowdown_active: bool,
-}
-
-impl Default for MovementModifiers {
-    fn default() -> Self {
-        Self {
-            speed_multiplier: 1.0,
-            tunnel_slowdown_active: false,
-        }
-    }
-}
-
-/// Tag component for entities that should be frozen during startup
-#[derive(Component, Debug, Clone, Copy)]
-pub struct Frozen;
-
-/// Tag component for eaten ghosts
-#[derive(Component, Debug, Clone, Copy)]
-pub struct Eaten;
-
-#[derive(Component, Debug, Clone, Copy)]
-pub enum GhostState {
-    /// Normal ghost behavior - chasing Pac-Man
-    Normal,
-    /// Frightened state after power pellet - ghost can be eaten
-    Frightened {
-        remaining_ticks: u32,
-        flash: bool,
-        remaining_flash_ticks: u32,
-    },
-    /// Eyes state - ghost has been eaten and is returning to ghost house
-    Eyes,
-}
-
-/// Component to track the last animation state for efficient change detection
-#[derive(Component, Debug, Clone, Copy, PartialEq)]
-pub struct LastAnimationState(pub GhostAnimation);
-
-impl GhostState {
-    /// Creates a new frightened state with the specified duration
-    pub fn new_frightened(total_ticks: u32, flash_start_ticks: u32) -> Self {
-        Self::Frightened {
-            remaining_ticks: total_ticks,
-            flash: false,
-            remaining_flash_ticks: flash_start_ticks, // Time until flashing starts
-        }
-    }
-
-    /// Ticks the ghost state, returning true if the state changed.
-    pub fn tick(&mut self) -> bool {
-        if let GhostState::Frightened {
-            remaining_ticks,
-            flash,
-            remaining_flash_ticks,
-        } = self
-        {
-            // Transition out of frightened state
-            if *remaining_ticks == 0 {
-                *self = GhostState::Normal;
-                return true;
-            }
-
-            *remaining_ticks -= 1;
-
-            if *remaining_flash_ticks > 0 {
-                *remaining_flash_ticks = remaining_flash_ticks.saturating_sub(1);
-                if *remaining_flash_ticks == 0 {
-                    *flash = true;
-                    true
-                } else {
-                    false
-                }
-            } else {
-                false
-            }
-        } else {
-            false
-        }
-    }
-
-    /// Returns the appropriate animation state for this ghost state
-    pub fn animation_state(&self) -> GhostAnimation {
-        match self {
-            GhostState::Normal => GhostAnimation::Normal,
-            GhostState::Eyes => GhostAnimation::Eyes,
-            GhostState::Frightened { flash: false, .. } => GhostAnimation::Frightened { flash: false },
-            GhostState::Frightened { flash: true, .. } => GhostAnimation::Frightened { flash: true },
-        }
-    }
-}
-
-/// Enumeration of different ghost animation states.
-/// Note that this is used in micromap which has a fixed size based on the number of variants,
-/// so extending this should be done with caution, and will require updating the micromap's capacity.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub enum GhostAnimation {
-    /// Normal ghost appearance with directional movement animations
-    Normal,
-    /// Blue ghost appearance when vulnerable (power pellet active)
-    Frightened { flash: bool },
-    /// Eyes-only animation when ghost has been consumed by Pac-Man (Eaten state)
-    Eyes,
-}
-
-/// Global resource containing pre-loaded animation sets for all ghost types.
-///
-/// This resource is initialized once during game startup and provides O(1) access
-/// to animation sets for each ghost type. The animation system uses this resource
-/// to efficiently switch between different ghost states without runtime asset loading.
-///
-/// The HashMap is keyed by `Ghost` enum variants (Blinky, Pinky, Inky, Clyde) and
-/// contains the normal directional animation for each ghost type.
-#[derive(Resource)]
-pub struct GhostAnimations {
-    pub normal: HashMap<Ghost, DirectionalAnimation>,
-    pub eyes: DirectionalAnimation,
-    pub frightened: LinearAnimation,
-    pub frightened_flashing: LinearAnimation,
-}
-
-impl GhostAnimations {
-    /// Creates a new GhostAnimations resource with the provided data.
-    pub fn new(
-        normal: HashMap<Ghost, DirectionalAnimation>,
-        eyes: DirectionalAnimation,
-        frightened: LinearAnimation,
-        frightened_flashing: LinearAnimation,
-    ) -> Self {
-        Self {
-            normal,
-            eyes,
-            frightened,
-            frightened_flashing,
-        }
-    }
-
-    /// Gets the normal directional animation for the specified ghost type.
-    pub fn get_normal(&self, ghost_type: &Ghost) -> Option<&DirectionalAnimation> {
-        self.normal.get(ghost_type)
-    }
-
-    /// Gets the eyes animation (shared across all ghosts).
-    pub fn eyes(&self) -> &DirectionalAnimation {
-        &self.eyes
-    }
-
-    /// Gets the frightened animations (shared across all ghosts).
-    pub fn frightened(&self, flash: bool) -> &LinearAnimation {
-        if flash {
-            &self.frightened_flashing
-        } else {
-            &self.frightened
-        }
-    }
-}
-
-#[derive(Bundle)]
-pub struct PlayerBundle {
-    pub player: PlayerControlled,
-    pub position: Position,
-    pub velocity: Velocity,
-    pub buffered_direction: BufferedDirection,
-    pub sprite: Renderable,
-    pub directional_animation: DirectionalAnimation,
-    pub entity_type: EntityType,
-    pub collider: Collider,
-    pub movement_modifiers: MovementModifiers,
-    pub pacman_collider: PacmanCollider,
-}
-
-#[derive(Bundle)]
-pub struct ItemBundle {
-    pub position: Position,
-    pub sprite: Renderable,
-    pub entity_type: EntityType,
-    pub collider: Collider,
-    pub item_collider: ItemCollider,
-}
-
-#[derive(Bundle)]
-pub struct GhostBundle {
-    pub ghost: Ghost,
-    pub position: Position,
-    pub velocity: Velocity,
-    pub sprite: Renderable,
-    pub directional_animation: DirectionalAnimation,
-    pub entity_type: EntityType,
-    pub collider: Collider,
-    pub ghost_collider: GhostCollider,
-    pub ghost_state: GhostState,
-    pub last_animation_state: LastAnimationState,
-}

src/systems/debug.rs

@@ -1,6 +1,4 @@
 //! Debug rendering system
-use std::cmp::Ordering;
-
 use crate::constants::{self, BOARD_PIXEL_OFFSET};
 use crate::map::builder::Map;
 use crate::systems::{Collider, CursorPosition, NodeId, Position, SystemTimings};
@@ -13,6 +11,7 @@ use sdl2::rect::{Point, Rect};
 use sdl2::render::{Canvas, Texture};
 use sdl2::video::Window;
 use smallvec::SmallVec;
+use std::cmp::Ordering;
 use std::collections::{HashMap, HashSet};
 use tracing::warn;
 
@@ -149,6 +148,7 @@ fn transform_position_with_offset(pos: Vec2, scale: f32) -> IVec2 {
 }
 
 /// Renders timing information in the top-left corner of the screen using the debug text atlas
+#[cfg_attr(coverage_nightly, coverage(off))]
 fn render_timing_display(
     canvas: &mut Canvas<Window>,
     timings: &SystemTimings,
@@ -203,6 +203,7 @@ fn render_timing_display(
 }
 
 #[allow(clippy::too_many_arguments)]
+#[cfg_attr(coverage_nightly, coverage(off))]
 pub fn debug_render_system(
     canvas: &mut Canvas<Window>,
     ttf_atlas: &mut TtfAtlasResource,

src/systems/ghost.rs

@@ -1,5 +1,7 @@
+use std::collections::HashMap;
+
 use crate::platform;
-use crate::systems::components::{DirectionalAnimation, Frozen, GhostAnimation, GhostState, LastAnimationState, LinearAnimation};
+use crate::systems::{DirectionalAnimation, Frozen, LinearAnimation, Looping};
 use crate::{
     map::{
         builder::Map,
@@ -7,17 +9,186 @@ use crate::{
         graph::{Edge, TraversalFlags},
     },
     systems::{
-        components::{DeltaTime, Ghost},
+        components::DeltaTime,
         movement::{Position, Velocity},
     },
 };
+use bevy_ecs::component::Component;
+use bevy_ecs::resource::Resource;
+use tracing::{debug, trace, warn};
 
-use crate::systems::GhostAnimations;
 use bevy_ecs::query::Without;
 use bevy_ecs::system::{Commands, Query, Res};
 use rand::seq::IndexedRandom;
 use smallvec::SmallVec;
 
+/// Tag component for Pac-Man during his death animation.
+/// This is mainly because the Frozen tag would stop both movement and animation, while the Dying tag can signal that the animation should continue despite being frozen.
+#[derive(Component, Debug, Clone, Copy)]
+pub struct Dying;
+
+#[derive(Component, Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum Ghost {
+    Blinky,
+    Pinky,
+    Inky,
+    Clyde,
+}
+
+impl Ghost {
+    /// Returns the ghost type name for atlas lookups.
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Ghost::Blinky => "blinky",
+            Ghost::Pinky => "pinky",
+            Ghost::Inky => "inky",
+            Ghost::Clyde => "clyde",
+        }
+    }
+
+    /// Returns the base movement speed for this ghost type.
+    pub fn base_speed(self) -> f32 {
+        match self {
+            Ghost::Blinky => 1.0,
+            Ghost::Pinky => 0.95,
+            Ghost::Inky => 0.9,
+            Ghost::Clyde => 0.85,
+        }
+    }
+}
+
+#[derive(Component, Debug, Clone, Copy, PartialEq, Eq)]
+pub enum GhostState {
+    /// Normal ghost behavior - chasing Pac-Man
+    Normal,
+    /// Frightened state after power pellet - ghost can be eaten
+    Frightened {
+        remaining_ticks: u32,
+        flash: bool,
+        remaining_flash_ticks: u32,
+    },
+    /// Eyes state - ghost has been eaten and is returning to ghost house
+    Eyes,
+}
+
+impl GhostState {
+    /// Creates a new frightened state with the specified duration
+    pub fn new_frightened(total_ticks: u32, flash_start_ticks: u32) -> Self {
+        Self::Frightened {
+            remaining_ticks: total_ticks,
+            flash: false,
+            remaining_flash_ticks: flash_start_ticks, // Time until flashing starts
+        }
+    }
+
+    /// Ticks the ghost state, returning true if the state changed.
+    pub fn tick(&mut self) -> bool {
+        if let GhostState::Frightened {
+            remaining_ticks,
+            flash,
+            remaining_flash_ticks,
+        } = self
+        {
+            // Transition out of frightened state
+            if *remaining_ticks == 0 {
+                *self = GhostState::Normal;
+                return true;
+            }
+
+            *remaining_ticks -= 1;
+
+            if *remaining_flash_ticks > 0 {
+                *remaining_flash_ticks = remaining_flash_ticks.saturating_sub(1);
+                if *remaining_flash_ticks == 0 {
+                    *flash = true;
+                    true
+                } else {
+                    false
+                }
+            } else {
+                false
+            }
+        } else {
+            false
+        }
+    }
+
+    /// Returns the appropriate animation state for this ghost state
+    pub fn animation_state(&self) -> GhostAnimation {
+        match self {
+            GhostState::Normal => GhostAnimation::Normal,
+            GhostState::Eyes => GhostAnimation::Eyes,
+            GhostState::Frightened { flash: false, .. } => GhostAnimation::Frightened { flash: false },
+            GhostState::Frightened { flash: true, .. } => GhostAnimation::Frightened { flash: true },
+        }
+    }
+}
+
+/// Enumeration of different ghost animation states.
+/// Note that this is used in micromap which has a fixed size based on the number of variants,
+/// so extending this should be done with caution, and will require updating the micromap's capacity.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum GhostAnimation {
+    /// Normal ghost appearance with directional movement animations
+    Normal,
+    /// Blue ghost appearance when vulnerable (power pellet active)
+    Frightened { flash: bool },
+    /// Eyes-only animation when ghost has been consumed by Pac-Man (Eaten state)
+    Eyes,
+}
+
+/// Global resource containing pre-loaded animation sets for all ghost types.
+///
+/// This resource is initialized once during game startup and provides O(1) access
+/// to animation sets for each ghost type. The animation system uses this resource
+/// to efficiently switch between different ghost states without runtime asset loading.
+///
+/// The HashMap is keyed by `Ghost` enum variants (Blinky, Pinky, Inky, Clyde) and
+/// contains the normal directional animation for each ghost type.
+#[derive(Resource)]
+pub struct GhostAnimations {
+    pub normal: HashMap<Ghost, DirectionalAnimation>,
+    pub eyes: DirectionalAnimation,
+    pub frightened: LinearAnimation,
+    pub frightened_flashing: LinearAnimation,
+}
+
+impl GhostAnimations {
+    /// Creates a new GhostAnimations resource with the provided data.
+    pub fn new(
+        normal: HashMap<Ghost, DirectionalAnimation>,
+        eyes: DirectionalAnimation,
+        frightened: LinearAnimation,
+        frightened_flashing: LinearAnimation,
+    ) -> Self {
+        Self {
+            normal,
+            eyes,
+            frightened,
+            frightened_flashing,
+        }
+    }
+
+    /// Gets the normal directional animation for the specified ghost type.
+    pub fn get_normal(&self, ghost_type: &Ghost) -> Option<&DirectionalAnimation> {
+        self.normal.get(ghost_type)
+    }
+
+    /// Gets the eyes animation (shared across all ghosts).
+    pub fn eyes(&self) -> &DirectionalAnimation {
+        &self.eyes
+    }
+
+    /// Gets the frightened animations (shared across all ghosts).
+    pub fn frightened(&self, flash: bool) -> &LinearAnimation {
+        if flash {
+            &self.frightened_flashing
+        } else {
+            &self.frightened
+        }
+    }
+}
+
 /// Autonomous ghost AI system implementing randomized movement with backtracking avoidance.
 pub fn ghost_movement_system(
     map: Res<Map>,
@@ -43,8 +214,10 @@ pub fn ghost_movement_system(
 
                     let new_edge: Edge = if non_opposite_options.is_empty() {
                         if let Some(edge) = intersection.get(opposite) {
+                            trace!(node = current_node, ghost = ?_ghost, direction = ?opposite, "Ghost forced to reverse direction");
                             edge
                         } else {
+                            warn!(node = current_node, ghost = ?_ghost, "Ghost stuck with no available directions");
                             break;
                         }
                     } else {
@@ -81,7 +254,7 @@ pub fn ghost_movement_system(
 pub fn eaten_ghost_system(
     map: Res<Map>,
     delta_time: Res<DeltaTime>,
-    mut eaten_ghosts: Query<(&Ghost, &mut Position, &mut Velocity, &mut GhostState)>,
+    mut eaten_ghosts: Query<(&Ghost, &mut Position, &mut Velocity, &mut GhostState), Without<Frozen>>,
 ) {
     for (ghost_type, mut position, mut velocity, mut ghost_state) in eaten_ghosts.iter_mut() {
         // Only process ghosts that are in Eyes state
@@ -116,6 +289,7 @@ pub fn eaten_ghost_system(
                     // Reached target node, check if we're at ghost house center
                     if to == ghost_house_center {
                         // Respawn the ghost - set state back to normal
+                        debug!(ghost = ?ghost_type, "Eaten ghost reached ghost house, respawning as normal");
                         *ghost_state = GhostState::Normal;
                         // Reset to stopped at ghost house center
                         *position = Position::Stopped {
@@ -179,6 +353,10 @@ fn find_direction_to_target(
     None
 }
 
+/// Component to track the last animation state for efficient change detection
+#[derive(Component, Debug, Clone, Copy, PartialEq)]
+pub struct LastAnimationState(pub GhostAnimation);
+
 /// Unified system that manages ghost state transitions and animations with component swapping
 pub fn ghost_state_system(
     mut commands: Commands,
@@ -192,24 +370,30 @@ pub fn ghost_state_system(
         // Only update animation if the animation state actually changed
         let current_animation_state = ghost_state.animation_state();
         if last_animation_state.0 != current_animation_state {
+            trace!(ghost = ?ghost_type, old_state = ?last_animation_state.0, new_state = ?current_animation_state, "Ghost animation state changed");
             match current_animation_state {
                 GhostAnimation::Frightened { flash } => {
-                    // Remove DirectionalAnimation, add LinearAnimation
+                    // Remove DirectionalAnimation, add LinearAnimation with Looping component
                     commands
                         .entity(entity)
                         .remove::<DirectionalAnimation>()
-                        .insert(*animations.frightened(flash));
+                        .insert(animations.frightened(flash).clone())
+                        .insert(Looping);
                 }
                 GhostAnimation::Normal => {
-                    // Remove LinearAnimation, add DirectionalAnimation
+                    // Remove LinearAnimation and Looping, add DirectionalAnimation
                     commands
                         .entity(entity)
-                        .remove::<LinearAnimation>()
-                        .insert(*animations.get_normal(ghost_type).unwrap());
+                        .remove::<(LinearAnimation, Looping)>()
+                        .insert(animations.get_normal(ghost_type).unwrap().clone());
                 }
                 GhostAnimation::Eyes => {
-                    // Remove LinearAnimation, add DirectionalAnimation (eyes animation)
-                    commands.entity(entity).remove::<LinearAnimation>().insert(*animations.eyes());
+                    // Remove LinearAnimation and Looping, add DirectionalAnimation (eyes animation)
+                    trace!(ghost = ?ghost_type, "Switching to eyes animation for eaten ghost");
+                    commands
+                        .entity(entity)
+                        .remove::<(LinearAnimation, Looping)>()
+                        .insert(animations.eyes().clone());
                 }
             }
             last_animation_state.0 = current_animation_state;

src/systems/hud/fruits.rs

@@ -0,0 +1,79 @@
+use crate::systems::item::FruitType;
+use crate::texture::sprites::GameSprite;
+use bevy_ecs::component::Component;
+use bevy_ecs::resource::Resource;
+
+#[derive(Component)]
+pub struct FruitInHud {
+    pub index: u32,
+}
+
+#[derive(Resource, Default)]
+pub struct FruitSprites(pub Vec<FruitType>);
+
+use crate::constants::{BOARD_BOTTOM_PIXEL_OFFSET, CANVAS_SIZE, CELL_SIZE};
+use crate::error::GameError;
+use crate::systems::{PixelPosition, Renderable};
+use crate::texture::sprite::SpriteAtlas;
+use bevy_ecs::entity::Entity;
+use bevy_ecs::event::EventWriter;
+use bevy_ecs::system::{Commands, NonSendMut, Query, Res};
+use glam::Vec2;
+
+/// Calculates the pixel position for a fruit sprite based on its index
+fn calculate_fruit_sprite_position(index: u32) -> Vec2 {
+    let start_x = CANVAS_SIZE.x - CELL_SIZE * 2; // 2 cells from right
+    let start_y = CANVAS_SIZE.y - BOARD_BOTTOM_PIXEL_OFFSET.y + (CELL_SIZE / 2) + 1; // In bottom area
+    let sprite_spacing = CELL_SIZE + CELL_SIZE / 2; // 1.5 cells between sprites
+
+    let x = start_x - ((index as f32) * (sprite_spacing as f32 * 1.5)).round() as u32;
+    let y = start_y - CELL_SIZE / 2;
+
+    Vec2::new((x - CELL_SIZE) as f32, (y + CELL_SIZE) as f32)
+}
+
+/// System that manages fruit sprite entities in the HUD.
+/// Spawns and despawns fruit sprite entities based on changes to FruitSprites resource.
+/// Displays up to 6 fruits, sorted by value.
+pub fn fruit_sprite_system(
+    mut commands: Commands,
+    atlas: NonSendMut<SpriteAtlas>,
+    current_fruit_sprites: Query<(Entity, &FruitInHud)>,
+    fruit_sprites: Res<FruitSprites>,
+    mut errors: EventWriter<GameError>,
+) {
+    // We only want to display the greatest 6 fruits
+    let fruits_to_display: Vec<_> = fruit_sprites.0.iter().rev().take(6).collect();
+
+    let mut current_sprites: Vec<_> = current_fruit_sprites.iter().collect();
+    current_sprites.sort_by_key(|(_, fruit)| fruit.index);
+
+    // Despawn all current sprites. We will respawn them.
+    // This is simpler than trying to match them up.
+    for (entity, _) in &current_sprites {
+        commands.entity(*entity).despawn();
+    }
+
+    for (i, fruit_type) in fruits_to_display.iter().enumerate() {
+        let fruit_sprite = match atlas.get_tile(&GameSprite::Fruit(**fruit_type).to_path()) {
+            Ok(sprite) => sprite,
+            Err(e) => {
+                errors.write(e.into());
+                continue;
+            }
+        };
+
+        let position = calculate_fruit_sprite_position(i as u32);
+
+        commands.spawn((
+            FruitInHud { index: i as u32 },
+            Renderable {
+                sprite: fruit_sprite,
+                layer: 255, // High layer to render on top
+            },
+            PixelPosition {
+                pixel_position: position,
+            },
+        ));
+    }
+}

src/systems/hud/lives.rs

@@ -0,0 +1,89 @@
+use std::cmp::Ordering;
+
+use crate::constants::{BOARD_BOTTOM_PIXEL_OFFSET, CANVAS_SIZE, CELL_SIZE};
+use crate::error::GameError;
+use crate::map::direction::Direction;
+use crate::systems::{PixelPosition, PlayerLife, PlayerLives, Renderable};
+use crate::texture::sprite::SpriteAtlas;
+use crate::texture::sprites::{GameSprite, PacmanSprite};
+use bevy_ecs::entity::Entity;
+use bevy_ecs::event::EventWriter;
+use bevy_ecs::system::{Commands, NonSendMut, Query, Res};
+use glam::Vec2;
+
+/// Calculates the pixel position for a life sprite based on its index
+fn calculate_life_sprite_position(index: u32) -> Vec2 {
+    let start_x = CELL_SIZE * 2; // 2 cells from left
+    let start_y = CANVAS_SIZE.y - BOARD_BOTTOM_PIXEL_OFFSET.y + (CELL_SIZE / 2) + 1; // In bottom area
+    let sprite_spacing = CELL_SIZE + CELL_SIZE / 2; // 1.5 cells between sprites
+
+    let x = start_x + ((index as f32) * (sprite_spacing as f32 * 1.5)).round() as u32;
+    let y = start_y - CELL_SIZE / 2;
+
+    Vec2::new((x + CELL_SIZE) as f32, (y + CELL_SIZE) as f32)
+}
+
+/// System that manages player life sprite entities.
+/// Spawns and despawns life sprite entities based on changes to PlayerLives resource.
+/// Each life sprite is positioned based on its index (0, 1, 2, etc. from left to right).
+pub fn player_life_sprite_system(
+    mut commands: Commands,
+    atlas: NonSendMut<SpriteAtlas>,
+    current_life_sprites: Query<(Entity, &PlayerLife)>,
+    player_lives: Res<PlayerLives>,
+    mut errors: EventWriter<GameError>,
+) {
+    let displayed_lives = player_lives.0.saturating_sub(1);
+
+    // Get current life sprite entities, sorted by index
+    let mut current_sprites: Vec<_> = current_life_sprites.iter().collect();
+    current_sprites.sort_by_key(|(_, life)| life.index);
+    let current_count = current_sprites.len() as u8;
+
+    // Calculate the difference
+    let diff = (displayed_lives as i8) - (current_count as i8);
+
+    match diff.cmp(&0) {
+        // Ignore when the number of lives displayed is correct
+        Ordering::Equal => {}
+        // Spawn new life sprites
+        Ordering::Greater => {
+            let life_sprite = match atlas.get_tile(&GameSprite::Pacman(PacmanSprite::Moving(Direction::Left, 1)).to_path()) {
+                Ok(sprite) => sprite,
+                Err(e) => {
+                    errors.write(e.into());
+                    return;
+                }
+            };
+
+            for i in 0..diff {
+                let position = calculate_life_sprite_position(i as u32);
+
+                commands.spawn((
+                    PlayerLife { index: i as u32 },
+                    Renderable {
+                        sprite: life_sprite,
+                        layer: 255, // High layer to render on top
+                    },
+                    PixelPosition {
+                        pixel_position: position,
+                    },
+                ));
+            }
+        }
+        // Remove excess life sprites (highest indices first)
+        Ordering::Less => {
+            let to_remove = diff.unsigned_abs();
+            let sprites_to_remove: Vec<_> = current_sprites
+                .iter()
+                .rev() // Start from highest index
+                .take(to_remove as usize)
+                .map(|(entity, _)| *entity)
+                .collect();
+
+            for entity in sprites_to_remove {
+                commands.entity(entity).despawn();
+            }
+        }
+    }
+}

src/systems/hud/mod.rs

@@ -0,0 +1,9 @@
+pub mod fruits;
+pub mod lives;
+pub mod score;
+pub mod touch;
+
+pub use self::fruits::*;
+pub use self::lives::*;
+pub use self::score::*;
+pub use self::touch::*;

src/systems/hud/score.rs

@@ -0,0 +1,86 @@
+use crate::constants;
+use crate::error::{GameError, TextureError};
+use crate::systems::{BackbufferResource, GameStage, ScoreResource, StartupSequence};
+use crate::texture::sprite::SpriteAtlas;
+use crate::texture::text::TextTexture;
+use bevy_ecs::event::EventWriter;
+use bevy_ecs::system::{NonSendMut, Res};
+use sdl2::pixels::Color;
+use sdl2::render::Canvas;
+use sdl2::video::Window;
+
+/// Renders the HUD (score, lives, etc.) on top of the game.
+#[allow(clippy::too_many_arguments)]
+pub fn hud_render_system(
+    mut backbuffer: NonSendMut<BackbufferResource>,
+    mut canvas: NonSendMut<&mut Canvas<Window>>,
+    mut atlas: NonSendMut<SpriteAtlas>,
+    score: Res<ScoreResource>,
+    stage: Res<GameStage>,
+    mut errors: EventWriter<GameError>,
+) {
+    let _ = canvas.with_texture_canvas(&mut backbuffer.0, |canvas| {
+        let mut text_renderer = TextTexture::new(1.0);
+
+        // Render lives and high score text in white
+        let lives_text = "1UP   HIGH SCORE   ";
+        let lives_position = glam::UVec2::new(4 + 8 * 3, 2); // x_offset + lives_offset * 8, y_offset
+
+        if let Err(e) = text_renderer.render(canvas, &mut atlas, lives_text, lives_position) {
+            errors.write(TextureError::RenderFailed(format!("Failed to render lives text: {}", e)).into());
+        }
+
+        // Render score text
+        let score_text = format!("{:02}", score.0);
+        let score_offset = 7 - (score_text.len() as i32);
+        let score_position = glam::UVec2::new(4 + 8 * score_offset as u32, 10); // x_offset + score_offset * 8, 8 + y_offset
+
+        if let Err(e) = text_renderer.render(canvas, &mut atlas, &score_text, score_position) {
+            errors.write(TextureError::RenderFailed(format!("Failed to render score text: {}", e)).into());
+        }
+
+        // Render high score text
+        let high_score_text = format!("{:02}", score.0);
+        let high_score_offset = 17 - (high_score_text.len() as i32);
+        let high_score_position = glam::UVec2::new(4 + 8 * high_score_offset as u32, 10); // x_offset + score_offset * 8, 8 + y_offset
+        if let Err(e) = text_renderer.render(canvas, &mut atlas, &high_score_text, high_score_position) {
+            errors.write(TextureError::RenderFailed(format!("Failed to render high score text: {}", e)).into());
+        }
+
+        // Render GAME OVER text
+        if matches!(*stage, GameStage::GameOver) {
+            let game_over_text = "GAME  OVER";
+            let game_over_width = text_renderer.text_width(game_over_text);
+            let game_over_position = glam::UVec2::new((constants::CANVAS_SIZE.x - game_over_width) / 2, 160);
+            if let Err(e) = text_renderer.render_with_color(canvas, &mut atlas, game_over_text, game_over_position, Color::RED) {
+                errors.write(TextureError::RenderFailed(format!("Failed to render GAME OVER text: {}", e)).into());
+            }
+        }
+
+        // Render text based on StartupSequence stage
+        if matches!(
+            *stage,
+            GameStage::Starting(StartupSequence::TextOnly { .. })
+                | GameStage::Starting(StartupSequence::CharactersVisible { .. })
+        ) {
+            let ready_text = "READY!";
+            let ready_width = text_renderer.text_width(ready_text);
+            let ready_position = glam::UVec2::new((constants::CANVAS_SIZE.x - ready_width) / 2, 160);
+            if let Err(e) = text_renderer.render_with_color(canvas, &mut atlas, ready_text, ready_position, Color::YELLOW) {
+                errors.write(TextureError::RenderFailed(format!("Failed to render READY text: {}", e)).into());
+            }
+
+            if matches!(*stage, GameStage::Starting(StartupSequence::TextOnly { .. })) {
+                let player_one_text = "PLAYER ONE";
+                let player_one_width = text_renderer.text_width(player_one_text);
+                let player_one_position = glam::UVec2::new((constants::CANVAS_SIZE.x - player_one_width) / 2, 113);
+
+                if let Err(e) =
+                    text_renderer.render_with_color(canvas, &mut atlas, player_one_text, player_one_position, Color::CYAN)
+                {
+                    errors.write(TextureError::RenderFailed(format!("Failed to render PLAYER ONE text: {}", e)).into());
+                }
+            }
+        }
+    });
+}

src/systems/hud/touch.rs

@@ -0,0 +1,81 @@
+use crate::error::{GameError, TextureError};
+use crate::systems::{BackbufferResource, TouchState};
+use bevy_ecs::event::EventWriter;
+use bevy_ecs::system::{NonSendMut, Res};
+use sdl2::pixels::Color;
+use sdl2::rect::Point;
+use sdl2::render::{BlendMode, Canvas};
+use sdl2::video::Window;
+
+/// Renders touch UI overlay for mobile/testing.
+pub fn touch_ui_render_system(
+    mut backbuffer: NonSendMut<BackbufferResource>,
+    mut canvas: NonSendMut<&mut Canvas<Window>>,
+    touch_state: Res<TouchState>,
+    mut errors: EventWriter<GameError>,
+) {
+    if let Some(ref touch_data) = touch_state.active_touch {
+        let _ = canvas.with_texture_canvas(&mut backbuffer.0, |canvas| {
+            // Set blend mode for transparency
+            canvas.set_blend_mode(BlendMode::Blend);
+
+            // Draw semi-transparent circle at touch start position
+            canvas.set_draw_color(Color::RGBA(255, 255, 255, 100));
+            let center = Point::new(touch_data.start_pos.x as i32, touch_data.start_pos.y as i32);
+
+            // Draw a simple circle by drawing filled rectangles (basic approach)
+            let radius = 30;
+            for dy in -radius..=radius {
+                for dx in -radius..=radius {
+                    if dx * dx + dy * dy <= radius * radius {
+                        let point = Point::new(center.x + dx, center.y + dy);
+                        if let Err(e) = canvas.draw_point(point) {
+                            errors.write(TextureError::RenderFailed(format!("Touch UI render error: {}", e)).into());
+                            return;
+                        }
+                    }
+                }
+            }
+
+            // Draw direction indicator if we have a direction
+            if let Some(direction) = touch_data.current_direction {
+                canvas.set_draw_color(Color::RGBA(0, 255, 0, 150));
+
+                // Draw arrow indicating direction
+                let arrow_length = 40;
+                let (dx, dy) = match direction {
+                    crate::map::direction::Direction::Up => (0, -arrow_length),
+                    crate::map::direction::Direction::Down => (0, arrow_length),
+                    crate::map::direction::Direction::Left => (-arrow_length, 0),
+                    crate::map::direction::Direction::Right => (arrow_length, 0),
+                };
+
+                let end_point = Point::new(center.x + dx, center.y + dy);
+                if let Err(e) = canvas.draw_line(center, end_point) {
+                    errors.write(TextureError::RenderFailed(format!("Touch arrow render error: {}", e)).into());
+                }
+
+                // Draw arrowhead (simple approach)
+                let arrow_size = 8;
+                match direction {
+                    crate::map::direction::Direction::Up => {
+                        let _ = canvas.draw_line(end_point, Point::new(end_point.x - arrow_size, end_point.y + arrow_size));
+                        let _ = canvas.draw_line(end_point, Point::new(end_point.x + arrow_size, end_point.y + arrow_size));
+                    }
+                    crate::map::direction::Direction::Down => {
+                        let _ = canvas.draw_line(end_point, Point::new(end_point.x - arrow_size, end_point.y - arrow_size));
+                        let _ = canvas.draw_line(end_point, Point::new(end_point.x + arrow_size, end_point.y - arrow_size));
+                    }
+                    crate::map::direction::Direction::Left => {
+                        let _ = canvas.draw_line(end_point, Point::new(end_point.x + arrow_size, end_point.y - arrow_size));
+                        let _ = canvas.draw_line(end_point, Point::new(end_point.x + arrow_size, end_point.y + arrow_size));
+                    }
+                    crate::map::direction::Direction::Right => {
+                        let _ = canvas.draw_line(end_point, Point::new(end_point.x - arrow_size, end_point.y - arrow_size));
+                        let _ = canvas.draw_line(end_point, Point::new(end_point.x - arrow_size, end_point.y + arrow_size));
+                    }
+                }
+            }
+        });
+    }
+}

src/systems/input.rs

@@ -13,17 +13,17 @@ use sdl2::{
 };
 use smallvec::{smallvec, SmallVec};
 
-use crate::systems::components::DeltaTime;
+use crate::systems::DeltaTime;
 use crate::{
     events::{GameCommand, GameEvent},
     map::direction::Direction,
 };
 
 // Touch input constants
-const TOUCH_DIRECTION_THRESHOLD: f32 = 10.0;
-const TOUCH_EASING_DISTANCE_THRESHOLD: f32 = 1.0;
-const MAX_TOUCH_MOVEMENT_SPEED: f32 = 100.0;
-const TOUCH_EASING_FACTOR: f32 = 1.5;
+pub const TOUCH_DIRECTION_THRESHOLD: f32 = 10.0;
+pub const TOUCH_EASING_DISTANCE_THRESHOLD: f32 = 1.0;
+pub const MAX_TOUCH_MOVEMENT_SPEED: f32 = 100.0;
+pub const TOUCH_EASING_FACTOR: f32 = 1.5;
 
 #[derive(Resource, Default, Debug, Copy, Clone)]
 pub enum CursorPosition {
@@ -35,7 +35,7 @@ pub enum CursorPosition {
     },
 }
 
-#[derive(Resource, Default, Debug)]
+#[derive(Resource, Default, Debug, Clone)]
 pub struct TouchState {
     pub active_touch: Option<TouchData>,
 }
@@ -85,8 +85,14 @@ impl Default for Bindings {
         key_bindings.insert(Keycode::Space, GameCommand::ToggleDebug);
         key_bindings.insert(Keycode::M, GameCommand::MuteAudio);
         key_bindings.insert(Keycode::R, GameCommand::ResetLevel);
-        key_bindings.insert(Keycode::Escape, GameCommand::Exit);
-        key_bindings.insert(Keycode::Q, GameCommand::Exit);
+
+        #[cfg(not(target_os = "emscripten"))]
+        {
+            key_bindings.insert(Keycode::Escape, GameCommand::Exit);
+            key_bindings.insert(Keycode::Q, GameCommand::Exit);
+            // Desktop-only fullscreen toggle
+            key_bindings.insert(Keycode::F, GameCommand::ToggleFullscreen);
+        }
 
         let movement_keys = HashSet::from([
             Keycode::W,
@@ -160,7 +166,7 @@ pub fn process_simple_key_events(bindings: &mut Bindings, frame_events: &[Simple
 }
 
 /// Calculates the primary direction from a 2D vector delta
-fn calculate_direction_from_delta(delta: Vec2) -> Direction {
+pub fn calculate_direction_from_delta(delta: Vec2) -> Direction {
     if delta.x.abs() > delta.y.abs() {
         if delta.x > 0.0 {
             Direction::Right
@@ -179,7 +185,7 @@ fn calculate_direction_from_delta(delta: Vec2) -> Direction {
 /// This slowly moves the start_pos towards the current_pos, with the speed
 /// decreasing as the distance gets smaller. The maximum movement speed is capped.
 /// Returns the delta vector and its length for reuse by the caller.
-fn update_touch_reference_position(touch_data: &mut TouchData, delta_time: f32) -> (Vec2, f32) {
+pub fn update_touch_reference_position(touch_data: &mut TouchData, delta_time: f32) -> (Vec2, f32) {
     // Calculate the vector from start to current position
     let delta = touch_data.current_pos - touch_data.start_pos;
     let distance = delta.length();
@@ -220,16 +226,6 @@ pub fn input_system(
     // Collect all events for this frame.
     let frame_events: SmallVec<[Event; 3]> = pump.poll_iter().collect();
 
-    // Warn if the smallvec was heap allocated due to exceeding stack capacity
-    #[cfg(debug_assertions)]
-    if frame_events.len() > frame_events.capacity() {
-        tracing::warn!(
-            "More than {} events in a frame, consider adjusting stack capacity: {:?}",
-            frame_events.capacity(),
-            frame_events
-        );
-    }
-
     // Handle non-keyboard events inline and build a simplified keyboard event stream.
     let mut simple_key_events: SmallVec<[SimpleKeyEvent; 3]> = smallvec![];
     for event in &frame_events {

src/systems/item.rs

@@ -1,74 +1,137 @@
 use bevy_ecs::{
-    entity::Entity,
-    event::{EventReader, EventWriter},
-    query::With,
-    system::{Commands, Query, ResMut},
+    event::Event,
+    observer::Trigger,
+    system::{Commands, NonSendMut, Res},
 };
+use strum_macros::IntoStaticStr;
+use tracing::debug;
 
 use crate::{
-    constants::animation::FRIGHTENED_FLASH_START_TICKS,
-    events::GameEvent,
-    systems::{AudioEvent, EntityType, GhostCollider, GhostState, ItemCollider, PacmanCollider, ScoreResource},
+    constants,
+    map::builder::Map,
+    systems::{common::bundles::ItemBundle, Collider, Position, Renderable, TimeToLive},
+    texture::{
+        sprite::SpriteAtlas,
+        sprites::{EffectSprite, GameSprite},
+    },
 };
 
-/// Determines if a collision between two entity types should be handled by the item system.
-///
-/// Returns `true` if one entity is a player and the other is a collectible item.
-#[allow(dead_code)]
-pub fn is_valid_item_collision(entity1: EntityType, entity2: EntityType) -> bool {
-    match (entity1, entity2) {
-        (EntityType::Player, entity) | (entity, EntityType::Player) => entity.is_collectible(),
-        _ => false,
+use crate::{systems::common::components::EntityType, systems::ItemCollider};
+
+use std::cmp::Ordering;
+
+/// Tracks the number of pellets consumed by the player for fruit spawning mechanics.
+#[derive(bevy_ecs::resource::Resource, Debug, Default)]
+pub struct PelletCount(pub u32);
+
+/// Represents the different fruit sprites that can appear as bonus items.
+#[derive(IntoStaticStr, Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[strum(serialize_all = "snake_case")]
+pub enum FruitType {
+    Cherry,
+    Strawberry,
+    Orange,
+    Apple,
+    Melon,
+    Galaxian,
+    Bell,
+    Key,
+}
+
+impl PartialOrd for FruitType {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
     }
 }
 
-pub fn item_system(
-    mut commands: Commands,
-    mut collision_events: EventReader<GameEvent>,
-    mut score: ResMut<ScoreResource>,
-    pacman_query: Query<Entity, With<PacmanCollider>>,
-    item_query: Query<(Entity, &EntityType), With<ItemCollider>>,
-    mut ghost_query: Query<&mut GhostState, With<GhostCollider>>,
-    mut events: EventWriter<AudioEvent>,
-) {
-    for event in collision_events.read() {
-        if let GameEvent::Collision(entity1, entity2) = event {
-            // Check if one is Pacman and the other is an item
-            let (_pacman_entity, item_entity) = if pacman_query.get(*entity1).is_ok() && item_query.get(*entity2).is_ok() {
-                (*entity1, *entity2)
-            } else if pacman_query.get(*entity2).is_ok() && item_query.get(*entity1).is_ok() {
-                (*entity2, *entity1)
-            } else {
-                continue;
-            };
+impl Ord for FruitType {
+    fn cmp(&self, other: &Self) -> Ordering {
+        (self.score_value()).cmp(&other.score_value())
+    }
+}
 
-            // Get the item type and update score
-            if let Ok((item_ent, entity_type)) = item_query.get(item_entity) {
-                if let Some(score_value) = entity_type.score_value() {
-                    score.0 += score_value;
+impl FruitType {
+    /// Returns the score value for this fruit type.
+    pub fn score_value(self) -> u32 {
+        match self {
+            FruitType::Cherry => 100,
+            FruitType::Strawberry => 300,
+            FruitType::Orange => 500,
+            FruitType::Apple => 700,
+            FruitType::Melon => 1000,
+            FruitType::Galaxian => 2000,
+            FruitType::Bell => 3000,
+            FruitType::Key => 5000,
+        }
+    }
 
-                    // Remove the collected item
-                    commands.entity(item_ent).despawn();
-
-                    // Trigger audio if appropriate
-                    if entity_type.is_collectible() {
-                        events.write(AudioEvent::PlayEat);
-                    }
-
-                    // Make ghosts frightened when power pellet is collected
-                    if *entity_type == EntityType::PowerPellet {
-                        // Convert seconds to frames (assumes 60 FPS)
-                        let total_ticks = 60 * 5; // 5 seconds total
-
-                        // Set all ghosts to frightened state, except those in Eyes state
-                        for mut ghost_state in ghost_query.iter_mut() {
-                            if !matches!(*ghost_state, GhostState::Eyes) {
-                                *ghost_state = GhostState::new_frightened(total_ticks, FRIGHTENED_FLASH_START_TICKS);
-                            }
-                        }
-                    }
-                }
-            }
+    pub fn from_index(index: u8) -> Self {
+        match index {
+            0 => FruitType::Cherry,
+            1 => FruitType::Strawberry,
+            2 => FruitType::Orange,
+            3 => FruitType::Apple,
+            4 => FruitType::Melon,
+            5 => FruitType::Galaxian,
+            6 => FruitType::Bell,
+            7 => FruitType::Key,
+            _ => panic!("Invalid fruit index: {}", index),
         }
     }
 }
+
+/// Trigger to spawn a fruit
+#[derive(Event, Clone, Copy, Debug)]
+pub enum SpawnTrigger {
+    Fruit,
+    Bonus { position: Position, value: u32, ttl: u32 },
+}
+
+pub fn spawn_fruit_observer(
+    trigger: Trigger<SpawnTrigger>,
+    mut commands: Commands,
+    atlas: NonSendMut<SpriteAtlas>,
+    map: Res<Map>,
+) {
+    let entity = match *trigger {
+        SpawnTrigger::Fruit => {
+            // Use cherry sprite as the default fruit (first fruit in original Pac-Man)
+            let sprite = &atlas
+                .get_tile(&GameSprite::Fruit(FruitType::from_index(0)).to_path())
+                .unwrap();
+            let bundle = ItemBundle {
+                position: map.start_positions.fruit_spawn,
+                sprite: Renderable {
+                    sprite: *sprite,
+                    layer: 1,
+                },
+                entity_type: EntityType::Fruit(FruitType::Cherry),
+                collider: Collider {
+                    size: constants::collider::FRUIT_SIZE,
+                },
+                item_collider: ItemCollider,
+            };
+
+            commands.spawn(bundle)
+        }
+        SpawnTrigger::Bonus { position, value, ttl } => {
+            let sprite = &atlas
+                .get_tile(&GameSprite::Effect(EffectSprite::Bonus(value)).to_path())
+                .unwrap();
+
+            let bundle = (
+                position,
+                TimeToLive::new(ttl),
+                Renderable {
+                    sprite: *sprite,
+                    layer: 1,
+                },
+                EntityType::Effect,
+            );
+
+            commands.spawn(bundle)
+        }
+    };
+
+    debug!(entity = ?entity.id(), "Entity spawned via trigger");
+}

src/systems/lifetime.rs

@@ -0,0 +1,33 @@
+use bevy_ecs::{
+    component::Component,
+    entity::Entity,
+    system::{Commands, Query, Res},
+};
+
+use crate::systems::DeltaTime;
+
+/// Component for entities that should be automatically deleted after a certain number of ticks
+#[derive(Component, Debug, Clone, Copy)]
+pub struct TimeToLive {
+    pub remaining_ticks: u32,
+}
+
+impl TimeToLive {
+    pub fn new(ticks: u32) -> Self {
+        Self { remaining_ticks: ticks }
+    }
+}
+
+/// System that manages entities with TimeToLive components, decrementing their remaining ticks
+/// and despawning them when they expire
+pub fn time_to_live_system(mut commands: Commands, dt: Res<DeltaTime>, mut query: Query<(Entity, &mut TimeToLive)>) {
+    for (entity, mut ttl) in query.iter_mut() {
+        if ttl.remaining_ticks <= dt.ticks {
+            // Entity has expired, despawn it
+            commands.entity(entity).despawn();
+        } else {
+            // Decrement remaining time
+            ttl.remaining_ticks = ttl.remaining_ticks.saturating_sub(dt.ticks);
+        }
+    }
+}

src/systems/mod.rs

@@ -1,32 +1,41 @@
-//! The Entity-Component-System (ECS) module.
-//!
-//! This module contains all the ECS-related logic, including components, systems,
-//! and resources.
+//! This module contains all the systems in the game.
 
+// These modules are excluded from coverage.
+#[cfg_attr(coverage_nightly, coverage(off))]
 pub mod audio;
-pub mod blinking;
-pub mod collision;
-pub mod components;
+#[cfg_attr(coverage_nightly, coverage(off))]
 pub mod debug;
-pub mod ghost;
+#[cfg_attr(coverage_nightly, coverage(off))]
+pub mod profiling;
+#[cfg_attr(coverage_nightly, coverage(off))]
+pub mod render;
+
+mod animation;
+mod collision;
+pub mod common;
+mod ghost;
+mod hud;
 pub mod input;
 pub mod item;
+pub mod lifetime;
 pub mod movement;
 pub mod player;
-pub mod profiling;
-pub mod render;
-pub mod stage;
+pub mod state;
 
+// Re-export all the modules. Do not fine-tune the exports.
+
+pub use self::animation::*;
 pub use self::audio::*;
-pub use self::blinking::*;
 pub use self::collision::*;
-pub use self::components::*;
+pub use self::common::*;
 pub use self::debug::*;
 pub use self::ghost::*;
+pub use self::hud::*;
 pub use self::input::*;
 pub use self::item::*;
+pub use self::lifetime::*;
 pub use self::movement::*;
 pub use self::player::*;
 pub use self::profiling::*;
 pub use self::render::*;
-pub use self::stage::*;
+pub use self::state::*;

src/systems/player.rs

@@ -1,21 +1,26 @@
 use bevy_ecs::{
-    event::{EventReader, EventWriter},
+    component::Component,
+    event::EventReader,
     query::{With, Without},
-    system::{Query, Res, ResMut},
+    system::{Query, Res, ResMut, Single},
 };
+use tracing::trace;
 
 use crate::{
-    error::GameError,
     events::{GameCommand, GameEvent},
     map::{builder::Map, graph::Edge},
     systems::{
-        components::{DeltaTime, EntityType, Frozen, GlobalState, MovementModifiers, PlayerControlled},
+        components::{DeltaTime, EntityType, Frozen, GlobalState, MovementModifiers},
         debug::DebugState,
         movement::{BufferedDirection, Position, Velocity},
         AudioState,
     },
 };
 
+/// A tag component for entities that are controlled by the player.
+#[derive(Default, Component)]
+pub struct PlayerControlled;
+
 pub fn can_traverse(entity_type: EntityType, edge: Edge) -> bool {
     let entity_flags = entity_type.traversal_flags();
     edge.traversal_flags.contains(entity_flags)
@@ -27,48 +32,40 @@ pub fn can_traverse(entity_type: EntityType, edge: Edge) -> bool {
 /// toggling, audio muting, and game exit requests. Movement commands are buffered
 /// to allow direction changes before reaching intersections, improving gameplay
 /// responsiveness. Non-movement commands immediately modify global game state.
+#[allow(clippy::type_complexity)]
 pub fn player_control_system(
     mut events: EventReader<GameEvent>,
     mut state: ResMut<GlobalState>,
     mut debug_state: ResMut<DebugState>,
     mut audio_state: ResMut<AudioState>,
-    mut players: Query<&mut BufferedDirection, (With<PlayerControlled>, Without<Frozen>)>,
-    mut errors: EventWriter<GameError>,
+    mut player: Option<Single<&mut BufferedDirection, (With<PlayerControlled>, Without<Frozen>)>>,
 ) {
     // Handle events
     for event in events.read() {
-        if let GameEvent::Command(command) = event {
-            match command {
-                GameCommand::MovePlayer(direction) => {
-                    // Get the player's movable component (ensuring there is only one player)
-                    let mut buffered_direction = match players.single_mut() {
-                        Ok(tuple) => tuple,
-                        Err(e) => {
-                            errors.write(GameError::InvalidState(format!(
-                                "No/multiple entities queried for player system: {}",
-                                e
-                            )));
-                            return;
-                        }
-                    };
+        let GameEvent::Command(command) = event;
 
-                    *buffered_direction = BufferedDirection::Some {
+        match command {
+            GameCommand::MovePlayer(direction) => {
+                // Only handle movement if there's an unfrozen player
+                if let Some(player_single) = player.as_mut() {
+                    trace!(direction = ?*direction, "Player direction buffered for movement");
+                    ***player_single = BufferedDirection::Some {
                         direction: *direction,
                         remaining_time: 0.25,
                     };
                 }
-                GameCommand::Exit => {
-                    state.exit = true;
-                }
-                GameCommand::ToggleDebug => {
-                    debug_state.enabled = !debug_state.enabled;
-                }
-                GameCommand::MuteAudio => {
-                    audio_state.muted = !audio_state.muted;
-                    tracing::info!("Audio {}", if audio_state.muted { "muted" } else { "unmuted" });
-                }
-                _ => {}
             }
+            GameCommand::Exit => {
+                state.exit = true;
+            }
+            GameCommand::ToggleDebug => {
+                debug_state.enabled = !debug_state.enabled;
+            }
+            GameCommand::MuteAudio => {
+                audio_state.muted = !audio_state.muted;
+                tracing::info!("Audio {}", if audio_state.muted { "muted" } else { "unmuted" });
+            }
+            _ => {}
         }
     }
 }
@@ -86,6 +83,7 @@ pub fn player_movement_system(
         (&MovementModifiers, &mut Position, &mut Velocity, &mut BufferedDirection),
         (With<PlayerControlled>, Without<Frozen>),
     >,
+    mut last_stopped_node: bevy_ecs::system::Local<Option<crate::systems::movement::NodeId>>,
 ) {
     for (modifiers, mut position, mut velocity, mut buffered_direction) in entities.iter_mut() {
         // Decrement the buffered direction remaining time
@@ -95,6 +93,7 @@ pub fn player_movement_system(
         } = *buffered_direction
         {
             if remaining_time <= 0.0 {
+                trace!("Buffered direction expired");
                 *buffered_direction = BufferedDirection::None;
             } else {
                 *buffered_direction = BufferedDirection::Some {
@@ -115,6 +114,8 @@ pub fn player_movement_system(
                         if let Some(edge) = map.graph.find_edge_in_direction(position.current_node(), direction) {
                             // If there is an edge in that direction (and it's traversable), start moving towards it and consume the buffered direction.
                             if can_traverse(EntityType::Player, edge) {
+                                trace!(from = position.current_node(), to = edge.target, direction = ?direction, "Player started moving using buffered direction");
+                                *last_stopped_node = None; // Reset stopped state when starting to move
                                 velocity.direction = edge.direction;
                                 *position = Position::Moving {
                                     from: position.current_node(),
@@ -129,6 +130,8 @@ pub fn player_movement_system(
                     // If there is no buffered direction (or it's not yet valid), continue in the current direction.
                     if let Some(edge) = map.graph.find_edge_in_direction(position.current_node(), velocity.direction) {
                         if can_traverse(EntityType::Player, edge) {
+                            trace!(from = position.current_node(), to = edge.target, direction = ?velocity.direction, "Player continued in current direction");
+                            *last_stopped_node = None; // Reset stopped state when starting to move
                             velocity.direction = edge.direction;
                             *position = Position::Moving {
                                 from: position.current_node(),
@@ -138,6 +141,11 @@ pub fn player_movement_system(
                         }
                     } else {
                         // No edge in our current direction either, erase the buffered direction and stop.
+                        let current_node = position.current_node();
+                        if *last_stopped_node != Some(current_node) {
+                            trace!(node = current_node, direction = ?velocity.direction, "Player stopped - no valid edge in current direction");
+                            *last_stopped_node = Some(current_node);
+                        }
                         *buffered_direction = BufferedDirection::None;
                         break;
                     }
@@ -155,14 +163,23 @@ pub fn player_movement_system(
 }
 
 /// Applies tunnel slowdown based on the current node tile
-pub fn player_tunnel_slowdown_system(map: Res<Map>, mut q: Query<(&Position, &mut MovementModifiers), With<PlayerControlled>>) {
-    if let Ok((position, mut modifiers)) = q.single_mut() {
-        let node = position.current_node();
-        let in_tunnel = map
-            .tile_at_node(node)
-            .map(|t| t == crate::constants::MapTile::Tunnel)
-            .unwrap_or(false);
-        modifiers.tunnel_slowdown_active = in_tunnel;
-        modifiers.speed_multiplier = if in_tunnel { 0.6 } else { 1.0 };
+pub fn player_tunnel_slowdown_system(map: Res<Map>, player: Single<(&Position, &mut MovementModifiers), With<PlayerControlled>>) {
+    let (position, mut modifiers) = player.into_inner();
+    let node = position.current_node();
+    let in_tunnel = map
+        .tile_at_node(node)
+        .map(|t| t == crate::constants::MapTile::Tunnel)
+        .unwrap_or(false);
+
+    if modifiers.tunnel_slowdown_active != in_tunnel {
+        trace!(
+            node,
+            in_tunnel,
+            speed_multiplier = if in_tunnel { 0.6 } else { 1.0 },
+            "Player tunnel slowdown state changed"
+        );
     }
+
+    modifiers.tunnel_slowdown_active = in_tunnel;
+    modifiers.speed_multiplier = if in_tunnel { 0.6 } else { 1.0 };
 }

src/systems/profiling.rs

@@ -52,6 +52,11 @@ impl TimingBuffer {
         self.last_tick = current_tick;
     }
 
+    /// Gets the most recent timing from the buffer.
+    pub fn get_most_recent_timing(&self) -> Duration {
+        self.buffer.back().copied().unwrap_or(Duration::ZERO)
+    }
+
     /// Gets statistics for this timing buffer.
     ///
     /// # Panics
@@ -157,6 +162,7 @@ pub enum SystemId {
     Stage,
     GhostStateAnimation,
     EatenGhost,
+    TimeToLive,
 }
 
 impl Display for SystemId {
@@ -247,6 +253,61 @@ impl SystemTimings {
         // Use the formatting module to format the data
         format_timing_display(timing_data)
     }
+
+    /// Returns a list of systems with their timings, likely responsible for slow frame timings.
+    ///
+    /// First, checks if any systems took longer than 2ms on the most recent tick.
+    /// If none exceed 2ms, accumulates systems until the top 30% of total timing
+    /// is reached, stopping at 5 systems maximum.
+    ///
+    /// Returns tuples of (SystemId, Duration) in a SmallVec capped at 5 items.
+    pub fn get_slowest_systems(&self) -> SmallVec<[(SystemId, Duration); 5]> {
+        let mut system_timings: Vec<(SystemId, Duration)> = Vec::new();
+        let mut total_duration = Duration::ZERO;
+
+        // Collect most recent timing for each system (excluding Total)
+        for id in SystemId::iter() {
+            if id == SystemId::Total {
+                continue;
+            }
+
+            if let Some(buffer) = self.timings.get(&id) {
+                let recent_timing = buffer.lock().get_most_recent_timing();
+                system_timings.push((id, recent_timing));
+                total_duration += recent_timing;
+            }
+        }
+
+        // Sort by duration (highest first)
+        system_timings.sort_by(|a, b| b.1.cmp(&a.1));
+
+        // Check for systems over 2ms threshold
+        let over_threshold: SmallVec<[(SystemId, Duration); 5]> = system_timings
+            .iter()
+            .filter(|(_, duration)| duration.as_millis() >= 2)
+            .copied()
+            .collect();
+
+        if !over_threshold.is_empty() {
+            return over_threshold;
+        }
+
+        // Accumulate top systems until 30% of total is reached (max 5 systems)
+        let threshold = total_duration.as_nanos() as f64 * 0.3;
+        let mut accumulated = 0u128;
+        let mut result = SmallVec::new();
+
+        for (id, duration) in system_timings.iter().take(5) {
+            result.push((*id, *duration));
+            accumulated += duration.as_nanos();
+
+            if accumulated as f64 >= threshold {
+                break;
+            }
+        }
+
+        result
+    }
 }
 
 pub fn profile<S, M>(id: SystemId, system: S) -> impl FnMut(&mut bevy_ecs::world::World)

src/systems/render.rs

@@ -1,33 +1,85 @@
-use crate::constants::CANVAS_SIZE;
 use crate::error::{GameError, TextureError};
 use crate::map::builder::Map;
-use crate::systems::input::TouchState;
 use crate::systems::{
-    debug_render_system, BatchedLinesResource, Collider, CursorPosition, DebugState, DebugTextureResource, DeltaTime,
-    DirectionalAnimation, LinearAnimation, Position, Renderable, ScoreResource, StartupSequence, SystemId, SystemTimings,
-    TtfAtlasResource, Velocity,
+    debug_render_system, BatchedLinesResource, Collider, CursorPosition, DebugState, DebugTextureResource, Position, SystemId,
+    SystemTimings, TtfAtlasResource,
 };
-use crate::texture::sprite::SpriteAtlas;
-use crate::texture::text::TextTexture;
+use crate::texture::sprite::{AtlasTile, SpriteAtlas};
 use bevy_ecs::component::Component;
 use bevy_ecs::entity::Entity;
 use bevy_ecs::event::EventWriter;
-use bevy_ecs::query::{Changed, Or, Without};
+use bevy_ecs::query::{Changed, Or, With};
 use bevy_ecs::removal_detection::RemovedComponents;
 use bevy_ecs::resource::Resource;
 use bevy_ecs::system::{NonSendMut, Query, Res, ResMut};
-use sdl2::pixels::Color;
+use glam::Vec2;
 use sdl2::rect::{Point, Rect};
 use sdl2::render::{BlendMode, Canvas, Texture};
 use sdl2::video::Window;
 use std::time::Instant;
 
+/// A component for entities that have a sprite, with a layer for ordering.
+///
+/// This is intended to be modified by other entities allowing animation.
+#[derive(Component)]
+pub struct Renderable {
+    pub sprite: AtlasTile,
+    pub layer: u8,
+}
+
 #[derive(Resource, Default)]
 pub struct RenderDirty(pub bool);
 
 #[derive(Component)]
 pub struct Hidden;
 
+/// A component that controls entity visibility in the render system.
+///
+/// Entities without this component are considered visible by default.
+/// This allows for efficient rendering where only entities that need
+/// visibility control have this component.
+#[derive(Component, Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Visibility(pub bool);
+
+impl Default for Visibility {
+    fn default() -> Self {
+        Self(true) // Default to visible
+    }
+}
+
+impl Visibility {
+    /// Creates a visible Visibility component
+    pub fn visible() -> Self {
+        Self(true)
+    }
+
+    /// Creates a hidden Visibility component
+    pub fn hidden() -> Self {
+        Self(false)
+    }
+
+    /// Returns true if the entity is visible
+    pub fn is_visible(&self) -> bool {
+        self.0
+    }
+
+    /// Returns true if the entity is hidden
+    #[allow(dead_code)] // Used in tests
+    pub fn is_hidden(&self) -> bool {
+        !self.0
+    }
+
+    /// Makes the entity visible
+    pub fn show(&mut self) {
+        self.0 = true;
+    }
+
+    /// Toggles the visibility state
+    pub fn toggle(&mut self) {
+        self.0 = !self.0;
+    }
+}
+
 /// Enum to identify which texture is being rendered to in the combined render system
 #[derive(Debug, Clone, Copy)]
 enum RenderTarget {
@@ -38,75 +90,18 @@ enum RenderTarget {
 #[allow(clippy::type_complexity)]
 pub fn dirty_render_system(
     mut dirty: ResMut<RenderDirty>,
-    changed: Query<(), Or<(Changed<Renderable>, Changed<Position>)>>,
-    removed_hidden: RemovedComponents<Hidden>,
+    changed: Query<(), Or<(Changed<Renderable>, Changed<Position>, Changed<Visibility>)>>,
     removed_renderables: RemovedComponents<Renderable>,
 ) {
-    if !changed.is_empty() || !removed_hidden.is_empty() || !removed_renderables.is_empty() {
+    if changed.iter().count() > 0 || !removed_renderables.is_empty() {
         dirty.0 = true;
     }
 }
 
-/// Updates directional animated entities with synchronized timing across directions.
-///
-/// This runs before the render system to update sprites based on current direction and movement state.
-/// All directions share the same frame timing to ensure perfect synchronization.
-pub fn directional_render_system(
-    dt: Res<DeltaTime>,
-    mut query: Query<(&Position, &Velocity, &mut DirectionalAnimation, &mut Renderable)>,
-) {
-    let ticks = (dt.seconds * 60.0).round() as u16; // Convert from seconds to ticks at 60 ticks/sec
-
-    for (position, velocity, mut anim, mut renderable) in query.iter_mut() {
-        let stopped = matches!(position, Position::Stopped { .. });
-
-        // Only tick animation when moving to preserve stopped frame
-        if !stopped {
-            // Tick shared animation state
-            anim.time_bank += ticks;
-            while anim.time_bank >= anim.frame_duration {
-                anim.time_bank -= anim.frame_duration;
-                anim.current_frame += 1;
-            }
-        }
-
-        // Get tiles for current direction and movement state
-        let tiles = if stopped {
-            anim.stopped_tiles.get(velocity.direction)
-        } else {
-            anim.moving_tiles.get(velocity.direction)
-        };
-
-        if !tiles.is_empty() {
-            let new_tile = tiles.get_tile(anim.current_frame);
-            if renderable.sprite != new_tile {
-                renderable.sprite = new_tile;
-            }
-        }
-    }
-}
-
-/// Updates linear animated entities (used for non-directional animations like frightened ghosts).
-///
-/// This system handles entities that use LinearAnimation component for simple frame cycling.
-pub fn linear_render_system(dt: Res<DeltaTime>, mut query: Query<(&mut LinearAnimation, &mut Renderable)>) {
-    let ticks = (dt.seconds * 60.0).round() as u16; // Convert from seconds to ticks at 60 ticks/sec
-
-    for (mut anim, mut renderable) in query.iter_mut() {
-        // Tick animation
-        anim.time_bank += ticks;
-        while anim.time_bank >= anim.frame_duration {
-            anim.time_bank -= anim.frame_duration;
-            anim.current_frame += 1;
-        }
-
-        if !anim.tiles.is_empty() {
-            let new_tile = anim.tiles.get_tile(anim.current_frame);
-            if renderable.sprite != new_tile {
-                renderable.sprite = new_tile;
-            }
-        }
-    }
+/// Component for Renderables to store an exact pixel position
+#[derive(Component)]
+pub struct PixelPosition {
+    pub pixel_position: Vec2,
 }
 
 /// A non-send resource for the map texture. This just wraps the texture with a type so it can be differentiated when exposed as a resource.
@@ -115,152 +110,24 @@ pub struct MapTextureResource(pub Texture);
 /// A non-send resource for the backbuffer texture. This just wraps the texture with a type so it can be differentiated when exposed as a resource.
 pub struct BackbufferResource(pub Texture);
 
-/// Renders touch UI overlay for mobile/testing.
-pub fn touch_ui_render_system(
-    mut backbuffer: NonSendMut<BackbufferResource>,
-    mut canvas: NonSendMut<&mut Canvas<Window>>,
-    touch_state: Res<TouchState>,
-    mut errors: EventWriter<GameError>,
-) {
-    if let Some(ref touch_data) = touch_state.active_touch {
-        let _ = canvas.with_texture_canvas(&mut backbuffer.0, |canvas| {
-            // Set blend mode for transparency
-            canvas.set_blend_mode(BlendMode::Blend);
-
-            // Draw semi-transparent circle at touch start position
-            canvas.set_draw_color(Color::RGBA(255, 255, 255, 100));
-            let center = Point::new(touch_data.start_pos.x as i32, touch_data.start_pos.y as i32);
-
-            // Draw a simple circle by drawing filled rectangles (basic approach)
-            let radius = 30;
-            for dy in -radius..=radius {
-                for dx in -radius..=radius {
-                    if dx * dx + dy * dy <= radius * radius {
-                        let point = Point::new(center.x + dx, center.y + dy);
-                        if let Err(e) = canvas.draw_point(point) {
-                            errors.write(TextureError::RenderFailed(format!("Touch UI render error: {}", e)).into());
-                            return;
-                        }
-                    }
-                }
-            }
-
-            // Draw direction indicator if we have a direction
-            if let Some(direction) = touch_data.current_direction {
-                canvas.set_draw_color(Color::RGBA(0, 255, 0, 150));
-
-                // Draw arrow indicating direction
-                let arrow_length = 40;
-                let (dx, dy) = match direction {
-                    crate::map::direction::Direction::Up => (0, -arrow_length),
-                    crate::map::direction::Direction::Down => (0, arrow_length),
-                    crate::map::direction::Direction::Left => (-arrow_length, 0),
-                    crate::map::direction::Direction::Right => (arrow_length, 0),
-                };
-
-                let end_point = Point::new(center.x + dx, center.y + dy);
-                if let Err(e) = canvas.draw_line(center, end_point) {
-                    errors.write(TextureError::RenderFailed(format!("Touch arrow render error: {}", e)).into());
-                }
-
-                // Draw arrowhead (simple approach)
-                let arrow_size = 8;
-                match direction {
-                    crate::map::direction::Direction::Up => {
-                        let _ = canvas.draw_line(end_point, Point::new(end_point.x - arrow_size, end_point.y + arrow_size));
-                        let _ = canvas.draw_line(end_point, Point::new(end_point.x + arrow_size, end_point.y + arrow_size));
-                    }
-                    crate::map::direction::Direction::Down => {
-                        let _ = canvas.draw_line(end_point, Point::new(end_point.x - arrow_size, end_point.y - arrow_size));
-                        let _ = canvas.draw_line(end_point, Point::new(end_point.x + arrow_size, end_point.y - arrow_size));
-                    }
-                    crate::map::direction::Direction::Left => {
-                        let _ = canvas.draw_line(end_point, Point::new(end_point.x + arrow_size, end_point.y - arrow_size));
-                        let _ = canvas.draw_line(end_point, Point::new(end_point.x + arrow_size, end_point.y + arrow_size));
-                    }
-                    crate::map::direction::Direction::Right => {
-                        let _ = canvas.draw_line(end_point, Point::new(end_point.x - arrow_size, end_point.y - arrow_size));
-                        let _ = canvas.draw_line(end_point, Point::new(end_point.x - arrow_size, end_point.y + arrow_size));
-                    }
-                }
-            }
-        });
-    }
-}
-
-/// Renders the HUD (score, lives, etc.) on top of the game.
-pub fn hud_render_system(
-    mut backbuffer: NonSendMut<BackbufferResource>,
-    mut canvas: NonSendMut<&mut Canvas<Window>>,
-    mut atlas: NonSendMut<SpriteAtlas>,
-    score: Res<ScoreResource>,
-    startup: Res<StartupSequence>,
-    mut errors: EventWriter<GameError>,
-) {
-    let _ = canvas.with_texture_canvas(&mut backbuffer.0, |canvas| {
-        let mut text_renderer = TextTexture::new(1.0);
-
-        // Render lives and high score text in white
-        let lives = 3; // TODO: Get from actual lives resource
-        let lives_text = format!("{lives}UP   HIGH SCORE   ");
-        let lives_position = glam::UVec2::new(4 + 8 * 3, 2); // x_offset + lives_offset * 8, y_offset
-
-        if let Err(e) = text_renderer.render(canvas, &mut atlas, &lives_text, lives_position) {
-            errors.write(TextureError::RenderFailed(format!("Failed to render lives text: {}", e)).into());
-        }
-
-        // Render score text
-        let score_text = format!("{:02}", score.0);
-        let score_offset = 7 - (score_text.len() as i32);
-        let score_position = glam::UVec2::new(4 + 8 * score_offset as u32, 10); // x_offset + score_offset * 8, 8 + y_offset
-
-        if let Err(e) = text_renderer.render(canvas, &mut atlas, &score_text, score_position) {
-            errors.write(TextureError::RenderFailed(format!("Failed to render score text: {}", e)).into());
-        }
-
-        // Render high score text
-        let high_score_text = format!("{:02}", score.0);
-        let high_score_offset = 17 - (high_score_text.len() as i32);
-        let high_score_position = glam::UVec2::new(4 + 8 * high_score_offset as u32, 10); // x_offset + score_offset * 8, 8 + y_offset
-        if let Err(e) = text_renderer.render(canvas, &mut atlas, &high_score_text, high_score_position) {
-            errors.write(TextureError::RenderFailed(format!("Failed to render high score text: {}", e)).into());
-        }
-
-        // Render text based on StartupSequence stage
-        if matches!(
-            *startup,
-            StartupSequence::TextOnly { .. } | StartupSequence::CharactersVisible { .. }
-        ) {
-            let ready_text = "READY!";
-            let ready_width = text_renderer.text_width(ready_text);
-            let ready_position = glam::UVec2::new((CANVAS_SIZE.x - ready_width) / 2, 160);
-            if let Err(e) = text_renderer.render_with_color(canvas, &mut atlas, ready_text, ready_position, Color::YELLOW) {
-                errors.write(TextureError::RenderFailed(format!("Failed to render READY text: {}", e)).into());
-            }
-
-            if matches!(*startup, StartupSequence::TextOnly { .. }) {
-                let player_one_text = "PLAYER ONE";
-                let player_one_width = text_renderer.text_width(player_one_text);
-                let player_one_position = glam::UVec2::new((CANVAS_SIZE.x - player_one_width) / 2, 113);
-
-                if let Err(e) =
-                    text_renderer.render_with_color(canvas, &mut atlas, player_one_text, player_one_position, Color::CYAN)
-                {
-                    errors.write(TextureError::RenderFailed(format!("Failed to render PLAYER ONE text: {}", e)).into());
-                }
-            }
-        }
-    });
-}
-
 #[allow(clippy::too_many_arguments)]
+#[allow(clippy::type_complexity)]
 pub fn render_system(
     canvas: &mut Canvas<Window>,
     map_texture: &NonSendMut<MapTextureResource>,
     atlas: &mut SpriteAtlas,
     map: &Res<Map>,
     dirty: &Res<RenderDirty>,
-    renderables: &Query<(Entity, &Renderable, &Position), Without<Hidden>>,
+    renderables: &Query<
+        (
+            Entity,
+            &Renderable,
+            Option<&Position>,
+            Option<&PixelPosition>,
+            Option<&Visibility>,
+        ),
+        Or<(With<Position>, With<PixelPosition>)>,
+    >,
     errors: &mut EventWriter<GameError>,
 ) {
     if !dirty.0 {
@@ -276,13 +143,25 @@ pub fn render_system(
         errors.write(TextureError::RenderFailed(e.to_string()).into());
     }
 
-    // Render all entities to the backbuffer
-    for (_, renderable, position) in renderables
+    // Collect and filter visible entities, then sort by layer
+    let mut visible_entities: Vec<_> = renderables
         .iter()
-        .sort_by_key::<(Entity, &Renderable, &Position), _>(|(_, renderable, _)| renderable.layer)
-        .rev()
-    {
-        let pos = position.get_pixel_position(&map.graph);
+        .filter(|(_, _, _, _, visibility)| visibility.copied().unwrap_or_default().is_visible())
+        .collect();
+
+    visible_entities.sort_by_key(|(_, renderable, _, _, _)| renderable.layer);
+    visible_entities.reverse();
+
+    // Render all visible entities to the backbuffer
+    for (_entity, renderable, position, pixel_position, _visibility) in visible_entities {
+        let pos = if let Some(position) = position {
+            position.get_pixel_position(&map.graph)
+        } else {
+            Ok(pixel_position
+                .expect("Pixel position should be present via query filtering, but got None on both")
+                .pixel_position)
+        };
+
         match pos {
             Ok(pos) => {
                 let dest = Rect::from_center(
@@ -307,6 +186,7 @@ pub fn render_system(
 /// Combined render system that renders to both backbuffer and debug textures in a single
 /// with_multiple_texture_canvas call for reduced overhead
 #[allow(clippy::too_many_arguments)]
+#[allow(clippy::type_complexity)]
 pub fn combined_render_system(
     mut canvas: NonSendMut<&mut Canvas<Window>>,
     map_texture: NonSendMut<MapTextureResource>,
@@ -320,7 +200,16 @@ pub fn combined_render_system(
     timing: Res<crate::systems::profiling::Timing>,
     map: Res<Map>,
     dirty: Res<RenderDirty>,
-    renderables: Query<(Entity, &Renderable, &Position), Without<Hidden>>,
+    renderables: Query<
+        (
+            Entity,
+            &Renderable,
+            Option<&Position>,
+            Option<&PixelPosition>,
+            Option<&Visibility>,
+        ),
+        Or<(With<Position>, With<PixelPosition>)>,
+    >,
     colliders: Query<(&Collider, &Position)>,
     cursor: Res<CursorPosition>,
     mut errors: EventWriter<GameError>,

src/systems/stage.rs

@@ -1,101 +0,0 @@
-use bevy_ecs::{
-    entity::Entity,
-    query::With,
-    resource::Resource,
-    system::{Commands, Query, ResMut},
-};
-use tracing::debug;
-
-use crate::systems::{Blinking, Frozen, GhostCollider, Hidden, PlayerControlled};
-
-#[derive(Resource, Debug, Clone, Copy)]
-pub enum StartupSequence {
-    /// Stage 1: Text-only stage
-    /// - Player & ghosts are hidden
-    /// - READY! and PLAYER ONE text are shown
-    /// - Energizers do not blink
-    TextOnly {
-        /// Remaining ticks in this stage
-        remaining_ticks: u32,
-    },
-    /// Stage 2: Characters visible stage
-    /// - PLAYER ONE text is hidden, READY! text remains
-    /// - Ghosts and Pac-Man are now shown
-    CharactersVisible {
-        /// Remaining ticks in this stage
-        remaining_ticks: u32,
-    },
-    /// Stage 3: Game begins
-    /// - Final state, game is fully active
-    GameActive,
-}
-
-impl StartupSequence {
-    /// Creates a new StartupSequence with the specified duration in ticks
-    pub fn new(text_only_ticks: u32, _characters_visible_ticks: u32) -> Self {
-        Self::TextOnly {
-            remaining_ticks: text_only_ticks,
-        }
-    }
-
-    /// Ticks the timer by one frame, returning transition information if state changes
-    pub fn tick(&mut self) -> Option<(StartupSequence, StartupSequence)> {
-        match self {
-            StartupSequence::TextOnly { remaining_ticks } => {
-                if *remaining_ticks > 0 {
-                    *remaining_ticks -= 1;
-                    None
-                } else {
-                    let from = *self;
-                    *self = StartupSequence::CharactersVisible {
-                        remaining_ticks: 60, // 1 second at 60 FPS
-                    };
-                    Some((from, *self))
-                }
-            }
-            StartupSequence::CharactersVisible { remaining_ticks } => {
-                if *remaining_ticks > 0 {
-                    *remaining_ticks -= 1;
-                    None
-                } else {
-                    let from = *self;
-                    *self = StartupSequence::GameActive;
-                    Some((from, *self))
-                }
-            }
-            StartupSequence::GameActive => None,
-        }
-    }
-}
-
-/// Handles startup sequence transitions and component management
-pub fn startup_stage_system(
-    mut startup: ResMut<StartupSequence>,
-    mut commands: Commands,
-    mut blinking_query: Query<Entity, With<Blinking>>,
-    mut player_query: Query<Entity, With<PlayerControlled>>,
-    mut ghost_query: Query<Entity, With<GhostCollider>>,
-) {
-    if let Some((from, to)) = startup.tick() {
-        debug!("StartupSequence transition from {from:?} to {to:?}");
-        match (from, to) {
-            (StartupSequence::TextOnly { .. }, StartupSequence::CharactersVisible { .. }) => {
-                // Unhide the player & ghosts
-                for entity in player_query.iter_mut().chain(ghost_query.iter_mut()) {
-                    commands.entity(entity).remove::<Hidden>();
-                }
-            }
-            (StartupSequence::CharactersVisible { .. }, StartupSequence::GameActive) => {
-                // Unfreeze the player & ghosts & pellet blinking
-                for entity in player_query
-                    .iter_mut()
-                    .chain(ghost_query.iter_mut())
-                    .chain(blinking_query.iter_mut())
-                {
-                    commands.entity(entity).remove::<Frozen>();
-                }
-            }
-            _ => {}
-        }
-    }
-}

src/systems/state.rs

@@ -0,0 +1,476 @@
+use std::mem::discriminant;
+use tracing::{debug, info};
+
+use crate::constants;
+use crate::events::StageTransition;
+use crate::map::direction::Direction;
+use crate::systems::{EntityType, ItemCollider, SpawnTrigger, Velocity};
+use crate::{
+    map::builder::Map,
+    systems::{
+        AudioEvent, Blinking, DirectionalAnimation, Dying, Frozen, Ghost, GhostCollider, GhostState, LinearAnimation, Looping,
+        NodeId, PlayerControlled, Position, Visibility,
+    },
+};
+use bevy_ecs::{
+    entity::Entity,
+    event::{EventReader, EventWriter},
+    query::{With, Without},
+    resource::Resource,
+    system::{Commands, Query, Res, ResMut, Single},
+};
+
+use crate::events::{GameCommand, GameEvent};
+#[cfg(not(target_os = "emscripten"))]
+use bevy_ecs::system::NonSendMut;
+#[cfg(not(target_os = "emscripten"))]
+use sdl2::render::Canvas;
+#[cfg(not(target_os = "emscripten"))]
+use sdl2::video::{FullscreenType, Window};
+
+#[derive(Resource, Clone)]
+pub struct PlayerAnimation(pub DirectionalAnimation);
+
+#[derive(Resource, Clone)]
+pub struct PlayerDeathAnimation(pub LinearAnimation);
+
+/// Tracks whether the beginning sound has been played for the current startup sequence
+#[derive(Resource, Debug, Default, Clone, Copy)]
+pub struct IntroPlayed(pub bool);
+
+/// A resource to track the overall stage of the game from a high-level perspective.
+#[derive(Resource, Debug, PartialEq, Eq, Clone, Copy)]
+pub enum GameStage {
+    Starting(StartupSequence),
+    /// The main gameplay loop is active.
+    Playing,
+    /// Short freeze after Pac-Man eats a ghost to display bonus score
+    GhostEatenPause {
+        remaining_ticks: u32,
+        ghost_entity: Entity,
+        ghost_type: Ghost,
+        node: NodeId,
+    },
+    /// The player has died and the death sequence is in progress. At the end, the player will return to the startup sequence or game over.
+    PlayerDying(DyingSequence),
+    /// The game has ended.
+    GameOver,
+}
+
+#[derive(Resource, Debug, Default)]
+pub struct Paused(pub bool);
+
+pub fn handle_pause_command(
+    mut events: EventReader<GameEvent>,
+    mut paused: ResMut<Paused>,
+    mut audio_events: EventWriter<AudioEvent>,
+) {
+    for event in events.read() {
+        if let GameEvent::Command(GameCommand::TogglePause) = event {
+            paused.0 = !paused.0;
+            if paused.0 {
+                info!("Game paused");
+                audio_events.write(AudioEvent::Pause);
+            } else {
+                info!("Game resumed");
+                audio_events.write(AudioEvent::Resume);
+            }
+        }
+    }
+}
+
+#[cfg(not(target_os = "emscripten"))]
+pub fn handle_fullscreen_command(mut events: EventReader<GameEvent>, mut canvas: NonSendMut<&mut Canvas<Window>>) {
+    for event in events.read() {
+        if let GameEvent::Command(GameCommand::ToggleFullscreen) = event {
+            let window = canvas.window_mut();
+            let current = window.fullscreen_state();
+            let target = match current {
+                FullscreenType::Off => FullscreenType::Desktop,
+                _ => FullscreenType::Off,
+            };
+
+            if let Err(e) = window.set_fullscreen(target) {
+                tracing::warn!(error = ?e, "Failed to toggle fullscreen");
+            } else {
+                let on = matches!(target, FullscreenType::Desktop | FullscreenType::True);
+                info!(fullscreen = on, "Toggled fullscreen");
+            }
+        }
+    }
+}
+
+pub trait TooSimilar {
+    fn too_similar(&self, other: &Self) -> bool;
+}
+
+impl TooSimilar for GameStage {
+    fn too_similar(&self, other: &Self) -> bool {
+        discriminant(self) == discriminant(other) && {
+            // These states are very simple, so they're 'too similar' automatically
+            if matches!(self, GameStage::Playing | GameStage::GameOver) {
+                return true;
+            }
+
+            // Since the discriminant is the same but the values are different, it's the interior value that is somehow different
+            match (self, other) {
+                // These states are similar if their interior values are similar as well
+                (GameStage::Starting(startup), GameStage::Starting(other)) => startup.too_similar(other),
+                (GameStage::PlayerDying(dying), GameStage::PlayerDying(other)) => dying.too_similar(other),
+                (
+                    GameStage::GhostEatenPause {
+                        ghost_entity,
+                        ghost_type,
+                        node,
+                        ..
+                    },
+                    GameStage::GhostEatenPause {
+                        ghost_entity: other_ghost_entity,
+                        ghost_type: other_ghost_type,
+                        node: other_node,
+                        ..
+                    },
+                ) => ghost_entity == other_ghost_entity && ghost_type == other_ghost_type && node == other_node,
+                // Already handled, but kept to properly exhaust the match
+                (GameStage::Playing, _) | (GameStage::GameOver, _) => unreachable!(),
+                _ => unreachable!(),
+            }
+        }
+    }
+}
+
+/// A resource that manages the multi-stage startup sequence of the game.
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub enum StartupSequence {
+    /// Stage 1: Text-only stage
+    /// - Player & ghosts are hidden
+    /// - READY! and PLAYER ONE text are shown
+    /// - Energizers do not blink
+    TextOnly {
+        /// Remaining ticks in this stage
+        remaining_ticks: u32,
+    },
+    /// Stage 2: Characters visible stage
+    /// - PLAYER ONE text is hidden, READY! text remains
+    /// - Ghosts and Pac-Man are now shown
+    CharactersVisible {
+        /// Remaining ticks in this stage
+        remaining_ticks: u32,
+    },
+}
+
+impl Default for GameStage {
+    fn default() -> Self {
+        Self::Playing
+    }
+}
+
+impl TooSimilar for StartupSequence {
+    fn too_similar(&self, other: &Self) -> bool {
+        discriminant(self) == discriminant(other)
+    }
+}
+
+/// The state machine for the multi-stage death sequence.
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub enum DyingSequence {
+    /// Initial stage: entities are frozen, waiting for a delay.
+    Frozen { remaining_ticks: u32 },
+    /// Second stage: Pac-Man's death animation is playing.
+    Animating { remaining_ticks: u32 },
+    /// Third stage: Pac-Man is now gone, waiting a moment before the level restarts.
+    Hidden { remaining_ticks: u32 },
+}
+
+impl TooSimilar for DyingSequence {
+    fn too_similar(&self, other: &Self) -> bool {
+        discriminant(self) == discriminant(other)
+    }
+}
+
+/// A resource to store the number of player lives.
+#[derive(Resource, Debug)]
+pub struct PlayerLives(pub u8);
+
+impl Default for PlayerLives {
+    fn default() -> Self {
+        Self(3)
+    }
+}
+
+/// Handles startup sequence transitions and component management
+#[allow(clippy::too_many_arguments)]
+#[allow(clippy::type_complexity)]
+pub fn stage_system(
+    mut game_state: ResMut<GameStage>,
+    player_death_animation: Res<PlayerDeathAnimation>,
+    player_animation: Res<PlayerAnimation>,
+    mut player_lives: ResMut<PlayerLives>,
+    map: Res<Map>,
+    mut commands: Commands,
+    mut audio_events: EventWriter<AudioEvent>,
+    mut stage_event_reader: EventReader<StageTransition>,
+    mut blinking_query: Query<Entity, With<Blinking>>,
+    player: Single<(Entity, &mut Position), With<PlayerControlled>>,
+    mut item_query: Query<(Entity, &EntityType), With<ItemCollider>>,
+    mut ghost_query: Query<(Entity, &Ghost, &mut Position, &mut GhostState), (With<GhostCollider>, Without<PlayerControlled>)>,
+    mut intro_played: ResMut<IntroPlayed>,
+) {
+    let old_state = *game_state;
+    let mut new_state_opt: Option<GameStage> = None;
+
+    // Handle stage transition requests before normal ticking
+    for event in stage_event_reader.read() {
+        let StageTransition::GhostEatenPause {
+            ghost_entity,
+            ghost_type,
+        } = *event;
+        let pac_node = player.1.current_node();
+
+        debug!(ghost = ?ghost_type, node = pac_node, "Ghost eaten, entering pause state");
+        new_state_opt = Some(GameStage::GhostEatenPause {
+            remaining_ticks: 30,
+            ghost_entity,
+            ghost_type,
+            node: pac_node,
+        });
+    }
+
+    let new_state: GameStage = new_state_opt.unwrap_or_else(|| match *game_state {
+        GameStage::Playing => {
+            // This is the default state, do nothing
+            *game_state
+        }
+        GameStage::GhostEatenPause {
+            remaining_ticks,
+            ghost_entity,
+            ghost_type,
+            node,
+        } => {
+            if remaining_ticks > 0 {
+                GameStage::GhostEatenPause {
+                    remaining_ticks: remaining_ticks.saturating_sub(1),
+                    ghost_entity,
+                    ghost_type,
+                    node,
+                }
+            } else {
+                debug!("Ghost eaten pause ended, resuming gameplay");
+                GameStage::Playing
+            }
+        }
+        GameStage::Starting(sequence) => match sequence {
+            StartupSequence::TextOnly { remaining_ticks } => {
+                // Play the beginning sound once at the start of TextOnly stage
+                if !intro_played.0 {
+                    audio_events.write(AudioEvent::PlaySound(crate::audio::Sound::Beginning));
+                    intro_played.0 = true;
+                }
+                if remaining_ticks > 0 {
+                    GameStage::Starting(StartupSequence::TextOnly {
+                        remaining_ticks: remaining_ticks.saturating_sub(1),
+                    })
+                } else {
+                    GameStage::Starting(StartupSequence::CharactersVisible { remaining_ticks: 60 })
+                }
+            }
+            StartupSequence::CharactersVisible { remaining_ticks } => {
+                if remaining_ticks > 0 {
+                    GameStage::Starting(StartupSequence::CharactersVisible {
+                        remaining_ticks: remaining_ticks.saturating_sub(1),
+                    })
+                } else {
+                    info!("Startup sequence completed, beginning gameplay");
+                    GameStage::Playing
+                }
+            }
+        },
+        GameStage::PlayerDying(sequence) => match sequence {
+            DyingSequence::Frozen { remaining_ticks } => {
+                if remaining_ticks > 0 {
+                    GameStage::PlayerDying(DyingSequence::Frozen {
+                        remaining_ticks: remaining_ticks.saturating_sub(1),
+                    })
+                } else {
+                    let death_animation = &player_death_animation.0;
+                    let remaining_ticks = (death_animation.tiles.len() * death_animation.frame_duration as usize) as u32;
+                    debug!(animation_frames = remaining_ticks, "Starting player death animation");
+                    GameStage::PlayerDying(DyingSequence::Animating { remaining_ticks })
+                }
+            }
+            DyingSequence::Animating { remaining_ticks } => {
+                if remaining_ticks > 0 {
+                    GameStage::PlayerDying(DyingSequence::Animating {
+                        remaining_ticks: remaining_ticks.saturating_sub(1),
+                    })
+                } else {
+                    GameStage::PlayerDying(DyingSequence::Hidden { remaining_ticks: 60 })
+                }
+            }
+            DyingSequence::Hidden { remaining_ticks } => {
+                if remaining_ticks > 0 {
+                    GameStage::PlayerDying(DyingSequence::Hidden {
+                        remaining_ticks: remaining_ticks.saturating_sub(1),
+                    })
+                } else {
+                    player_lives.0 = player_lives.0.saturating_sub(1);
+
+                    if player_lives.0 > 0 {
+                        info!(remaining_lives = player_lives.0, "Player died, returning to startup sequence");
+                        GameStage::Starting(StartupSequence::CharactersVisible { remaining_ticks: 60 })
+                    } else {
+                        info!("All lives lost, game over");
+                        GameStage::GameOver
+                    }
+                }
+            }
+        },
+        GameStage::GameOver => *game_state,
+    });
+
+    if old_state == new_state {
+        return;
+    }
+
+    if !old_state.too_similar(&new_state) {
+        debug!(old_state = ?old_state, new_state = ?new_state, "Game stage transition");
+    }
+
+    match (old_state, new_state) {
+        (GameStage::Playing, GameStage::GhostEatenPause { ghost_entity, node, .. }) => {
+            // Freeze the player & non-eaten ghosts
+            commands.entity(player.0).insert(Frozen);
+            commands.entity(ghost_entity).insert(Frozen);
+            for (entity, _, _, state) in ghost_query.iter_mut() {
+                // Only freeze ghosts that are not currently eaten
+                if *state != GhostState::Eyes {
+                    debug!(ghost = ?entity, "Freezing ghost");
+                    commands.entity(entity).insert(Frozen);
+                }
+            }
+
+            // Hide the player & eaten ghost
+            commands.entity(player.0).insert(Visibility::hidden());
+            commands.entity(ghost_entity).insert(Visibility::hidden());
+
+            // Spawn bonus points entity at Pac-Man's position
+            commands.trigger(SpawnTrigger::Bonus {
+                position: Position::Stopped { node },
+                // TODO: Doubling score value for each consecutive ghost eaten
+                value: 200,
+                ttl: 30,
+            });
+        }
+        (GameStage::GhostEatenPause { ghost_entity, .. }, GameStage::Playing) => {
+            // Unfreeze and reveal the player & all ghosts
+            commands.entity(player.0).remove::<Frozen>().insert(Visibility::visible());
+            for (entity, _, _, _) in ghost_query.iter_mut() {
+                commands.entity(entity).remove::<Frozen>().insert(Visibility::visible());
+            }
+
+            // Reveal the eaten ghost and switch it to Eyes state
+            commands.entity(ghost_entity).insert(GhostState::Eyes);
+        }
+        (_, GameStage::PlayerDying(DyingSequence::Frozen { .. })) => {
+            // Freeze the player & ghosts
+            commands.entity(player.0).insert(Frozen);
+            for (entity, _, _, _) in ghost_query.iter_mut() {
+                commands.entity(entity).insert(Frozen);
+            }
+        }
+        (GameStage::PlayerDying(DyingSequence::Frozen { .. }), GameStage::PlayerDying(DyingSequence::Animating { .. })) => {
+            // Hide the ghosts
+            for (entity, _, _, _) in ghost_query.iter_mut() {
+                commands.entity(entity).insert(Visibility::hidden());
+            }
+
+            // Start Pac-Man's death animation
+            commands
+                .entity(player.0)
+                .remove::<DirectionalAnimation>()
+                .insert((Dying, player_death_animation.0.clone()));
+
+            // Play the death sound
+            audio_events.write(AudioEvent::PlaySound(crate::audio::Sound::PacmanDeath));
+        }
+        (_, GameStage::PlayerDying(DyingSequence::Hidden { .. })) => {
+            // Pac-Man's death animation is complete, so he should be hidden just like the ghosts.
+            // Then, we reset them all back to their original positions and states.
+
+            // Freeze the blinking power pellets, force them to be visible (if they were hidden by blinking)
+            for entity in blinking_query.iter_mut() {
+                commands.entity(entity).insert(Frozen).insert(Visibility::visible());
+            }
+
+            // Delete any fruit entities
+            for (entity, _) in item_query
+                .iter_mut()
+                .filter(|(_, entity_type)| matches!(entity_type, EntityType::Fruit(_)))
+            {
+                commands.entity(entity).despawn();
+            }
+
+            // Reset the player animation
+            commands
+                .entity(player.0)
+                .remove::<(Dying, LinearAnimation, Looping)>()
+                .insert((
+                    Velocity {
+                        speed: constants::mechanics::PLAYER_SPEED,
+                        direction: Direction::Left,
+                    },
+                    Position::Stopped {
+                        node: map.start_positions.pacman,
+                    },
+                    player_animation.0.clone(),
+                    Visibility::hidden(),
+                    Frozen,
+                ));
+
+            // Reset ghost positions and state
+            for (ghost_entity, ghost, _, _) in ghost_query.iter_mut() {
+                commands.entity(ghost_entity).insert((
+                    GhostState::Normal,
+                    Position::Stopped {
+                        node: match ghost {
+                            Ghost::Blinky => map.start_positions.blinky,
+                            Ghost::Pinky => map.start_positions.pinky,
+                            Ghost::Inky => map.start_positions.inky,
+                            Ghost::Clyde => map.start_positions.clyde,
+                        },
+                    },
+                    Frozen,
+                    Visibility::hidden(),
+                ));
+            }
+        }
+        (_, GameStage::Starting(StartupSequence::CharactersVisible { .. })) => {
+            // Unhide the player & ghosts
+            commands.entity(player.0).insert(Visibility::visible());
+            for (entity, _, _, _) in ghost_query.iter_mut() {
+                commands.entity(entity).insert(Visibility::visible());
+            }
+        }
+        (GameStage::Starting(StartupSequence::CharactersVisible { .. }), GameStage::Playing) => {
+            // Unfreeze the player & ghosts & blinking
+            commands.entity(player.0).remove::<Frozen>();
+            for (entity, _, _, _) in ghost_query.iter_mut() {
+                commands.entity(entity).remove::<Frozen>();
+            }
+            for entity in blinking_query.iter_mut() {
+                commands.entity(entity).remove::<Frozen>();
+            }
+            // Reset intro flag for the next round
+            intro_played.0 = false;
+        }
+        (_, GameStage::GameOver) => {
+            // Freeze blinking
+            for entity in blinking_query.iter_mut() {
+                commands.entity(entity).insert(Frozen);
+            }
+        }
+        _ => {}
+    }
+
+    *game_state = new_state;
+}

src/texture/animated.rs

@@ -1,53 +1,45 @@
-use crate::map::direction::Direction;
-use crate::texture::sprite::AtlasTile;
+use glam::U16Vec2;
 
-/// Fixed-size tile sequence that avoids heap allocation
-#[derive(Clone, Copy, Debug)]
+use crate::{map::direction::Direction, texture::sprite::AtlasTile};
+
+/// A sequence of tiles for animation, backed by a vector.
+#[derive(Debug, Clone)]
 pub struct TileSequence {
-    tiles: [AtlasTile; 4], // Fixed array, max 4 frames
-    count: usize,          // Actual number of frames used
+    tiles: Vec<AtlasTile>,
 }
 
 impl TileSequence {
-    /// Creates a new tile sequence from a slice of tiles
+    /// Creates a new tile sequence from a slice of tiles.
     pub fn new(tiles: &[AtlasTile]) -> Self {
-        let mut tile_array = [AtlasTile {
-            pos: glam::U16Vec2::ZERO,
-            size: glam::U16Vec2::ZERO,
-            color: None,
-        }; 4];
-
-        let count = tiles.len().min(4);
-        tile_array[..count].copy_from_slice(&tiles[..count]);
-
-        Self {
-            tiles: tile_array,
-            count,
-        }
+        Self { tiles: tiles.to_vec() }
     }
 
     /// Returns the tile at the given frame index, wrapping if necessary
     pub fn get_tile(&self, frame: usize) -> AtlasTile {
-        if self.count == 0 {
-            // Return a default empty tile if no tiles
-            AtlasTile {
-                pos: glam::U16Vec2::ZERO,
-                size: glam::U16Vec2::ZERO,
+        if self.tiles.is_empty() {
+            // Return a default or handle the error appropriately
+            // For now, let's return a default tile, assuming it's a sensible default
+            return AtlasTile {
+                pos: U16Vec2::ZERO,
+                size: U16Vec2::ZERO,
                 color: None,
-            }
-        } else {
-            self.tiles[frame % self.count]
+            };
         }
+        self.tiles[frame % self.tiles.len()]
     }
 
-    /// Returns true if this sequence has no tiles
+    pub fn len(&self) -> usize {
+        self.tiles.len()
+    }
+
+    /// Checks if the sequence contains any tiles.
     pub fn is_empty(&self) -> bool {
-        self.count == 0
+        self.tiles.is_empty()
     }
 }
 
-/// Type-safe directional tile storage with named fields
-#[derive(Clone, Copy, Debug)]
+/// A collection of tile sequences for each cardinal direction.
+#[derive(Debug, Clone)]
 pub struct DirectionalTiles {
     pub up: TileSequence,
     pub down: TileSequence,

src/texture/sprite.rs

@@ -4,6 +4,7 @@ use sdl2::pixels::Color;
 use sdl2::rect::Rect;
 use sdl2::render::{Canvas, RenderTarget, Texture};
 use std::collections::HashMap;
+use tracing::debug;
 
 use crate::error::TextureError;
 
@@ -57,19 +58,6 @@ impl AtlasTile {
         canvas.copy(&atlas.texture, src, dest).map_err(TextureError::RenderFailed)?;
         Ok(())
     }
-
-    /// Creates a new atlas tile.
-    #[allow(dead_code)]
-    pub fn new(pos: U16Vec2, size: U16Vec2, color: Option<Color>) -> Self {
-        Self { pos, size, color }
-    }
-
-    /// Sets the color of the tile.
-    #[allow(dead_code)]
-    pub fn with_color(mut self, color: Color) -> Self {
-        self.color = Some(color);
-        self
-    }
 }
 
 /// High-performance sprite atlas providing fast texture region lookups and rendering.
@@ -90,8 +78,10 @@ pub struct SpriteAtlas {
 
 impl SpriteAtlas {
     pub fn new(texture: Texture, mapper: AtlasMapper) -> Self {
+        let tile_count = mapper.frames.len();
         let tiles = mapper.frames.into_iter().collect();
 
+        debug!(tile_count, "Created sprite atlas");
         Self {
             texture,
             tiles,
@@ -107,42 +97,14 @@ impl SpriteAtlas {
     /// atlas. The returned tile can be used for immediate rendering or stored
     /// for repeated use in animations and entity sprites.
     pub fn get_tile(&self, name: &str) -> Result<AtlasTile, TextureError> {
-        let frame = self
-            .tiles
-            .get(name)
-            .ok_or_else(|| TextureError::AtlasTileNotFound(name.to_string()))?;
+        let frame = self.tiles.get(name).ok_or_else(|| {
+            debug!(tile_name = name, "Atlas tile not found");
+            TextureError::AtlasTileNotFound(name.to_string())
+        })?;
         Ok(AtlasTile {
             pos: frame.pos,
             size: frame.size,
             color: self.default_color,
         })
     }
-
-    #[allow(dead_code)]
-    pub fn set_color(&mut self, color: Color) {
-        self.default_color = Some(color);
-    }
-
-    #[allow(dead_code)]
-    pub fn texture(&self) -> &Texture {
-        &self.texture
-    }
-
-    /// Returns the number of tiles in the atlas.
-    #[allow(dead_code)]
-    pub fn tiles_count(&self) -> usize {
-        self.tiles.len()
-    }
-
-    /// Returns true if the atlas has a tile with the given name.
-    #[allow(dead_code)]
-    pub fn has_tile(&self, name: &str) -> bool {
-        self.tiles.contains_key(name)
-    }
-
-    /// Returns the default color of the atlas.
-    #[allow(dead_code)]
-    pub fn default_color(&self) -> Option<Color> {
-        self.default_color
-    }
 }

src/texture/sprites.rs

@@ -5,8 +5,10 @@
 //! The `GameSprite` enum is the main entry point, and its `to_path` method
 //! generates the correct path for a given sprite in the texture atlas.
 
-use crate::map::direction::Direction;
-use crate::systems::components::Ghost;
+use crate::{
+    map::direction::Direction,
+    systems::{FruitType, Ghost},
+};
 
 /// Represents the different sprites for Pac-Man.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -15,6 +17,8 @@ pub enum PacmanSprite {
     Moving(Direction, u8),
     /// The full, closed-mouth Pac-Man sprite.
     Full,
+    /// A single frame of the dying animation.
+    Dying(u8),
 }
 
 /// Represents the color of a frightened ghost.
@@ -46,12 +50,20 @@ pub enum MazeSprite {
     Energizer,
 }
 
+/// Represents the different effect sprites that can appear as bonus items.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum EffectSprite {
+    Bonus(u32),
+}
+
 /// A top-level enum that encompasses all game sprites.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum GameSprite {
     Pacman(PacmanSprite),
     Ghost(GhostSprite),
     Maze(MazeSprite),
+    Fruit(FruitType),
+    Effect(EffectSprite),
 }
 
 impl GameSprite {
@@ -60,44 +72,61 @@ impl GameSprite {
     /// This path corresponds to the filename in the texture atlas JSON file.
     pub fn to_path(self) -> String {
         match self {
-            GameSprite::Pacman(sprite) => match sprite {
-                PacmanSprite::Moving(dir, frame) => {
-                    let frame_char = match frame {
-                        0 => 'a',
-                        1 => 'b',
-                        _ => panic!("Invalid animation frame"),
-                    };
-                    format!("pacman/{}_{}.png", dir.as_ref().to_lowercase(), frame_char)
+            GameSprite::Pacman(PacmanSprite::Moving(dir, frame)) => format!(
+                "pacman/{}_{}.png",
+                dir.as_ref(),
+                match frame {
+                    0 => "a",
+                    1 => "b",
+                    _ => panic!("Invalid animation frame"),
                 }
-                PacmanSprite::Full => "pacman/full.png".to_string(),
-            },
-            GameSprite::Ghost(sprite) => match sprite {
-                GhostSprite::Normal(ghost, dir, frame) => {
-                    let frame_char = match frame {
-                        0 => 'a',
-                        1 => 'b',
-                        _ => panic!("Invalid animation frame"),
-                    };
-                    format!("ghost/{}/{}_{}.png", ghost.as_str(), dir.as_ref().to_lowercase(), frame_char)
+            ),
+            GameSprite::Pacman(PacmanSprite::Full) => "pacman/full.png".to_string(),
+            GameSprite::Pacman(PacmanSprite::Dying(frame)) => format!("pacman/death/{}.png", frame),
+
+            // Ghost sprites
+            GameSprite::Ghost(GhostSprite::Normal(ghost_type, dir, frame)) => {
+                let frame_char = match frame {
+                    0 => 'a',
+                    1 => 'b',
+                    _ => panic!("Invalid animation frame"),
+                };
+                format!(
+                    "ghost/{}/{}_{}.png",
+                    ghost_type.as_str(),
+                    dir.as_ref().to_lowercase(),
+                    frame_char
+                )
+            }
+            GameSprite::Ghost(GhostSprite::Frightened(color, frame)) => {
+                let frame_char = match frame {
+                    0 => 'a',
+                    1 => 'b',
+                    _ => panic!("Invalid animation frame"),
+                };
+                let color_str = match color {
+                    FrightenedColor::Blue => "blue",
+                    FrightenedColor::White => "white",
+                };
+                format!("ghost/frightened/{}_{}.png", color_str, frame_char)
+            }
+            GameSprite::Ghost(GhostSprite::Eyes(dir)) => format!("ghost/eyes/{}.png", dir.as_ref().to_lowercase()),
+
+            // Maze sprites
+            GameSprite::Maze(MazeSprite::Tile(index)) => format!("maze/tiles/{}.png", index),
+            GameSprite::Maze(MazeSprite::Pellet) => "maze/pellet.png".to_string(),
+            GameSprite::Maze(MazeSprite::Energizer) => "maze/energizer.png".to_string(),
+
+            // Fruit sprites
+            GameSprite::Fruit(fruit) => format!("edible/{}.png", Into::<&'static str>::into(fruit)),
+
+            // Effect sprites
+            GameSprite::Effect(EffectSprite::Bonus(value)) => match value {
+                100 | 200 | 300 | 400 | 700 | 800 | 1000 | 2000 | 3000 | 5000 => format!("effects/{}.png", value),
+                _ => {
+                    tracing::warn!("Invalid bonus value: {}", value);
+                    "effects/100.png".to_string()
                 }
-                GhostSprite::Frightened(color, frame) => {
-                    let frame_char = match frame {
-                        0 => 'a',
-                        1 => 'b',
-                        _ => panic!("Invalid animation frame"),
-                    };
-                    let color_str = match color {
-                        FrightenedColor::Blue => "blue",
-                        FrightenedColor::White => "white",
-                    };
-                    format!("ghost/frightened/{}_{}.png", color_str, frame_char)
-                }
-                GhostSprite::Eyes(dir) => format!("ghost/eyes/{}.png", dir.as_ref().to_lowercase()),
-            },
-            GameSprite::Maze(sprite) => match sprite {
-                MazeSprite::Tile(index) => format!("maze/tiles/{}.png", index),
-                MazeSprite::Pellet => "maze/pellet.png".to_string(),
-                MazeSprite::Energizer => "maze/energizer.png".to_string(),
             },
         }
     }

src/texture/text.rs

@@ -1,5 +1,3 @@
-#![allow(dead_code)]
-
 //! This module provides text rendering using the texture atlas.
 //!
 //! The TextTexture system renders text from the atlas using character mapping.
@@ -109,6 +107,7 @@ impl TextTexture {
         }
     }
 
+    #[allow(dead_code)]
     pub fn get_char_map(&self) -> &HashMap<char, AtlasTile> {
         &self.char_map
     }
@@ -167,26 +166,6 @@ impl TextTexture {
         Ok(())
     }
 
-    /// Sets the default color for text rendering.
-    pub fn set_color(&mut self, color: Color) {
-        self.default_color = Some(color);
-    }
-
-    /// Gets the current default color.
-    pub fn color(&self) -> Option<Color> {
-        self.default_color
-    }
-
-    /// Sets the scale for text rendering.
-    pub fn set_scale(&mut self, scale: f32) {
-        self.scale = scale;
-    }
-
-    /// Gets the current scale.
-    pub fn scale(&self) -> f32 {
-        self.scale
-    }
-
     /// Calculates the width of a string in pixels at the current scale.
     pub fn text_width(&self, text: &str) -> u32 {
         let char_width = (8.0 * self.scale) as u32;

src/texture/ttf.rs

@@ -31,6 +31,8 @@ pub struct TtfAtlas {
     char_tiles: HashMap<char, TtfCharTile>,
     /// Cached color modulation state to avoid redundant SDL2 calls
     last_modulation: Option<Color>,
+    /// Cached maximum character height
+    max_char_height: u32,
 }
 
 const TTF_CHARS: &str = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz.,:-/()ms μµ%± ";
@@ -101,6 +103,7 @@ impl TtfAtlas {
             texture: atlas_texture,
             char_tiles,
             last_modulation: None,
+            max_char_height: max_height,
         })
     }
 
@@ -261,12 +264,6 @@ impl TtfRenderer {
     /// Calculate the height of text in pixels
     pub fn text_height(&self, atlas: &TtfAtlas) -> u32 {
         // Find the maximum height among all characters
-        atlas
-            .char_tiles
-            .values()
-            .map(|tile| tile.size.y)
-            .max()
-            .unwrap_or(0)
-            .saturating_mul(self.scale as u32)
+        (atlas.max_char_height as f32 * self.scale) as u32
     }
 }

tests/asset.rs

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

tests/blinking.rs

@@ -1,9 +1,5 @@
 use bevy_ecs::{entity::Entity, system::RunSystemOnce, world::World};
-use pacman::systems::{
-    blinking::{blinking_system, Blinking},
-    components::{DeltaTime, Renderable},
-    Frozen, Hidden,
-};
+use pacman::systems::{blinking_system, Blinking, DeltaTime, Frozen, Renderable, Visibility};
 use speculoos::prelude::*;
 
 mod common;
@@ -24,11 +20,12 @@ fn spawn_blinking_entity(world: &mut World, interval_ticks: u32) -> Entity {
                 sprite: common::mock_atlas_tile(1),
                 layer: 0,
             },
+            Visibility::visible(),
         ))
         .id()
 }
 
-/// Spawns a test entity with blinking, renderable, and hidden components
+/// Spawns a test entity with blinking, renderable, and hidden visibility
 fn spawn_hidden_blinking_entity(world: &mut World, interval_ticks: u32) -> Entity {
     world
         .spawn((
@@ -37,7 +34,7 @@ fn spawn_hidden_blinking_entity(world: &mut World, interval_ticks: u32) -> Entit
                 sprite: common::mock_atlas_tile(1),
                 layer: 0,
             },
-            Hidden,
+            Visibility::hidden(),
         ))
         .id()
 }
@@ -51,12 +48,13 @@ fn spawn_frozen_blinking_entity(world: &mut World, interval_ticks: u32) -> Entit
                 sprite: common::mock_atlas_tile(1),
                 layer: 0,
             },
+            Visibility::visible(),
             Frozen,
         ))
         .id()
 }
 
-/// Spawns a test entity with blinking, renderable, hidden, and frozen components
+/// Spawns a test entity with blinking, renderable, hidden visibility, and frozen components
 fn spawn_frozen_hidden_blinking_entity(world: &mut World, interval_ticks: u32) -> Entity {
     world
         .spawn((
@@ -65,7 +63,7 @@ fn spawn_frozen_hidden_blinking_entity(world: &mut World, interval_ticks: u32) -
                 sprite: common::mock_atlas_tile(1),
                 layer: 0,
             },
-            Hidden,
+            Visibility::hidden(),
             Frozen,
         ))
         .id()
@@ -77,9 +75,22 @@ fn run_blinking_system(world: &mut World, delta_ticks: u32) {
     world.run_system_once(blinking_system).unwrap();
 }
 
-/// Checks if an entity has the Hidden component
-fn has_hidden_component(world: &World, entity: Entity) -> bool {
-    world.entity(entity).contains::<Hidden>()
+/// Checks if an entity is visible
+fn is_entity_visible(world: &World, entity: Entity) -> bool {
+    world
+        .entity(entity)
+        .get::<Visibility>()
+        .map(|v| v.is_visible())
+        .unwrap_or(true) // Default to visible if no Visibility component
+}
+
+/// Checks if an entity is hidden
+fn is_entity_hidden(world: &World, entity: Entity) -> bool {
+    world
+        .entity(entity)
+        .get::<Visibility>()
+        .map(|v| v.is_hidden())
+        .unwrap_or(false) // Default to visible if no Visibility component
 }
 
 /// Checks if an entity has the Frozen component
@@ -104,7 +115,7 @@ fn test_blinking_system_normal_interval_no_toggle() {
     run_blinking_system(&mut world, 3);
 
     // Entity should not be hidden yet
-    assert_that(&has_hidden_component(&world, entity)).is_false();
+    assert_that(&is_entity_visible(&world, entity)).is_true();
 
     // Check that timer was updated
     let blinking = world.entity(entity).get::<Blinking>().unwrap();
@@ -120,7 +131,7 @@ fn test_blinking_system_normal_interval_first_toggle() {
     run_blinking_system(&mut world, 5);
 
     // Entity should now be hidden
-    assert_that(&has_hidden_component(&world, entity)).is_true();
+    assert_that(&is_entity_hidden(&world, entity)).is_true();
 
     // Check that timer was reset
     let blinking = world.entity(entity).get::<Blinking>().unwrap();
@@ -134,11 +145,11 @@ fn test_blinking_system_normal_interval_second_toggle() {
 
     // First toggle: 5 ticks
     run_blinking_system(&mut world, 5);
-    assert_that(&has_hidden_component(&world, entity)).is_true();
+    assert_that(&is_entity_hidden(&world, entity)).is_true();
 
     // Second toggle: another 5 ticks
     run_blinking_system(&mut world, 5);
-    assert_that(&has_hidden_component(&world, entity)).is_false();
+    assert_that(&is_entity_visible(&world, entity)).is_true();
 }
 
 #[test]
@@ -150,7 +161,7 @@ fn test_blinking_system_normal_interval_multiple_intervals() {
     run_blinking_system(&mut world, 7);
 
     // Should toggle twice (even number), so back to original state (not hidden)
-    assert_that(&has_hidden_component(&world, entity)).is_false();
+    assert_that(&is_entity_visible(&world, entity)).is_true();
 
     // Check that timer was updated to remainder
     let blinking = world.entity(entity).get::<Blinking>().unwrap();
@@ -166,7 +177,7 @@ fn test_blinking_system_normal_interval_odd_intervals() {
     run_blinking_system(&mut world, 5);
 
     // Should toggle twice (even number), so back to original state (not hidden)
-    assert_that(&has_hidden_component(&world, entity)).is_false();
+    assert_that(&is_entity_visible(&world, entity)).is_true();
 
     // Check that timer was updated to remainder
     let blinking = world.entity(entity).get::<Blinking>().unwrap();
@@ -182,7 +193,7 @@ fn test_blinking_system_zero_interval_with_ticks() {
     run_blinking_system(&mut world, 1);
 
     // Entity should be hidden immediately
-    assert_that(&has_hidden_component(&world, entity)).is_true();
+    assert_that(&is_entity_hidden(&world, entity)).is_true();
 }
 
 #[test]
@@ -194,7 +205,7 @@ fn test_blinking_system_zero_interval_no_ticks() {
     run_blinking_system(&mut world, 0);
 
     // Entity should not be hidden (no time passed)
-    assert_that(&has_hidden_component(&world, entity)).is_false();
+    assert_that(&is_entity_visible(&world, entity)).is_true();
 }
 
 #[test]
@@ -206,7 +217,7 @@ fn test_blinking_system_zero_interval_toggle_back() {
     run_blinking_system(&mut world, 1);
 
     // Entity should be unhidden
-    assert_that(&has_hidden_component(&world, entity)).is_false();
+    assert_that(&is_entity_visible(&world, entity)).is_true();
 }
 
 #[test]
@@ -218,7 +229,7 @@ fn test_blinking_system_frozen_entity_unhidden() {
     run_blinking_system(&mut world, 10);
 
     // Frozen entity should be unhidden and stay unhidden
-    assert_that(&has_hidden_component(&world, entity)).is_false();
+    assert_that(&is_entity_visible(&world, entity)).is_true();
     assert_that(&has_frozen_component(&world, entity)).is_true();
 }
 
@@ -231,7 +242,7 @@ fn test_blinking_system_frozen_entity_no_blinking() {
     run_blinking_system(&mut world, 10);
 
     // Frozen entity should not be hidden (blinking disabled)
-    assert_that(&has_hidden_component(&world, entity)).is_false();
+    assert_that(&is_entity_visible(&world, entity)).is_true();
     assert_that(&has_frozen_component(&world, entity)).is_true();
 }
 
@@ -259,7 +270,7 @@ fn test_blinking_system_entity_without_renderable_ignored() {
     run_blinking_system(&mut world, 10);
 
     // Entity should not be affected (not in query)
-    assert_that(&has_hidden_component(&world, entity)).is_false();
+    assert_that(&is_entity_visible(&world, entity)).is_true();
 }
 
 #[test]
@@ -278,7 +289,7 @@ fn test_blinking_system_entity_without_blinking_ignored() {
     run_blinking_system(&mut world, 10);
 
     // Entity should not be affected (not in query)
-    assert_that(&has_hidden_component(&world, entity)).is_false();
+    assert_that(&is_entity_visible(&world, entity)).is_true();
 }
 
 #[test]
@@ -290,7 +301,7 @@ fn test_blinking_system_large_interval() {
     run_blinking_system(&mut world, 500);
 
     // Entity should not be hidden yet
-    assert_that(&has_hidden_component(&world, entity)).is_false();
+    assert_that(&is_entity_visible(&world, entity)).is_true();
 
     // Check that timer was updated
     let blinking = world.entity(entity).get::<Blinking>().unwrap();
@@ -306,11 +317,11 @@ fn test_blinking_system_very_small_interval() {
     run_blinking_system(&mut world, 1);
 
     // Entity should be hidden
-    assert_that(&has_hidden_component(&world, entity)).is_true();
+    assert_that(&is_entity_hidden(&world, entity)).is_true();
 
     // Run system with another 1 tick
     run_blinking_system(&mut world, 1);
 
     // Entity should be unhidden
-    assert_that(&has_hidden_component(&world, entity)).is_false();
+    assert_that(&is_entity_visible(&world, entity)).is_true();
 }

tests/collision.rs

@@ -36,19 +36,17 @@ fn test_check_collision_helper() {
 
 #[test]
 fn test_collision_system_pacman_item() {
-    let mut world = common::create_test_world();
+    let (mut world, mut schedule) = common::create_test_world();
     let _pacman = common::spawn_test_pacman(&mut world, 0);
     let _item = common::spawn_test_item(&mut world, 0, EntityType::Pellet);
 
     // Run collision system - should not panic
-    world
-        .run_system_once(collision_system)
-        .expect("System should run successfully");
+    schedule.run(&mut world);
 }
 
 #[test]
 fn test_collision_system_pacman_ghost() {
-    let mut world = common::create_test_world();
+    let (mut world, _) = common::create_test_world();
     let _pacman = common::spawn_test_pacman(&mut world, 0);
     let _ghost = common::spawn_test_ghost(&mut world, 0, GhostState::Normal);
 
@@ -60,19 +58,17 @@ fn test_collision_system_pacman_ghost() {
 
 #[test]
 fn test_collision_system_no_collision() {
-    let mut world = common::create_test_world();
+    let (mut world, mut schedule) = common::create_test_world();
     let _pacman = common::spawn_test_pacman(&mut world, 0);
     let _ghost = common::spawn_test_ghost(&mut world, 1, GhostState::Normal); // Different node
 
     // Run collision system - should not panic
-    world
-        .run_system_once(collision_system)
-        .expect("System should run successfully");
+    schedule.run(&mut world);
 }
 
 #[test]
 fn test_collision_system_multiple_entities() {
-    let mut world = common::create_test_world();
+    let (mut world, _) = common::create_test_world();
     let _pacman = common::spawn_test_pacman(&mut world, 0);
     let _item = common::spawn_test_item(&mut world, 0, EntityType::Pellet);
     let _ghost = common::spawn_test_ghost(&mut world, 0, GhostState::Normal);

tests/common.rs

@@ -1,11 +1,11 @@
 #![allow(dead_code)]
 
-use bevy_ecs::{entity::Entity, event::Events, world::World};
+use bevy_ecs::{entity::Entity, event::Events, schedule::Schedule, world::World};
 use glam::{U16Vec2, Vec2};
 use pacman::{
-    asset::{get_asset_bytes, Asset},
+    asset::Asset,
     constants::RAW_BOARD,
-    events::GameEvent,
+    events::{CollisionTrigger, GameEvent},
     game::ATLAS_FRAMES,
     map::{
         builder::Map,
@@ -13,8 +13,9 @@ use pacman::{
         graph::{Graph, Node},
     },
     systems::{
-        AudioEvent, AudioState, BufferedDirection, Collider, DebugState, DeltaTime, EntityType, Ghost, GhostCollider, GhostState,
-        GlobalState, ItemCollider, MovementModifiers, PacmanCollider, PlayerControlled, Position, ScoreResource, Velocity,
+        item_collision_observer, AudioEvent, AudioState, BufferedDirection, Collider, DebugState, DeltaTime, EntityType,
+        FruitSprites, Ghost, GhostCollider, GhostState, GlobalState, ItemCollider, MovementModifiers, PacmanCollider,
+        PelletCount, PlayerControlled, Position, ScoreResource, Velocity,
     },
     texture::sprite::{AtlasMapper, AtlasTile, SpriteAtlas},
 };
@@ -42,7 +43,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::AtlasImage).unwrap();
+    let atlas_bytes = Asset::AtlasImage.get_bytes().unwrap();
 
     let texture = texture_creator.load_texture_bytes(&atlas_bytes).unwrap();
 
@@ -74,7 +75,7 @@ pub fn create_test_graph() -> Graph {
 }
 
 /// Creates a basic test world with required resources for ECS systems
-pub fn create_test_world() -> World {
+pub fn create_test_world() -> (World, Schedule) {
     let mut world = World::new();
 
     // Add required resources
@@ -82,16 +83,22 @@ pub fn create_test_world() -> World {
     world.insert_resource(Events::<pacman::error::GameError>::default());
     world.insert_resource(Events::<AudioEvent>::default());
     world.insert_resource(ScoreResource(0));
+    world.insert_resource(FruitSprites::default());
     world.insert_resource(AudioState::default());
     world.insert_resource(GlobalState { exit: false });
     world.insert_resource(DebugState::default());
+    world.insert_resource(PelletCount(0));
     world.insert_resource(DeltaTime {
         seconds: 1.0 / 60.0,
         ticks: 1,
     }); // 60 FPS
     world.insert_resource(create_test_map());
 
-    world
+    let schedule = Schedule::default();
+
+    world.add_observer(item_collision_observer);
+
+    (world, schedule)
 }
 
 /// Creates a test map using the default RAW_BOARD
@@ -161,9 +168,8 @@ pub fn send_game_event(world: &mut World, event: GameEvent) {
 }
 
 /// Sends a collision event between two entities
-pub fn send_collision_event(world: &mut World, entity1: Entity, entity2: Entity) {
-    let mut events = world.resource_mut::<Events<GameEvent>>();
-    events.send(GameEvent::Collision(entity1, entity2));
+pub fn trigger_collision(world: &mut World, event: CollisionTrigger) {
+    world.trigger(event);
 }
 
 /// Creates a mock atlas tile for testing

tests/constants.rs

@@ -1,24 +0,0 @@
-use pacman::constants::*;
-use speculoos::prelude::*;
-
-#[test]
-fn test_raw_board_structure() {
-    // Test board dimensions match expected size
-    assert_that(&RAW_BOARD.len()).is_equal_to(BOARD_CELL_SIZE.y as usize);
-    for row in RAW_BOARD.iter() {
-        assert_that(&row.len()).is_equal_to(BOARD_CELL_SIZE.x as usize);
-    }
-
-    // Test boundaries are properly walled
-    assert_that(&RAW_BOARD[0].chars().all(|c| c == '#')).is_true();
-    assert_that(&RAW_BOARD[RAW_BOARD.len() - 1].chars().all(|c| c == '#')).is_true();
-}
-
-#[test]
-fn test_raw_board_contains_required_elements() {
-    // Test that essential game elements are present
-    assert_that(&RAW_BOARD.iter().any(|row| row.contains('X'))).is_true();
-    assert_that(&RAW_BOARD.iter().any(|row| row.contains("=="))).is_true();
-    assert_that(&RAW_BOARD.iter().any(|row| row.chars().any(|c| c == 'T'))).is_true();
-    assert_that(&RAW_BOARD.iter().any(|row| row.chars().any(|c| c == 'o'))).is_true();
-}

tests/error.rs

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

tests/game.rs

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

tests/input.rs

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

tests/item.rs

@@ -1,5 +1,8 @@
-use bevy_ecs::{entity::Entity, system::RunSystemOnce};
-use pacman::systems::{is_valid_item_collision, item_system, EntityType, GhostState, Position, ScoreResource};
+use bevy_ecs::entity::Entity;
+use pacman::{
+    events::CollisionTrigger,
+    systems::{EntityType, GhostState, Position, ScoreResource},
+};
 use speculoos::prelude::*;
 
 mod common;
@@ -24,35 +27,18 @@ fn test_is_collectible_item() {
     assert_that(&EntityType::Ghost.is_collectible()).is_false();
 }
 
-#[test]
-fn test_is_valid_item_collision() {
-    // Player-item collisions should be valid
-    assert_that(&is_valid_item_collision(EntityType::Player, EntityType::Pellet)).is_true();
-    assert_that(&is_valid_item_collision(EntityType::Player, EntityType::PowerPellet)).is_true();
-    assert_that(&is_valid_item_collision(EntityType::Pellet, EntityType::Player)).is_true();
-    assert_that(&is_valid_item_collision(EntityType::PowerPellet, EntityType::Player)).is_true();
-
-    // Non-player-item collisions should be invalid
-    assert_that(&is_valid_item_collision(EntityType::Player, EntityType::Ghost)).is_false();
-    assert_that(&is_valid_item_collision(EntityType::Ghost, EntityType::Pellet)).is_false();
-    assert_that(&is_valid_item_collision(EntityType::Pellet, EntityType::PowerPellet)).is_false();
-    assert_that(&is_valid_item_collision(EntityType::Player, EntityType::Player)).is_false();
-}
-
 #[test]
 fn test_item_system_pellet_collection() {
-    let mut world = common::create_test_world();
-    let pacman = common::spawn_test_pacman(&mut world, 0);
+    let (mut world, mut _schedule) = common::create_test_world();
     let pellet = common::spawn_test_item(&mut world, 1, EntityType::Pellet);
 
     // Send collision event
-    common::send_collision_event(&mut world, pacman, pellet);
+    common::trigger_collision(&mut world, CollisionTrigger::ItemCollision { item: pellet });
 
-    // Run the item system
-    world.run_system_once(item_system).expect("System should run successfully");
+    world.flush();
 
     // Check that score was updated
-    let score = world.resource::<ScoreResource>();
+    let score = world.resource_mut::<ScoreResource>();
     assert_that(&score.0).is_equal_to(10);
 
     // Check that the pellet was despawned (query should return empty)
@@ -66,13 +52,12 @@ fn test_item_system_pellet_collection() {
 
 #[test]
 fn test_item_system_power_pellet_collection() {
-    let mut world = common::create_test_world();
-    let pacman = common::spawn_test_pacman(&mut world, 0);
+    let (mut world, mut _schedule) = common::create_test_world();
     let power_pellet = common::spawn_test_item(&mut world, 1, EntityType::PowerPellet);
 
-    common::send_collision_event(&mut world, pacman, power_pellet);
+    common::trigger_collision(&mut world, CollisionTrigger::ItemCollision { item: power_pellet });
 
-    world.run_system_once(item_system).expect("System should run successfully");
+    world.flush();
 
     // Check that score was updated with power pellet value
     let score = world.resource::<ScoreResource>();
@@ -89,18 +74,17 @@ fn test_item_system_power_pellet_collection() {
 
 #[test]
 fn test_item_system_multiple_collections() {
-    let mut world = common::create_test_world();
-    let pacman = common::spawn_test_pacman(&mut world, 0);
+    let (mut world, mut _schedule) = common::create_test_world();
     let pellet1 = common::spawn_test_item(&mut world, 1, EntityType::Pellet);
     let pellet2 = common::spawn_test_item(&mut world, 2, EntityType::Pellet);
     let power_pellet = common::spawn_test_item(&mut world, 3, EntityType::PowerPellet);
 
     // Send multiple collision events
-    common::send_collision_event(&mut world, pacman, pellet1);
-    common::send_collision_event(&mut world, pacman, pellet2);
-    common::send_collision_event(&mut world, pacman, power_pellet);
+    common::trigger_collision(&mut world, CollisionTrigger::ItemCollision { item: pellet1 });
+    common::trigger_collision(&mut world, CollisionTrigger::ItemCollision { item: pellet2 });
+    common::trigger_collision(&mut world, CollisionTrigger::ItemCollision { item: power_pellet });
 
-    world.run_system_once(item_system).expect("System should run successfully");
+    world.flush();
 
     // Check final score: 2 pellets (20) + 1 power pellet (50) = 70
     let score = world.resource::<ScoreResource>();
@@ -123,8 +107,7 @@ fn test_item_system_multiple_collections() {
 
 #[test]
 fn test_item_system_ignores_non_item_collisions() {
-    let mut world = common::create_test_world();
-    let pacman = common::spawn_test_pacman(&mut world, 0);
+    let (mut world, mut _schedule) = common::create_test_world();
 
     // Create a ghost entity (not an item)
     let ghost = world.spawn((Position::Stopped { node: 2 }, EntityType::Ghost)).id();
@@ -133,9 +116,9 @@ fn test_item_system_ignores_non_item_collisions() {
     let initial_score = world.resource::<ScoreResource>().0;
 
     // Send collision event between pacman and ghost
-    common::send_collision_event(&mut world, pacman, ghost);
+    common::trigger_collision(&mut world, CollisionTrigger::ItemCollision { item: ghost });
 
-    world.run_system_once(item_system).expect("System should run successfully");
+    world.flush();
 
     // Score should remain unchanged
     let score = world.resource::<ScoreResource>();
@@ -152,14 +135,14 @@ fn test_item_system_ignores_non_item_collisions() {
 
 #[test]
 fn test_item_system_no_collision_events() {
-    let mut world = common::create_test_world();
+    let (mut world, mut _schedule) = common::create_test_world();
     let _pacman = common::spawn_test_pacman(&mut world, 0);
     let _pellet = common::spawn_test_item(&mut world, 1, EntityType::Pellet);
 
     let initial_score = world.resource::<ScoreResource>().0;
 
     // Run system without any collision events
-    world.run_system_once(item_system).expect("System should run successfully");
+    world.flush();
 
     // Nothing should change
     let score = world.resource::<ScoreResource>();
@@ -174,19 +157,15 @@ fn test_item_system_no_collision_events() {
 
 #[test]
 fn test_item_system_collision_with_missing_entity() {
-    let mut world = common::create_test_world();
-    let pacman = common::spawn_test_pacman(&mut world, 0);
+    let (mut world, mut _schedule) = common::create_test_world();
 
     // Create a fake entity ID that doesn't exist
     let fake_entity = Entity::from_raw(999);
 
-    common::send_collision_event(&mut world, pacman, fake_entity);
+    common::trigger_collision(&mut world, CollisionTrigger::ItemCollision { item: fake_entity });
 
     // System should handle gracefully and not crash
-    world
-        .run_system_once(item_system)
-        .expect("System should handle missing entities gracefully");
-
+    world.flush();
     // Score should remain unchanged
     let score = world.resource::<ScoreResource>();
     assert_that(&score.0).is_equal_to(0);
@@ -194,17 +173,16 @@ fn test_item_system_collision_with_missing_entity() {
 
 #[test]
 fn test_item_system_preserves_existing_score() {
-    let mut world = common::create_test_world();
+    let (mut world, mut _schedule) = common::create_test_world();
 
     // Set initial score
     world.insert_resource(ScoreResource(100));
 
-    let pacman = common::spawn_test_pacman(&mut world, 0);
     let pellet = common::spawn_test_item(&mut world, 1, EntityType::Pellet);
 
-    common::send_collision_event(&mut world, pacman, pellet);
+    common::trigger_collision(&mut world, CollisionTrigger::ItemCollision { item: pellet });
 
-    world.run_system_once(item_system).expect("System should run successfully");
+    world.flush();
 
     // Score should be initial + pellet value
     let score = world.resource::<ScoreResource>();
@@ -213,8 +191,7 @@ fn test_item_system_preserves_existing_score() {
 
 #[test]
 fn test_power_pellet_does_not_affect_ghosts_in_eyes_state() {
-    let mut world = common::create_test_world();
-    let pacman = common::spawn_test_pacman(&mut world, 0);
+    let (mut world, mut _schedule) = common::create_test_world();
     let power_pellet = common::spawn_test_item(&mut world, 1, EntityType::PowerPellet);
 
     // Spawn a ghost in Eyes state (returning to ghost house)
@@ -223,9 +200,9 @@ fn test_power_pellet_does_not_affect_ghosts_in_eyes_state() {
     // Spawn a ghost in Normal state
     let normal_ghost = common::spawn_test_ghost(&mut world, 3, GhostState::Normal);
 
-    common::send_collision_event(&mut world, pacman, power_pellet);
+    common::trigger_collision(&mut world, CollisionTrigger::ItemCollision { item: power_pellet });
 
-    world.run_system_once(item_system).expect("System should run successfully");
+    world.flush();
 
     // Check that the power pellet was collected and score updated
     let score = world.resource::<ScoreResource>();

tests/map_builder.rs

@@ -1,10 +1,11 @@
 use glam::Vec2;
 use pacman::constants::{CELL_SIZE, RAW_BOARD};
 use pacman::map::builder::Map;
+use pacman::map::graph::TraversalFlags;
 use speculoos::prelude::*;
 
 #[test]
-fn test_map_creation() {
+fn test_map_creation_success() {
     let map = Map::new(RAW_BOARD).unwrap();
 
     assert_that(&map.graph.nodes().count()).is_greater_than(0);
@@ -22,7 +23,7 @@ fn test_map_creation() {
 }
 
 #[test]
-fn test_map_node_positions() {
+fn test_map_node_positions_accuracy() {
     let map = Map::new(RAW_BOARD).unwrap();
 
     for (grid_pos, &node_id) in &map.grid_to_node {
@@ -35,3 +36,54 @@ fn test_map_node_positions() {
         assert_that(&node.position).is_equal_to(expected_pos);
     }
 }
+
+#[test]
+fn test_start_positions_are_valid() {
+    let map = Map::new(RAW_BOARD).unwrap();
+    let positions = &map.start_positions;
+
+    // All start positions should exist in the graph
+    assert_that(&map.graph.get_node(positions.pacman)).is_some();
+    assert_that(&map.graph.get_node(positions.blinky)).is_some();
+    assert_that(&map.graph.get_node(positions.pinky)).is_some();
+    assert_that(&map.graph.get_node(positions.inky)).is_some();
+    assert_that(&map.graph.get_node(positions.clyde)).is_some();
+}
+
+#[test]
+fn test_ghost_house_has_ghost_only_entrance() {
+    let map = Map::new(RAW_BOARD).unwrap();
+
+    // Find the house entrance node
+    let house_entrance = map.start_positions.blinky;
+
+    // Check that there's a ghost-only connection from the house entrance
+    let mut has_ghost_only_connection = false;
+    for edge in map.graph.adjacency_list[house_entrance as usize].edges() {
+        if edge.traversal_flags == TraversalFlags::GHOST {
+            has_ghost_only_connection = true;
+            break;
+        }
+    }
+    assert_that(&has_ghost_only_connection).is_true();
+}
+
+#[test]
+fn test_tunnel_connections_exist() {
+    let map = Map::new(RAW_BOARD).unwrap();
+
+    // Find tunnel nodes by looking for nodes with zero-distance connections
+    let mut has_tunnel_connection = false;
+    for intersection in &map.graph.adjacency_list {
+        for edge in intersection.edges() {
+            if edge.distance == 0.0f32 {
+                has_tunnel_connection = true;
+                break;
+            }
+        }
+        if has_tunnel_connection {
+            break;
+        }
+    }
+    assert_that(&has_tunnel_connection).is_true();
+}

tests/player.rs

@@ -112,7 +112,7 @@ fn test_entity_type_traversal_flags() {
 
 #[test]
 fn test_player_control_system_move_command() {
-    let mut world = common::create_test_world();
+    let (mut world, _) = common::create_test_world();
     let _player = common::spawn_test_player(&mut world, 0);
 
     // Send move command
@@ -141,7 +141,7 @@ fn test_player_control_system_move_command() {
 
 #[test]
 fn test_player_control_system_exit_command() {
-    let mut world = common::create_test_world();
+    let (mut world, _) = common::create_test_world();
     let _player = common::spawn_test_player(&mut world, 0);
 
     // Send exit command
@@ -159,7 +159,7 @@ fn test_player_control_system_exit_command() {
 
 #[test]
 fn test_player_control_system_toggle_debug() {
-    let mut world = common::create_test_world();
+    let (mut world, _) = common::create_test_world();
     let _player = common::spawn_test_player(&mut world, 0);
 
     // Send toggle debug command
@@ -177,7 +177,7 @@ fn test_player_control_system_toggle_debug() {
 
 #[test]
 fn test_player_control_system_mute_audio() {
-    let mut world = common::create_test_world();
+    let (mut world, _) = common::create_test_world();
     let _player = common::spawn_test_player(&mut world, 0);
 
     // Send mute audio command
@@ -206,7 +206,7 @@ fn test_player_control_system_mute_audio() {
 
 #[test]
 fn test_player_control_system_no_player_entity() {
-    let mut world = common::create_test_world();
+    let (mut world, _) = common::create_test_world();
     // Don't spawn a player entity
 
     common::send_game_event(&mut world, GameEvent::Command(GameCommand::MovePlayer(Direction::Up)));
@@ -214,16 +214,14 @@ fn test_player_control_system_no_player_entity() {
     // Run the system - should write an error
     world
         .run_system_once(player_control_system)
-        .expect("System should run successfully");
+        .expect("System should run successfully even with no player entity");
 
-    // Check that an error was written (we can't easily check Events without manual management,
-    // so for this test we just verify the system ran without panicking)
-    // In a real implementation, you might expose error checking through the ECS world
+    // The system should run successfully and simply ignore movement commands when there's no player
 }
 
 #[test]
 fn test_player_movement_system_buffered_direction_expires() {
-    let mut world = common::create_test_world();
+    let (mut world, _) = common::create_test_world();
     let player = common::spawn_test_player(&mut world, 0);
 
     // Set a buffered direction with short time
@@ -253,7 +251,7 @@ fn test_player_movement_system_buffered_direction_expires() {
 
 #[test]
 fn test_player_movement_system_start_moving_from_stopped() {
-    let mut world = common::create_test_world();
+    let (mut world, _) = common::create_test_world();
     let _player = common::spawn_test_player(&mut world, 0);
 
     // Player starts at node 0, facing right (towards node 1)
@@ -278,7 +276,7 @@ fn test_player_movement_system_start_moving_from_stopped() {
 
 #[test]
 fn test_player_movement_system_buffered_direction_change() {
-    let mut world = common::create_test_world();
+    let (mut world, _) = common::create_test_world();
     let player = common::spawn_test_player(&mut world, 0);
 
     // Set a buffered direction to go down (towards node 2)
@@ -309,7 +307,7 @@ fn test_player_movement_system_buffered_direction_change() {
 
 #[test]
 fn test_player_movement_system_no_valid_edge() {
-    let mut world = common::create_test_world();
+    let (mut world, _) = common::create_test_world();
     let player = common::spawn_test_player(&mut world, 0);
 
     // Set velocity to direction with no edge
@@ -334,7 +332,7 @@ fn test_player_movement_system_no_valid_edge() {
 
 #[test]
 fn test_player_movement_system_continue_moving() {
-    let mut world = common::create_test_world();
+    let (mut world, _) = common::create_test_world();
     let player = common::spawn_test_player(&mut world, 0);
 
     // Set player to already be moving
@@ -364,7 +362,7 @@ fn test_player_movement_system_continue_moving() {
 
 #[test]
 fn test_full_player_input_to_movement_flow() {
-    let mut world = common::create_test_world();
+    let (mut world, _) = common::create_test_world();
     let _player = common::spawn_test_player(&mut world, 0);
 
     // Send move command
@@ -398,7 +396,7 @@ fn test_full_player_input_to_movement_flow() {
 
 #[test]
 fn test_buffered_direction_timing() {
-    let mut world = common::create_test_world();
+    let (mut world, _) = common::create_test_world();
     let _player = common::spawn_test_player(&mut world, 0);
 
     // Send move command
@@ -437,7 +435,7 @@ fn test_buffered_direction_timing() {
 
 #[test]
 fn test_multiple_rapid_direction_changes() {
-    let mut world = common::create_test_world();
+    let (mut world, _) = common::create_test_world();
     let _player = common::spawn_test_player(&mut world, 0);
 
     // Send multiple rapid direction changes
@@ -470,7 +468,7 @@ fn test_multiple_rapid_direction_changes() {
 
 #[test]
 fn test_player_state_persistence_across_systems() {
-    let mut world = common::create_test_world();
+    let (mut world, _) = common::create_test_world();
     let _player = common::spawn_test_player(&mut world, 0);
 
     // Test that multiple commands can be processed - but need to handle events properly

tests/profiling.rs

@@ -73,25 +73,6 @@ fn test_default_zero_timing_for_unused_systems() {
     }
 }
 
-#[test]
-fn test_pre_populated_timing_entries() {
-    let timings = SystemTimings::default();
-
-    // Verify that we can add timing to any SystemId without panicking
-    // (this would fail with the old implementation if the entry didn't exist)
-    // Use the same tick for all systems to avoid zero-padding
-    for id in SystemId::iter() {
-        timings.add_timing(id, Duration::from_nanos(1), 1);
-    }
-
-    // Verify all systems now have non-zero timing
-    let stats = timings.get_stats(1);
-    for id in SystemId::iter() {
-        let (avg, _) = stats.get(&id).unwrap();
-        assert_that(&(*avg > Duration::ZERO)).is_true();
-    }
-}
-
 #[test]
 fn test_total_system_timing() {
     let timings = SystemTimings::default();

tests/sprite.rs

@@ -1,70 +0,0 @@
-use glam::U16Vec2;
-use pacman::texture::sprite::{AtlasMapper, AtlasTile, MapperFrame};
-use sdl2::pixels::Color;
-use speculoos::prelude::*;
-use std::collections::HashMap;
-
-mod common;
-
-#[test]
-fn test_atlas_mapper_frame_lookup() {
-    let mut frames = HashMap::new();
-    frames.insert(
-        "test".to_string(),
-        MapperFrame {
-            pos: U16Vec2::new(10, 20),
-            size: U16Vec2::new(32, 64),
-        },
-    );
-
-    let mapper = AtlasMapper { frames };
-
-    // Test direct frame lookup
-    let frame = mapper.frames.get("test");
-    assert_that(&frame.is_some()).is_true();
-    let frame = frame.unwrap();
-    assert_that(&frame.pos).is_equal_to(U16Vec2::new(10, 20));
-    assert_that(&frame.size).is_equal_to(U16Vec2::new(32, 64));
-}
-
-#[test]
-fn test_atlas_mapper_multiple_frames() {
-    let mut frames = HashMap::new();
-    frames.insert(
-        "tile1".to_string(),
-        MapperFrame {
-            pos: U16Vec2::new(0, 0),
-            size: U16Vec2::new(32, 32),
-        },
-    );
-    frames.insert(
-        "tile2".to_string(),
-        MapperFrame {
-            pos: U16Vec2::new(32, 0),
-            size: U16Vec2::new(64, 64),
-        },
-    );
-
-    let mapper = AtlasMapper { frames };
-
-    assert_that(&mapper.frames.len()).is_equal_to(2);
-    assert_that(&mapper.frames.contains_key("tile1")).is_true();
-    assert_that(&mapper.frames.contains_key("tile2")).is_true();
-    assert_that(&mapper.frames.contains_key("tile3")).is_false();
-    assert_that(&mapper.frames.contains_key("nonexistent")).is_false();
-}
-
-#[test]
-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_that(&tile.pos).is_equal_to(pos);
-    assert_that(&tile.size).is_equal_to(size);
-    assert_that(&tile.color).is_equal_to(None);
-
-    let tile_with_color = tile.with_color(color);
-    assert_that(&tile_with_color.color).is_equal_to(Some(color));
-}

tests/sprites.rs

@@ -0,0 +1,73 @@
+//! Tests for the sprite path generation.
+use pacman::{
+    game::ATLAS_FRAMES,
+    map::direction::Direction,
+    systems::Ghost,
+    texture::sprites::{FrightenedColor, GameSprite, GhostSprite, MazeSprite, PacmanSprite},
+};
+
+#[test]
+fn test_all_sprite_paths_exist() {
+    let mut sprites_to_test = Vec::new();
+
+    // Pac-Man sprites
+    for &dir in &[Direction::Up, Direction::Down, Direction::Left, Direction::Right] {
+        for frame in 0..2 {
+            sprites_to_test.push(GameSprite::Pacman(PacmanSprite::Moving(dir, frame)));
+        }
+    }
+    sprites_to_test.push(GameSprite::Pacman(PacmanSprite::Full));
+    for frame in 0..=10 {
+        sprites_to_test.push(GameSprite::Pacman(PacmanSprite::Dying(frame)));
+    }
+
+    // Ghost sprites
+    for &ghost in &[Ghost::Blinky, Ghost::Pinky, Ghost::Inky, Ghost::Clyde] {
+        for &dir in &[Direction::Up, Direction::Down, Direction::Left, Direction::Right] {
+            for frame in 0..2 {
+                sprites_to_test.push(GameSprite::Ghost(GhostSprite::Normal(ghost, dir, frame)));
+            }
+            sprites_to_test.push(GameSprite::Ghost(GhostSprite::Eyes(dir)));
+        }
+    }
+    for &color in &[FrightenedColor::Blue, FrightenedColor::White] {
+        for frame in 0..2 {
+            sprites_to_test.push(GameSprite::Ghost(GhostSprite::Frightened(color, frame)));
+        }
+    }
+
+    // Maze sprites
+    for i in 0..=34 {
+        sprites_to_test.push(GameSprite::Maze(MazeSprite::Tile(i)));
+    }
+    sprites_to_test.push(GameSprite::Maze(MazeSprite::Pellet));
+    sprites_to_test.push(GameSprite::Maze(MazeSprite::Energizer));
+
+    for sprite in sprites_to_test {
+        let path = sprite.to_path();
+        assert!(
+            ATLAS_FRAMES.contains_key(&path),
+            "Sprite path '{}' does not exist in the atlas.",
+            path
+        );
+    }
+}
+
+#[test]
+fn test_invalid_sprite_paths_do_not_exist() {
+    let invalid_sprites = vec![
+        // An invalid Pac-Man dying frame
+        GameSprite::Pacman(PacmanSprite::Dying(99)),
+        // An invalid maze tile
+        GameSprite::Maze(MazeSprite::Tile(99)),
+    ];
+
+    for sprite in invalid_sprites {
+        let path = sprite.to_path();
+        assert!(
+            !ATLAS_FRAMES.contains_key(&path),
+            "Invalid sprite path '{}' was found in the atlas, but it should not exist.",
+            path
+        );
+    }
+}

tests/text.rs

@@ -81,44 +81,20 @@ fn test_text_scale() -> Result<(), String> {
     let string = "ABCDEFG !-/\"";
     let base_width = (string.len() * 8) as u32;
 
-    let mut text_texture = TextTexture::new(0.5);
-
-    assert_that(&text_texture.scale()).is_equal_to(0.5);
+    let text_texture = TextTexture::new(0.5);
     assert_that(&text_texture.text_height()).is_equal_to(4);
     assert_that(&text_texture.text_width("")).is_equal_to(0);
     assert_that(&text_texture.text_width(string)).is_equal_to(base_width / 2);
 
-    text_texture.set_scale(2.0);
-    assert_that(&text_texture.scale()).is_equal_to(2.0);
+    let text_texture = TextTexture::new(2.0);
     assert_that(&text_texture.text_height()).is_equal_to(16);
     assert_that(&text_texture.text_width(string)).is_equal_to(base_width * 2);
     assert_that(&text_texture.text_width("")).is_equal_to(0);
 
-    text_texture.set_scale(1.0);
-    assert_that(&text_texture.scale()).is_equal_to(1.0);
+    let text_texture = TextTexture::new(1.0);
     assert_that(&text_texture.text_height()).is_equal_to(8);
     assert_that(&text_texture.text_width(string)).is_equal_to(base_width);
     assert_that(&text_texture.text_width("")).is_equal_to(0);
 
     Ok(())
 }
-
-#[test]
-fn test_text_color() -> Result<(), String> {
-    let mut text_texture = TextTexture::new(1.0);
-
-    // Test default color (should be None initially)
-    assert_that(&text_texture.color()).is_equal_to(None);
-
-    // Test setting color
-    let test_color = sdl2::pixels::Color::YELLOW;
-    text_texture.set_color(test_color);
-    assert_that(&text_texture.color()).is_equal_to(Some(test_color));
-
-    // Test changing color
-    let new_color = sdl2::pixels::Color::RED;
-    text_texture.set_color(new_color);
-    assert_that(&text_texture.color()).is_equal_to(Some(new_color));
-
-    Ok(())
-}

tests/ttf.rs

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