fix: use bun and web.build.ts in build workflow, use minify & cwd args for tailwindcss cli

.github/workflows/build.yaml

@@ -1,4 +1,4 @@
-name: Build
+name: Builds
 
 on: ["push", "pull_request"]
 
@@ -104,27 +104,48 @@ jobs:
       - name: Rust Cache
         uses: Swatinem/rust-cache@v2
 
-      - name: Install pnpm
-        uses: pnpm/action-setup@v3
+      - name: Setup Bun
+        uses: oven-sh/setup-bun@v2
         with:
-          version: 8
-          run_install: true
+          bun-version: latest
 
       - name: Build with Emscripten
+        shell: bash
         run: |
-          cargo build --target=wasm32-unknown-emscripten --release
+          # Retry mechanism for Emscripten build - only retry on specific hash errors
+          MAX_RETRIES=3
+          RETRY_DELAY=30
 
-      - name: Assemble
-        run: |
-          echo "Generating CSS"
-          pnpx postcss-cli ./assets/site/styles.scss -o ./assets/site/build.css
+          for attempt in $(seq 1 $MAX_RETRIES); do
+            echo "Build attempt $attempt of $MAX_RETRIES"
 
-          echo "Copying WASM files"
+            # Capture output and check for specific error while preserving real-time output
+            if bun run web.build.ts 2>&1 | tee /tmp/build_output.log; then
+              echo "Build successful on attempt $attempt"
+              break
+            else
+              echo "Build failed on attempt $attempt"
 
-          mkdir -p dist
-          cp assets/site/{build.css,favicon.ico,index.html} dist
-          output_folder="target/wasm32-unknown-emscripten/release"
-          cp $output_folder/pacman.{wasm,js} $output_folder/deps/pacman.data dist
+              # Check if the failure was due to the specific hash error
+              if grep -q "emcc: error: Unexpected hash:" /tmp/build_output.log; then
+                echo "::warning::Detected 'emcc: error: Unexpected hash:' error - will retry (attempt $attempt of $MAX_RETRIES)"
+
+                if [ $attempt -eq $MAX_RETRIES ]; then
+                  echo "::error::All retry attempts failed. Exiting with error."
+                  exit 1
+                fi
+
+                echo "Waiting $RETRY_DELAY seconds before retry..."
+                sleep $RETRY_DELAY
+
+                # Exponential backoff: double the delay for next attempt
+                RETRY_DELAY=$((RETRY_DELAY * 2))
+              else
+                echo "Build failed but not due to hash error - not retrying"
+                exit 1
+              fi
+            fi
+          done
 
       - name: Upload Artifact
         uses: actions/upload-pages-artifact@v3

.github/workflows/coverage.yaml

@@ -18,6 +18,7 @@ jobs:
         uses: dtolnay/rust-toolchain@master
         with:
           toolchain: ${{ env.RUST_TOOLCHAIN }}
+          components: llvm-tools-preview
 
       - name: Rust Cache
         uses: Swatinem/rust-cache@v2
@@ -40,20 +41,17 @@ jobs:
           cargo install cargo-vcpkg
           cargo vcpkg -v build
 
-      - name: Install cargo-tarpaulin
-        run: cargo install cargo-tarpaulin
+      - uses: taiki-e/install-action@cargo-llvm-cov
+      - uses: taiki-e/install-action@nextest
 
       # Note: We manually link zlib. This should be synchronized with the flags set for Linux in .cargo/config.toml.
       - name: Generate coverage report
         run: |
-          cargo tarpaulin \
-            --out Lcov \
-            --output-dir coverage \
-            --rustflags="-C link-arg=-lz"
+          cargo llvm-cov --no-fail-fast --lcov --output-path lcov.info nextest
 
       - name: Upload coverage to Coveralls
         uses: coverallsapp/github-action@v2
         with:
-          files: ./coverage/lcov.info
+          files: ./lcov.info
           format: lcov
           allow-empty: false

.github/workflows/test.yaml

@@ -1,4 +1,4 @@
-name: Test
+name: Tests
 
 on: ["push", "pull_request"]
 
@@ -42,8 +42,10 @@ jobs:
           cargo install cargo-vcpkg
           cargo vcpkg -v build
 
-      - name: Run tests
-        run: cargo test --workspace --verbose
+      - uses: taiki-e/install-action@nextest
+
+      - name: Run nextest
+        run: cargo nextest run --workspace
 
       - name: Run clippy
         run: cargo clippy -- -D warnings

.gitignore

@@ -1,7 +1,6 @@
-/target
-/dist
+target/
+dist/
+emsdk/
 .idea
-*.dll
 rust-sdl2-emscripten/
 assets/site/build.css
-emsdk/

README.md

@@ -1,9 +1,33 @@
 # Pac-Man
 
-If the title doesn't clue you in, I'm remaking Pac-Man with SDL and Rust.
+[![Tests Status][badge-test]][test] [![Build Status][badge-build]][build] [![Code Coverage][badge-coverage]][coverage] [![Online Demo][badge-online-demo]][demo] [![Last Commit][badge-last-commit]][commits]
 
-The project is _extremely_ early in development, but check back in a week, and maybe I'll have something cool to look
-at.
+[badge-test]: https://github.com/Xevion/Pac-Man/actions/workflows/test.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
+[build]: https://github.com/Xevion/Pac-Man/actions/workflows/build.yaml
+[test]: https://github.com/Xevion/Pac-Man/actions/workflows/test.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
+
+## Description
+
+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
+- [ ] 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
+- [ ] Progressive difficulty with faster ghosts and shorter power pellet duration
+- [x] Authentic sound effects and sprites
+
+Built with SDL2 for cross-platform graphics and audio, this implementation can run on Windows, Linux, macOS, and in web browsers via WebAssembly.
 
 ## Feature Targets
 
@@ -12,68 +36,29 @@ at.
 - Online demo, playable in a browser.
 - Automatic build system, with releases for Windows, Linux, and Mac & Web-Assembly.
 - Debug tooling
-    - Game state visualization
-    - Game speed controls + pausing
-    - Log tracing
-    - Performance details
+  - Game state visualization
+  - Game speed controls + pausing
+  - Log tracing
+  - Performance details
 
 ## Experimental Ideas
 
 - Perfected Ghost Algorithms
 - More than 4 ghosts
 - Custom Level Generation
-    - Multi-map tunnelling
+  - Multi-map tunnelling
 - Online Scoreboard
-    - WebAssembly build contains a special API key for communicating with server.
-    - To prevent abuse, the server will only accept scores from the WebAssembly build.
+  - WebAssembly build contains a special API key for communicating with server.
+  - To prevent abuse, the server will only accept scores from the WebAssembly build.
 
-## Installation
+## Build Notes
 
-Besides SDL2, the following extensions are required: Image, Mixer, and TTF.
-
-### Ubuntu
-
-On Ubuntu, you can install the required packages with the following command:
-
-```
-sudo apt install libsdl2-dev libsdl2-image-dev libsdl2-mixer-dev libsdl2-ttf-dev
-```
-
-### Windows
-
-On Windows, installation requires either building from source (not covered), or downloading the pre-built binaries.
-
-The latest releases can be found here:
-
-- [SDL2](https://github.com/libsdl-org/SDL/releases/latest/)
-- [SDL2_image](https://github.com/libsdl-org/SDL_image/releases/latest/)
-- [SDL2_mixer](https://github.com/libsdl-org/SDL_mixer/releases/latest/)
-- [SDL2_ttf](https://github.com/libsdl-org/SDL_ttf/releases/latest/)
-
-Download each for your architecture, and locate the appropriately named DLL within. Move said DLL to root of this project.
-
-In total, you should have the following DLLs in the root of the project:
-
-- SDL2.dll
-- SDL2_mixer.dll
-- SDL2_ttf.dll
-- SDL2_image.dll
-- libpngX-X.dll
-    - Not sure on what specific version is to be used, or if naming matters. `libpng16-16.dll` is what I had used.
-- zlib1.dll
-
-## Building
-
-To build the project, run the following command:
-
-```
-cargo build
-```
-
-During development, you can easily run the project with:
-
-```
-cargo run
-cargo run -q # Quiet mode, no logging
-cargo run --release # Release mode, optimized
-```
+- 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.
+  - You can then activate the Emscripten SDK with `source ./emsdk/emsdk_env.sh` or `./emsdk/emsdk_env.ps1` or `./emsdk/emsdk_env.bat` depending on your OS/terminal.
+  - While using the `web.build.ts` is not technically required, it simplifies the build process and is very helpful.
+    - It is intended to be run with `bun`, which you can acquire at [bun.sh](https://bun.sh/)
+  - Tip: You can launch a fileserver with `python` or `caddy` to serve the files in the `dist` folder.
+    - `python3 -m http.server 8080 -d dist`
+    - `caddy file-server --root dist` (install with `[sudo apt|brew|choco] install caddy` or [a dozen other ways](https://caddyserver.com/docs/install))

assets/site/build.css

@@ -1,23 +0,0 @@
-@tailwind base;
-@tailwind components;
-@tailwind utilities;
-
-@font-face {
-    font-family: "Liberation Mono";
-    src:
-        url("LiberationMono.woff2") format("woff2"),
-        url("LiberationMono.woff") format("woff");
-    font-weight: normal;
-    font-style: normal;
-    font-display: swap;
-}
-
-canvas {
-    @apply w-full h-[65vh] min-h-[200px] block mx-auto bg-black;
-}
-
-.code {
-    @apply px-1 rounded font-mono bg-zinc-900 border border-zinc-700 lowercase;
-}
-
-/*# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0eWxlcy5zY3NzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBIiwiZmlsZSI6ImJ1aWxkLmNzcyIsInNvdXJjZXNDb250ZW50IjpbIkB0YWlsd2luZCBiYXNlO1xuQHRhaWx3aW5kIGNvbXBvbmVudHM7XG5AdGFpbHdpbmQgdXRpbGl0aWVzO1xuXG5AZm9udC1mYWNlIHtcbiAgICBmb250LWZhbWlseTogXCJMaWJlcmF0aW9uIE1vbm9cIjtcbiAgICBzcmM6XG4gICAgICAgIHVybChcIkxpYmVyYXRpb25Nb25vLndvZmYyXCIpIGZvcm1hdChcIndvZmYyXCIpLFxuICAgICAgICB1cmwoXCJMaWJlcmF0aW9uTW9uby53b2ZmXCIpIGZvcm1hdChcIndvZmZcIik7XG4gICAgZm9udC13ZWlnaHQ6IG5vcm1hbDtcbiAgICBmb250LXN0eWxlOiBub3JtYWw7XG4gICAgZm9udC1kaXNwbGF5OiBzd2FwO1xufVxuXG5jYW52YXMge1xuICAgIEBhcHBseSB3LWZ1bGwgaC1bNjV2aF0gbWluLWgtWzIwMHB4XSBibG9jayBteC1hdXRvIGJnLWJsYWNrO1xufVxuXG4uY29kZSB7XG4gICAgQGFwcGx5IHB4LTEgcm91bmRlZCBmb250LW1vbm8gYmctemluYy05MDAgYm9yZGVyIGJvcmRlci16aW5jLTcwMCBsb3dlcmNhc2U7XG59XG4iXX0= */

assets/site/index.html

@@ -2,12 +2,25 @@
 <html>
   <head>
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>Pac-Man Arcade</title>
+    <title>Pac-Man in Rust</title>
     <link rel="stylesheet" href="build.css" />
     <style>
+      /* Minimal fallback to prevent white flash and canvas pop-in before CSS loads */
+      html,
+      body {
+        background: #000;
+        color: #facc15;
+        margin: 0;
+        text-align: center;
+      }
+      #canvas {
+        display: block;
+        margin: 1.5rem auto;
+        background: #000;
+      }
     </style>
   </head>
-  <body class="bg-black text-yellow-400 text-center">
+  <body class="bg-black text-yellow-400 text-center min-h-screen">
     <a
       href="https://github.com/Xevion/Pac-Man"
       class="absolute top-0 right-0"
@@ -17,7 +30,7 @@
         width="80"
         height="80"
         viewBox="0 0 250 250"
-        class="fill-yellow-400 text-black"
+        class="fill-yellow-400 text-white"
         aria-hidden="true"
       >
         <path d="M0,0 L115,115 L130,115 L142,142 L250,250 L250,0 Z"></path>
@@ -31,33 +44,54 @@
         ></path>
       </svg>
     </a>
-    <h1 class="text-4xl mt-10 scaled-text">Pac-Man Arcade</h1>
-    <p class="text-lg mt-5 scaled-text">
-      Welcome to the Pac-Man Arcade! Use the controls below to play.
-    </p>
-    <canvas
-      id="canvas"
-      class="block mx-auto mt-5"
-      width="800"
-      height="600"
-    ></canvas>
-    <div class="mt-10">
-      <span
-        class="inline-block mx-2 px-4 py-2 bg-yellow-400 text-black rounded scaled-text"
-        >&larr; &uarr; &rarr; &darr; Move</span
-      >
-      <span
-        class="inline-block mx-2 px-4 py-2 bg-yellow-400 text-black rounded scaled-text"
-        >Space Change Sprite</span
-      >
-      <span
-        class="inline-block mx-2 px-4 py-2 bg-yellow-400 text-black rounded scaled-text"
-        >Shift + &uarr;&darr; Change Volume</span
-      >
+
+    <div class="min-h-screen flex flex-col">
+      <header class="pt-10">
+        <h1 class="text-4xl arcade-title scaled-text">Pac-Man in Rust</h1>
+      </header>
+
+      <main class="flex-1 flex items-center justify-center px-4">
+        <div class="w-full max-w-5xl">
+          <canvas
+            id="canvas"
+            class="block mx-auto bg-black w-full max-w-[90vw] h-auto mt-5 rounded-xl shadow-[inset_0_0_0_2px_rgba(255,255,255,0.12),0_10px_30px_rgba(0,0,0,0.8)]"
+          ></canvas>
+
+          <div
+            class="mt-8 flex flex-wrap gap-3 justify-center items-center text-sm"
+          >
+            <span class="code">&larr; &uarr; &rarr; &darr;</span>
+            <span class="opacity-70">Move</span>
+
+            <span class="mx-2 opacity-30">|</span>
+
+            <span class="code">Space</span>
+            <span class="opacity-70">Toggle Debug</span>
+
+            <span class="mx-2 opacity-30">|</span>
+
+            <span class="code">P</span>
+            <span class="opacity-70">Pause / Unpause</span>
+
+            <span class="mx-2 opacity-30">|</span>
+
+            <span class="code">M</span>
+            <span class="opacity-70">Mute / Unmute</span>
+          </div>
+        </div>
+      </main>
     </div>
     <script type="text/javascript">
+      const canvas = document.getElementById("canvas");
       var Module = {
-        canvas: document.getElementById("canvas"),
+        canvas: canvas,
+        preRun: [
+          () => {
+            [...canvas.classList]
+              .filter((className) => className.includes("shadow-"))
+              .forEach((className) => canvas.classList.remove(className));
+          },
+        ],
       };
     </script>
     <script type="text/javascript" src="pacman.js"></script>

assets/site/styles.css

@@ -0,0 +1,28 @@
+@import "tailwindcss";
+
+@font-face {
+  font-family: "TerminalVector";
+  src: url("TerminalVector.ttf");
+  font-weight: normal;
+  font-style: normal;
+  font-display: swap;
+}
+
+/* Key badge styling */
+.code {
+  @apply px-3 py-1 rounded-md font-mono text-[0.9em] lowercase inline-block align-middle;
+  background: rgba(250, 204, 21, 0.08); /* yellow-400 at low opacity */
+  border: 1px solid rgba(250, 204, 21, 0.25);
+  color: #fde68a; /* lighter yellow for readability */
+  font-family: "TerminalVector", ui-monospace, Consolas, "Courier New",
+    monospace;
+}
+
+/* Title styling */
+.arcade-title {
+  font-family: "TerminalVector", ui-monospace, Consolas, "Courier New",
+    monospace;
+  letter-spacing: 0.08em;
+  text-shadow: 0 0 18px rgba(250, 204, 21, 0.15),
+    0 0 2px rgba(255, 255, 255, 0.25);
+}

assets/site/styles.scss

@@ -1,21 +0,0 @@
-@tailwind base;
-@tailwind components;
-@tailwind utilities;
-
-@font-face {
-    font-family: "Liberation Mono";
-    src:
-        url("LiberationMono.woff2") format("woff2"),
-        url("LiberationMono.woff") format("woff");
-    font-weight: normal;
-    font-style: normal;
-    font-display: swap;
-}
-
-canvas {
-    @apply w-full h-[65vh] min-h-[200px] block mx-auto bg-black;
-}
-
-.code {
-    @apply px-1 rounded font-mono bg-zinc-900 border border-zinc-700 lowercase;
-}

build.sh

@@ -1,74 +0,0 @@
-#!/bin/bash
-set -eu
-
-release='false'
-serve='false'
-skip_emsdk='false'
-clean='false'
-
-print_usage() {
-    printf "Usage: -erdsc\n"
-    printf "  -e: Skip EMSDK setup (GitHub workflow only)\n"
-    printf "  -r: Build in release mode\n"
-    printf "  -d: Build in debug mode\n"
-    printf "  -s: Serve the WASM files once built\n"
-    printf "  -c: Clean the target/dist directory\n"
-}
-
-while getopts 'erdsc' flag; do
-    case "${flag}" in
-    e) skip_emsdk='true' ;;
-    r) release='true' ;;
-    d) release='false' ;; # doesn't actually do anything, but last flag wins
-    s) serve='true' ;;
-    c) clean='true' ;;
-    *)
-        print_usage
-        exit 1
-        ;;
-    esac
-done
-
-if [ "$clean" = 'true' ]; then
-    echo "Cleaning target directory"
-    cargo clean
-    rm -rf ./dist/
-fi
-
-if [ "$skip_emsdk" = 'false' ]; then
-    echo "Activating Emscripten"
-    # SDL2-TTF requires 3.1.43, fails to build on latest
-    ../emsdk/emsdk activate 3.1.43
-    source ../emsdk/emsdk_env.sh
-fi
-
-echo "Building WASM with Emscripten"
-build_type='debug'
-if [ "$release" = 'true' ]; then
-    cargo build --target=wasm32-unknown-emscripten --release
-    build_type='release'
-else
-    cargo build --target=wasm32-unknown-emscripten
-fi
-
-echo "Generating CSS"
-pnpx postcss-cli ./assets/site/styles.scss -o ./assets/site/build.css
-
-echo "Copying WASM files"
-mkdir -p dist
-output_folder="target/wasm32-unknown-emscripten/$build_type"
-
-cp assets/site/{build.css,favicon.ico,index.html} dist
-cp $output_folder/pacman.{wasm,js} dist
-if [ -f $output_folder/deps/pacman.data ]; then
-    cp $output_folder/deps/pacman.data dist
-fi
-
-if [ -f $output_folder/pacman.wasm.map ]; then
-    cp $output_folder/pacman.wasm.map dist
-fi
-
-if [ "$serve" = 'true' ]; then
-    echo "Serving WASM with Emscripten"
-    python3 -m http.server -d ./dist/ 8080
-fi

build.ts

@@ -1,201 +0,0 @@
-import { $ } from "bun";
-
-// This is a bun script, run with `bun run build.ts`
-
-import * as path from "path";
-import * as fs from "fs/promises";
-
-async function clean() {
-  console.log("Cleaning...");
-  await $`cargo clean`;
-  await $`rm -rf ./dist/`;
-  console.log("Cleaned...");
-}
-
-async function setupEmscripten() {
-  const emsdkDir = "./emsdk";
-  const emsdkExists = await fs
-    .access(emsdkDir)
-    .then(() => true)
-    .catch(() => false);
-
-  if (!emsdkExists) {
-    console.log("Cloning Emscripten SDK...");
-    await $`git clone https://github.com/emscripten-core/emsdk.git`;
-  } else {
-    console.log("Emscripten SDK already exists, skipping clone.");
-  }
-
-  const emscriptenToolchainPath = path.join(emsdkDir, "upstream", "emscripten");
-  const toolchainInstalled = await fs
-    .access(emscriptenToolchainPath)
-    .then(() => true)
-    .catch(() => false);
-
-  if (!toolchainInstalled) {
-    console.log("Installing Emscripten toolchain...");
-    await $`./emsdk/emsdk install 3.1.43`;
-  } else {
-    console.log(
-      "Emscripten toolchain 3.1.43 already installed, skipping install."
-    );
-  }
-
-  console.log("Activating Emscripten...");
-  await $`./emsdk/emsdk activate 3.1.43`;
-  console.log("Emscripten activated.");
-
-  // Set EMSDK environment variable for subsequent commands
-  process.env.EMSDK = path.resolve(emsdkDir);
-
-  const emsdkPython = path.join(path.resolve(emsdkDir), "python");
-  const emsdkNode = path.join(path.resolve(emsdkDir), "node", "16.20.0_64bit"); // Adjust node version if needed
-  const emsdkBin = path.join(path.resolve(emsdkDir), "upstream", "emscripten");
-  process.env.PATH = `${emsdkPython}:${emsdkNode}:${emsdkBin}:${process.env.PATH}`;
-}
-
-async function buildWeb(release: boolean) {
-  console.log("Building WASM with Emscripten...");
-  const rustcFlags = [
-    "-C",
-    "link-arg=--preload-file",
-    "-C",
-    "link-arg=assets",
-  ].join(" ");
-
-  if (release) {
-    await $`env RUSTFLAGS=${rustcFlags} cargo build --target=wasm32-unknown-emscripten --release`;
-  } else {
-    await $`env RUSTFLAGS=${rustcFlags} cargo build --target=wasm32-unknown-emscripten`;
-  }
-
-  console.log("Generating CSS...");
-  await $`pnpx postcss-cli ./assets/site/styles.scss -o ./assets/site/build.css`;
-
-  console.log("Copying WASM files...");
-  const buildType = release ? "release" : "debug";
-  const outputFolder = `target/wasm32-unknown-emscripten/${buildType}`;
-  await $`mkdir -p dist`;
-  await $`cp assets/site/index.html dist`;
-  await $`cp assets/site/*.woff* dist`;
-  await $`cp assets/site/build.css dist`;
-  await $`cp assets/site/favicon.ico dist`;
-  await $`cp ${outputFolder}/pacman.wasm dist`;
-  await $`cp ${outputFolder}/pacman.js dist`;
-
-  // Check if .data file exists before copying
-  try {
-    await fs.access(`${outputFolder}/pacman.data`);
-    await $`cp ${outputFolder}/pacman.data dist`;
-  } catch (e) {
-    console.log("No pacman.data file found, skipping copy.");
-  }
-
-  // Check if .map file exists before copying
-  try {
-    await fs.access(`${outputFolder}/pacman.wasm.map`);
-    await $`cp ${outputFolder}/pacman.wasm.map dist`;
-  } catch (e) {
-    console.log("No pacman.wasm.map file found, skipping copy.");
-  }
-
-  console.log("WASM files copied.");
-}
-
-async function serve() {
-  console.log("Serving WASM with Emscripten...");
-  await $`python3 -m http.server -d ./dist/ 8080`;
-}
-
-async function main() {
-  const args = process.argv.slice(2);
-
-  let release = false;
-  let serveFiles = false;
-  let skipEmscriptenSetup = false;
-  let cleanProject = false;
-  let target = "web"; // Default target
-
-  for (const arg of args) {
-    switch (arg) {
-      case "-r":
-        release = true;
-        break;
-      case "-s":
-        serveFiles = true;
-        break;
-      case "-e":
-        skipEmscriptenSetup = true;
-        break;
-      case "-c":
-        cleanProject = true;
-        break;
-      case "--target=linux":
-        target = "linux";
-        break;
-      case "--target=windows":
-        target = "windows";
-        break;
-      case "--target=web":
-        target = "web";
-        break;
-      case "-h":
-      case "--help":
-        console.log(`
-Usage: ts-node build.ts [options]
-
-Options:
-  -r              Build in release mode
-  -s              Serve the WASM files once built (for web target)
-  -e              Skip EMSDK setup (GitHub workflow only)
-  -c              Clean the target/dist directory
-  --target=[web|linux|windows] Specify target platform (default: web)
-  -h, --help      Show this help message
-        `);
-        return;
-    }
-  }
-
-  if (cleanProject) {
-    await clean();
-  }
-
-  if (!skipEmscriptenSetup && target === "web") {
-    await setupEmscripten();
-  }
-
-  switch (target) {
-    case "web":
-      await buildWeb(release);
-      if (serveFiles) {
-        await serve();
-      }
-      break;
-    case "linux":
-      console.log("Building for Linux...");
-      if (release) {
-        await $`cargo build --release`;
-      } else {
-        await $`cargo build`;
-      }
-      console.log("Linux build complete.");
-      break;
-    case "windows":
-      console.log("Building for Windows...");
-      if (release) {
-        await $`cargo build --release --target=x86_64-pc-windows-msvc`; // Assuming MSVC toolchain
-      } else {
-        await $`cargo build --target=x86_64-pc-windows-msvc`;
-      }
-      console.log("Windows build complete.");
-      break;
-    default:
-      console.error("Invalid target specified.");
-      process.exit(1);
-  }
-}
-
-main().catch((err) => {
-  console.error(err);
-  process.exit(1);
-});

src/app.rs

@@ -33,7 +33,7 @@ pub struct App<'a> {
     last_tick: Instant,
 }
 
-impl<'a> App<'a> {
+impl App<'_> {
     pub fn new() -> Result<Self> {
         let sdl_context = sdl2::init().map_err(|e| anyhow!(e))?;
         let video_subsystem = sdl_context.video().map_err(|e| anyhow!(e))?;
@@ -92,6 +92,8 @@ impl<'a> App<'a> {
                         }
                         _ => {}
                     },
+                    // It doesn't really make sense to have this available in the browser
+                    #[cfg(not(target_os = "emscripten"))]
                     Event::Quit { .. }
                     | Event::KeyDown {
                         keycode: Some(Keycode::Escape) | Some(Keycode::Q),

src/audio.rs

@@ -10,13 +10,15 @@ const SOUND_ASSETS: [Asset; 4] = [Asset::Wav1, Asset::Wav2, Asset::Wav3, Asset::
 /// The audio system for the game.
 ///
 /// This struct is responsible for initializing the audio device, loading sounds,
-/// and playing them.
+/// 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: mixer::Sdl2MixerContext,
+    _mixer_context: Option<mixer::Sdl2MixerContext>,
     sounds: Vec<Chunk>,
     next_sound_index: usize,
     muted: bool,
+    disabled: bool,
 }
 
 impl Default for Audio {
@@ -27,13 +29,27 @@ impl Default for Audio {
 
 impl Audio {
     /// Creates a new `Audio` instance.
+    ///
+    /// 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
 
-        mixer::open_audio(frequency, format, 1, chunk_size).expect("Failed to open audio");
+        // Try to open audio, but don't panic if it fails
+        if let Err(e) = mixer::open_audio(frequency, format, 1, 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,
+                muted: false,
+                disabled: true,
+            };
+        }
+
         mixer::allocate_channels(channels);
 
         // set channel volume
@@ -41,31 +57,72 @@ impl Audio {
             mixer::Channel(i).set_volume(32);
         }
 
-        let mixer_context = mixer::init(InitFlag::OGG).expect("Failed to initialize SDL2_mixer");
+        // Try to initialize mixer, but don't panic if it fails
+        let mixer_context = match mixer::init(InitFlag::OGG) {
+            Ok(ctx) => ctx,
+            Err(e) => {
+                tracing::warn!("Failed to initialize SDL2_mixer: {}. Audio will be disabled.", e);
+                return Self {
+                    _mixer_context: None,
+                    sounds: Vec::new(),
+                    next_sound_index: 0,
+                    muted: false,
+                    disabled: true,
+                };
+            }
+        };
 
-        let sounds: Vec<Chunk> = SOUND_ASSETS
-            .iter()
-            .enumerate()
-            .map(|(i, asset)| {
-                let data = get_asset_bytes(*asset).expect("Failed to load sound asset");
-                let rwops = RWops::from_bytes(&data).unwrap_or_else(|_| panic!("Failed to create RWops for sound {}", i + 1));
-                rwops
-                    .load_wav()
-                    .unwrap_or_else(|_| panic!("Failed to load sound {} from asset API", i + 1))
-            })
-            .collect();
+        // 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) {
+                Ok(data) => match RWops::from_bytes(&data) {
+                    Ok(rwops) => match rwops.load_wav() {
+                        Ok(chunk) => sounds.push(chunk),
+                        Err(e) => {
+                            tracing::warn!("Failed to load sound {} from asset API: {}", i + 1, e);
+                        }
+                    },
+                    Err(e) => {
+                        tracing::warn!("Failed to create RWops for sound {}: {}", i + 1, e);
+                    }
+                },
+                Err(e) => {
+                    tracing::warn!("Failed to load sound asset {}: {}", i + 1, e);
+                }
+            }
+        }
+
+        // If no sounds loaded successfully, disable audio
+        if sounds.is_empty() {
+            tracing::warn!("No sounds loaded successfully. Audio will be disabled.");
+            return Self {
+                _mixer_context: Some(mixer_context),
+                sounds: Vec::new(),
+                next_sound_index: 0,
+                muted: false,
+                disabled: true,
+            };
+        }
 
         Audio {
-            _mixer_context: mixer_context,
+            _mixer_context: Some(mixer_context),
             sounds,
             next_sound_index: 0,
             muted: false,
+            disabled: false,
         }
     }
 
     /// Plays the "eat" sound effect.
+    ///
+    /// If audio is disabled or muted, this function does nothing.
     #[allow(dead_code)]
     pub fn eat(&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) {
                 Ok(channel) => {
@@ -80,12 +137,17 @@ impl Audio {
     }
 
     /// Instantly mute or unmute all channels.
+    ///
+    /// If audio is disabled, this function does nothing.
     pub fn set_mute(&mut self, mute: bool) {
-        let channels = 4;
-        let volume = if mute { 0 } else { 32 };
-        for i in 0..channels {
-            mixer::Channel(i).set_volume(volume);
+        if !self.disabled {
+            let channels = 4;
+            let volume = if mute { 0 } else { 32 };
+            for i in 0..channels {
+                mixer::Channel(i).set_volume(volume);
+            }
         }
+
         self.muted = mute;
     }
 
@@ -93,116 +155,10 @@ impl Audio {
     pub fn is_muted(&self) -> bool {
         self.muted
     }
-}
 
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::sync::Once;
-
-    static INIT: Once = Once::new();
-
-    fn init_sdl() -> Result<(), String> {
-        INIT.call_once(|| {
-            if let Err(e) = sdl2::init() {
-                eprintln!("Failed to initialize SDL2: {}", e);
-            }
-        });
-        Ok(())
-    }
-
-    #[test]
-    fn test_sound_assets_array() {
-        assert_eq!(SOUND_ASSETS.len(), 4);
-        assert_eq!(SOUND_ASSETS[0], Asset::Wav1);
-        assert_eq!(SOUND_ASSETS[1], Asset::Wav2);
-        assert_eq!(SOUND_ASSETS[2], Asset::Wav3);
-        assert_eq!(SOUND_ASSETS[3], Asset::Wav4);
-    }
-
-    #[test]
-    fn test_audio_asset_paths() {
-        // Test that all sound assets have valid paths
-        for asset in SOUND_ASSETS.iter() {
-            let path = asset.path();
-            assert!(!path.is_empty());
-            assert!(path.contains("sound/waka/"));
-            assert!(path.ends_with(".ogg"));
-        }
-    }
-
-    // Only run SDL2-dependent tests if SDL2 initialization succeeds
-    #[test]
-    fn test_audio_basic_functionality() {
-        if let Err(_) = init_sdl() {
-            eprintln!("Skipping SDL2-dependent tests due to initialization failure");
-            return;
-        }
-
-        // Test basic audio creation
-        let audio = Audio::new();
-        assert_eq!(audio.is_muted(), false);
-        assert_eq!(audio.next_sound_index, 0);
-        assert_eq!(audio.sounds.len(), 4);
-    }
-
-    #[test]
-    fn test_audio_mute_functionality() {
-        if let Err(_) = init_sdl() {
-            eprintln!("Skipping SDL2-dependent tests due to initialization failure");
-            return;
-        }
-
-        let mut audio = Audio::new();
-
-        // Test mute/unmute
-        assert_eq!(audio.is_muted(), false);
-        audio.set_mute(true);
-        assert_eq!(audio.is_muted(), true);
-        audio.set_mute(false);
-        assert_eq!(audio.is_muted(), false);
-    }
-
-    #[test]
-    fn test_audio_sound_rotation() {
-        if let Err(_) = init_sdl() {
-            eprintln!("Skipping SDL2-dependent tests due to initialization failure");
-            return;
-        }
-
-        let mut audio = Audio::new();
-        let initial_index = audio.next_sound_index;
-
-        // Test sound rotation
-        for i in 0..4 {
-            audio.eat();
-            assert_eq!(audio.next_sound_index, (initial_index + i + 1) % 4);
-        }
-
-        assert_eq!(audio.next_sound_index, initial_index);
-    }
-
-    #[test]
-    fn test_audio_sound_index_bounds() {
-        if let Err(_) = init_sdl() {
-            eprintln!("Skipping SDL2-dependent tests due to initialization failure");
-            return;
-        }
-
-        let audio = Audio::new();
-        assert!(audio.next_sound_index < audio.sounds.len());
-    }
-
-    #[test]
-    fn test_audio_default_impl() {
-        if let Err(_) = init_sdl() {
-            eprintln!("Skipping SDL2-dependent tests due to initialization failure");
-            return;
-        }
-
-        let audio = Audio::default();
-        assert_eq!(audio.is_muted(), false);
-        assert_eq!(audio.next_sound_index, 0);
-        assert_eq!(audio.sounds.len(), 4);
+    /// Returns `true` if the audio system is disabled.
+    #[allow(dead_code)]
+    pub fn is_disabled(&self) -> bool {
+        self.disabled
     }
 }

src/constants.rs

@@ -37,8 +37,6 @@ pub enum MapTile {
     Pellet,
     /// A power pellet.
     PowerPellet,
-    /// A starting position for an entity.
-    StartingPosition(u8),
     /// A tunnel tile.
     Tunnel,
 }
@@ -68,7 +66,7 @@ pub const RAW_BOARD: [&str; BOARD_CELL_SIZE.y as usize] = [
     "#............##............#",
     "#.####.#####.##.#####.####.#",
     "#.####.#####.##.#####.####.#",
-    "#o..##.......0 .......##..o#",
+    "#o..##.......X .......##..o#",
     "###.##.##.########.##.##.###",
     "###.##.##.########.##.##.###",
     "#......##....##....##......#",
@@ -77,197 +75,3 @@ pub const RAW_BOARD: [&str; BOARD_CELL_SIZE.y as usize] = [
     "#..........................#",
     "############################",
 ];
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_loop_time() {
-        // 60 FPS = 16.67ms per frame
-        let expected_nanos = (1_000_000_000.0 / 60.0) as u64;
-        assert_eq!(LOOP_TIME.as_nanos() as u64, expected_nanos);
-    }
-
-    #[test]
-    fn test_cell_size() {
-        assert_eq!(CELL_SIZE, 8);
-    }
-
-    #[test]
-    fn test_board_cell_size() {
-        assert_eq!(BOARD_CELL_SIZE.x, 28);
-        assert_eq!(BOARD_CELL_SIZE.y, 31);
-    }
-
-    #[test]
-    fn test_scale() {
-        assert_eq!(SCALE, 2.6);
-    }
-
-    #[test]
-    fn test_board_cell_offset() {
-        assert_eq!(BOARD_CELL_OFFSET.x, 0);
-        assert_eq!(BOARD_CELL_OFFSET.y, 3);
-    }
-
-    #[test]
-    fn test_board_pixel_offset() {
-        let expected = UVec2::new(0 * CELL_SIZE, 3 * CELL_SIZE);
-        assert_eq!(BOARD_PIXEL_OFFSET, expected);
-        assert_eq!(BOARD_PIXEL_OFFSET.x, 0);
-        assert_eq!(BOARD_PIXEL_OFFSET.y, 24); // 3 * 8
-    }
-
-    #[test]
-    fn test_board_pixel_size() {
-        let expected = UVec2::new(28 * CELL_SIZE, 31 * CELL_SIZE);
-        assert_eq!(BOARD_PIXEL_SIZE, expected);
-        assert_eq!(BOARD_PIXEL_SIZE.x, 224); // 28 * 8
-        assert_eq!(BOARD_PIXEL_SIZE.y, 248); // 31 * 8
-    }
-
-    #[test]
-    fn test_canvas_size() {
-        let expected = UVec2::new((28 + 0) * CELL_SIZE, (31 + 3) * CELL_SIZE);
-        assert_eq!(CANVAS_SIZE, expected);
-        assert_eq!(CANVAS_SIZE.x, 224); // (28 + 0) * 8
-        assert_eq!(CANVAS_SIZE.y, 272); // (31 + 3) * 8
-    }
-
-    #[test]
-    fn test_map_tile_variants() {
-        assert_ne!(MapTile::Empty, MapTile::Wall);
-        assert_ne!(MapTile::Pellet, MapTile::PowerPellet);
-        assert_ne!(MapTile::StartingPosition(0), MapTile::StartingPosition(1));
-        assert_ne!(MapTile::Tunnel, MapTile::Empty);
-    }
-
-    #[test]
-    fn test_map_tile_starting_position() {
-        let pos0 = MapTile::StartingPosition(0);
-        let pos1 = MapTile::StartingPosition(1);
-        let pos0_clone = MapTile::StartingPosition(0);
-
-        assert_eq!(pos0, pos0_clone);
-        assert_ne!(pos0, pos1);
-    }
-
-    #[test]
-    fn test_map_tile_debug() {
-        let tile = MapTile::Wall;
-        let debug_str = format!("{:?}", tile);
-        assert!(!debug_str.is_empty());
-    }
-
-    #[test]
-    fn test_map_tile_clone() {
-        let original = MapTile::StartingPosition(5);
-        let cloned = original;
-        assert_eq!(original, cloned);
-    }
-
-    #[test]
-    fn test_raw_board_dimensions() {
-        assert_eq!(RAW_BOARD.len(), BOARD_CELL_SIZE.y as usize);
-        assert_eq!(RAW_BOARD.len(), 31);
-
-        for row in RAW_BOARD.iter() {
-            assert_eq!(row.len(), BOARD_CELL_SIZE.x as usize);
-            assert_eq!(row.len(), 28);
-        }
-    }
-
-    #[test]
-    fn test_raw_board_boundaries() {
-        // First row should be all walls
-        assert!(RAW_BOARD[0].chars().all(|c| c == '#'));
-
-        // Last row should be all walls
-        let last_row = RAW_BOARD[RAW_BOARD.len() - 1];
-        assert!(last_row.chars().all(|c| c == '#'));
-
-        // First and last character of each row should be walls (except tunnel rows and rows with spaces)
-        for (i, row) in RAW_BOARD.iter().enumerate() {
-            if i != 14 && !row.starts_with(' ') {
-                // Skip tunnel row and rows that start with spaces
-                assert_eq!(row.chars().next().unwrap(), '#');
-                assert_eq!(row.chars().last().unwrap(), '#');
-            }
-        }
-    }
-
-    #[test]
-    fn test_raw_board_tunnel_row() {
-        // Row 14 should have tunnel characters 'T' at the edges
-        let tunnel_row = RAW_BOARD[14];
-        assert_eq!(tunnel_row.chars().next().unwrap(), 'T');
-        assert_eq!(tunnel_row.chars().last().unwrap(), 'T');
-    }
-
-    #[test]
-    fn test_raw_board_power_pellets() {
-        // Power pellets are represented by 'o'
-        let mut power_pellet_count = 0;
-        for row in RAW_BOARD.iter() {
-            power_pellet_count += row.chars().filter(|&c| c == 'o').count();
-        }
-        assert_eq!(power_pellet_count, 4); // Should have exactly 4 power pellets
-    }
-
-    #[test]
-    fn test_raw_board_starting_position() {
-        // Should have a starting position '0' for Pac-Man
-        let mut found_starting_position = false;
-        for row in RAW_BOARD.iter() {
-            if row.contains('0') {
-                found_starting_position = true;
-                break;
-            }
-        }
-        assert!(found_starting_position);
-    }
-
-    #[test]
-    fn test_raw_board_ghost_house() {
-        // The ghost house area should be present (the == characters)
-        let mut found_ghost_house = false;
-        for row in RAW_BOARD.iter() {
-            if row.contains("==") {
-                found_ghost_house = true;
-                break;
-            }
-        }
-        assert!(found_ghost_house);
-    }
-
-    #[test]
-    fn test_raw_board_symmetry() {
-        // The board should be roughly symmetrical
-        let mid_point = RAW_BOARD[0].len() / 2;
-
-        for row in RAW_BOARD.iter() {
-            let left_half = &row[..mid_point];
-            let right_half = &row[mid_point..];
-
-            // Check that the halves are symmetrical (accounting for the center column)
-            assert_eq!(left_half.len(), right_half.len());
-        }
-    }
-
-    #[test]
-    fn test_constants_consistency() {
-        // Verify that derived constants are calculated correctly
-        let calculated_pixel_offset = UVec2::new(BOARD_CELL_OFFSET.x * CELL_SIZE, BOARD_CELL_OFFSET.y * CELL_SIZE);
-        assert_eq!(BOARD_PIXEL_OFFSET, calculated_pixel_offset);
-
-        let calculated_pixel_size = UVec2::new(BOARD_CELL_SIZE.x * CELL_SIZE, BOARD_CELL_SIZE.y * CELL_SIZE);
-        assert_eq!(BOARD_PIXEL_SIZE, calculated_pixel_size);
-
-        let calculated_canvas_size = UVec2::new(
-            (BOARD_CELL_SIZE.x + BOARD_CELL_OFFSET.x) * CELL_SIZE,
-            (BOARD_CELL_SIZE.y + BOARD_CELL_OFFSET.y) * CELL_SIZE,
-        );
-        assert_eq!(CANVAS_SIZE, calculated_canvas_size);
-    }
-}

src/entity/direction.rs

@@ -35,67 +35,3 @@ impl From<Direction> for IVec2 {
 }
 
 pub const DIRECTIONS: [Direction; 4] = [Direction::Up, Direction::Down, Direction::Left, Direction::Right];
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_direction_opposite() {
-        assert_eq!(Direction::Up.opposite(), Direction::Down);
-        assert_eq!(Direction::Down.opposite(), Direction::Up);
-        assert_eq!(Direction::Left.opposite(), Direction::Right);
-        assert_eq!(Direction::Right.opposite(), Direction::Left);
-    }
-
-    #[test]
-    fn test_direction_as_ivec2() {
-        assert_eq!(Direction::Up.as_ivec2(), -IVec2::Y);
-        assert_eq!(Direction::Down.as_ivec2(), IVec2::Y);
-        assert_eq!(Direction::Left.as_ivec2(), -IVec2::X);
-        assert_eq!(Direction::Right.as_ivec2(), IVec2::X);
-    }
-
-    #[test]
-    fn test_direction_from_ivec2() {
-        assert_eq!(IVec2::from(Direction::Up), -IVec2::Y);
-        assert_eq!(IVec2::from(Direction::Down), IVec2::Y);
-        assert_eq!(IVec2::from(Direction::Left), -IVec2::X);
-        assert_eq!(IVec2::from(Direction::Right), IVec2::X);
-    }
-
-    #[test]
-    fn test_directions_constant() {
-        assert_eq!(DIRECTIONS.len(), 4);
-        assert!(DIRECTIONS.contains(&Direction::Up));
-        assert!(DIRECTIONS.contains(&Direction::Down));
-        assert!(DIRECTIONS.contains(&Direction::Left));
-        assert!(DIRECTIONS.contains(&Direction::Right));
-    }
-
-    #[test]
-    fn test_direction_equality() {
-        assert_eq!(Direction::Up, Direction::Up);
-        assert_ne!(Direction::Up, Direction::Down);
-        assert_ne!(Direction::Left, Direction::Right);
-    }
-
-    #[test]
-    fn test_direction_clone() {
-        let dir = Direction::Up;
-        let cloned = dir;
-        assert_eq!(dir, cloned);
-    }
-
-    #[test]
-    fn test_direction_hash() {
-        use std::collections::HashMap;
-        let mut map = HashMap::new();
-        map.insert(Direction::Up, "up");
-        map.insert(Direction::Down, "down");
-
-        assert_eq!(map.get(&Direction::Up), Some(&"up"));
-        assert_eq!(map.get(&Direction::Down), Some(&"down"));
-        assert_eq!(map.get(&Direction::Left), None);
-    }
-}

src/entity/graph.rs

@@ -5,6 +5,16 @@ use super::direction::Direction;
 /// A unique identifier for a node, represented by its index in the graph's storage.
 pub type NodeId = usize;
 
+/// Defines who can traverse a given edge.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub enum EdgePermissions {
+    /// Anyone can use this edge.
+    #[default]
+    All,
+    /// Only ghosts can use this edge.
+    GhostsOnly,
+}
+
 /// Represents a directed edge from one node to another with a given weight (e.g., distance).
 #[derive(Debug, Clone, Copy)]
 pub struct Edge {
@@ -14,6 +24,8 @@ pub struct Edge {
     pub distance: f32,
     /// The cardinal direction of this edge.
     pub direction: Direction,
+    /// Defines who is allowed to traverse this edge.
+    pub permissions: EdgePermissions,
 }
 
 /// Represents a node in the graph, defined by its position.
@@ -121,8 +133,8 @@ impl Graph {
             return Err("To node does not exist.");
         }
 
-        let edge_a = self.add_edge(from, to, replace, distance, direction);
-        let edge_b = self.add_edge(to, from, replace, distance, direction.opposite());
+        let edge_a = self.add_edge(from, to, replace, distance, direction, EdgePermissions::default());
+        let edge_b = self.add_edge(to, from, replace, distance, direction.opposite(), EdgePermissions::default());
 
         if edge_a.is_err() && edge_b.is_err() {
             return Err("Failed to connect nodes in both directions.");
@@ -150,6 +162,7 @@ impl Graph {
         replace: bool,
         distance: Option<f32>,
         direction: Direction,
+        permissions: EdgePermissions,
     ) -> Result<(), &'static str> {
         let edge = Edge {
             target: to,
@@ -168,6 +181,7 @@ impl Graph {
                 }
             },
             direction,
+            permissions,
         };
 
         if from >= self.adjacency_list.len() {
@@ -295,7 +309,10 @@ impl Traverser {
     /// Creates a new traverser starting at the given node ID.
     ///
     /// The traverser will immediately attempt to start moving in the initial direction.
-    pub fn new(graph: &Graph, start_node: NodeId, initial_direction: Direction) -> Self {
+    pub fn new<F>(graph: &Graph, start_node: NodeId, initial_direction: Direction, can_traverse: &F) -> Self
+    where
+        F: Fn(Edge) -> bool,
+    {
         let mut traverser = Traverser {
             position: Position::AtNode(start_node),
             direction: initial_direction,
@@ -303,7 +320,7 @@ impl Traverser {
         };
 
         // This will kickstart the traverser into motion
-        traverser.advance(graph, 0.0);
+        traverser.advance(graph, 0.0, can_traverse);
 
         traverser
     }
@@ -329,7 +346,10 @@ impl Traverser {
     /// - If it reaches a node, it attempts to transition to a new edge based on
     ///   the buffered direction or by continuing straight.
     /// - If no valid move is possible, it stops at the node.
-    pub fn advance(&mut self, graph: &Graph, distance: f32) {
+    pub fn advance<F>(&mut self, graph: &Graph, distance: f32, can_traverse: &F)
+    where
+        F: Fn(Edge) -> bool,
+    {
         // Decrement the remaining frames for the next direction
         if let Some((direction, remaining)) = self.next_direction {
             if remaining > 0 {
@@ -344,13 +364,15 @@ impl Traverser {
                 // We're not moving, but a buffered direction is available.
                 if let Some((next_direction, _)) = self.next_direction {
                     if let Some(edge) = graph.find_edge_in_direction(node_id, next_direction) {
-                        // Start moving in that direction
-                        self.position = Position::BetweenNodes {
-                            from: node_id,
-                            to: edge.target,
-                            traversed: distance.max(0.0),
-                        };
-                        self.direction = next_direction;
+                        if can_traverse(edge) {
+                            // Start moving in that direction
+                            self.position = Position::BetweenNodes {
+                                from: node_id,
+                                to: edge.target,
+                                traversed: distance.max(0.0),
+                            };
+                            self.direction = next_direction;
+                        }
                     }
 
                     self.next_direction = None; // Consume the buffered direction regardless of whether we started moving with it
@@ -382,26 +404,33 @@ impl Traverser {
                     // If we buffered a direction, try to find an edge in that direction
                     if let Some((next_dir, _)) = self.next_direction {
                         if let Some(edge) = graph.find_edge_in_direction(to, next_dir) {
-                            self.position = Position::BetweenNodes {
-                                from: to,
-                                to: edge.target,
-                                traversed: overflow,
-                            };
+                            if can_traverse(edge) {
+                                self.position = Position::BetweenNodes {
+                                    from: to,
+                                    to: edge.target,
+                                    traversed: overflow,
+                                };
 
-                            self.direction = next_dir; // Remember our new direction
-                            self.next_direction = None; // Consume the buffered direction
-                            moved = true;
+                                self.direction = next_dir; // Remember our new direction
+                                self.next_direction = None; // Consume the buffered direction
+                                moved = true;
+                            }
                         }
                     }
 
                     // If we didn't move, try to continue in the current direction
                     if !moved {
                         if let Some(edge) = graph.find_edge_in_direction(to, self.direction) {
-                            self.position = Position::BetweenNodes {
-                                from: to,
-                                to: edge.target,
-                                traversed: overflow,
-                            };
+                            if can_traverse(edge) {
+                                self.position = Position::BetweenNodes {
+                                    from: to,
+                                    to: edge.target,
+                                    traversed: overflow,
+                                };
+                            } else {
+                                self.position = Position::AtNode(to);
+                                self.next_direction = None;
+                            }
                         } else {
                             self.position = Position::AtNode(to);
                             self.next_direction = None;
@@ -412,361 +441,3 @@ impl Traverser {
         }
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::entity::direction::Direction;
-
-    fn create_test_graph() -> Graph {
-        let mut graph = Graph::new();
-        let node1 = graph.add_node(Node {
-            position: glam::Vec2::new(0.0, 0.0),
-        });
-        let node2 = graph.add_node(Node {
-            position: glam::Vec2::new(16.0, 0.0),
-        });
-        let node3 = graph.add_node(Node {
-            position: glam::Vec2::new(0.0, 16.0),
-        });
-
-        graph.connect(node1, node2, false, None, Direction::Right).unwrap();
-        graph.connect(node1, node3, false, None, Direction::Down).unwrap();
-
-        graph
-    }
-
-    #[test]
-    fn test_graph_new() {
-        let graph = Graph::new();
-        assert_eq!(graph.node_count(), 0);
-        assert!(graph.adjacency_list.is_empty());
-    }
-
-    #[test]
-    fn test_graph_add_node() {
-        let mut graph = Graph::new();
-        let node = Node {
-            position: glam::Vec2::new(10.0, 20.0),
-        };
-        let id = graph.add_node(node);
-
-        assert_eq!(id, 0);
-        assert_eq!(graph.node_count(), 1);
-        assert_eq!(graph.adjacency_list.len(), 1);
-
-        let retrieved_node = graph.get_node(id).unwrap();
-        assert_eq!(retrieved_node.position, glam::Vec2::new(10.0, 20.0));
-    }
-
-    #[test]
-    fn test_graph_node_count() {
-        let mut graph = Graph::new();
-        assert_eq!(graph.node_count(), 0);
-
-        graph.add_node(Node {
-            position: glam::Vec2::new(0.0, 0.0),
-        });
-        assert_eq!(graph.node_count(), 1);
-
-        graph.add_node(Node {
-            position: glam::Vec2::new(1.0, 1.0),
-        });
-        assert_eq!(graph.node_count(), 2);
-    }
-
-    #[test]
-    fn test_graph_get_node() {
-        let mut graph = Graph::new();
-        let node = Node {
-            position: glam::Vec2::new(5.0, 10.0),
-        };
-        let id = graph.add_node(node);
-
-        let retrieved = graph.get_node(id).unwrap();
-        assert_eq!(retrieved.position, glam::Vec2::new(5.0, 10.0));
-
-        assert!(graph.get_node(999).is_none());
-    }
-
-    #[test]
-    fn test_graph_connect() {
-        let mut graph = Graph::new();
-        let node1 = graph.add_node(Node {
-            position: glam::Vec2::new(0.0, 0.0),
-        });
-        let node2 = graph.add_node(Node {
-            position: glam::Vec2::new(16.0, 0.0),
-        });
-
-        let result = graph.connect(node1, node2, false, None, Direction::Right);
-        assert!(result.is_ok());
-
-        // Check that edges were added in both directions
-        let edge1 = graph.find_edge_in_direction(node1, Direction::Right);
-        let edge2 = graph.find_edge_in_direction(node2, Direction::Left);
-
-        assert!(edge1.is_some());
-        assert!(edge2.is_some());
-        assert_eq!(edge1.unwrap().target, node2);
-        assert_eq!(edge2.unwrap().target, node1);
-    }
-
-    #[test]
-    fn test_graph_connect_invalid_nodes() {
-        let mut graph = Graph::new();
-        let node1 = graph.add_node(Node {
-            position: glam::Vec2::new(0.0, 0.0),
-        });
-
-        // Try to connect to non-existent node
-        let result = graph.connect(node1, 999, false, None, Direction::Right);
-        assert!(result.is_err());
-
-        // Try to connect from non-existent node
-        let result = graph.connect(999, node1, false, None, Direction::Right);
-        assert!(result.is_err());
-    }
-
-    #[test]
-    fn test_graph_find_edge() {
-        let mut graph = Graph::new();
-        let node1 = graph.add_node(Node {
-            position: glam::Vec2::new(0.0, 0.0),
-        });
-        let node2 = graph.add_node(Node {
-            position: glam::Vec2::new(16.0, 0.0),
-        });
-
-        graph.connect(node1, node2, false, None, Direction::Right).unwrap();
-
-        let edge = graph.find_edge(node1, node2);
-        assert!(edge.is_some());
-        assert_eq!(edge.unwrap().target, node2);
-
-        // Test non-existent edge
-        assert!(graph.find_edge(node1, 999).is_none());
-    }
-
-    #[test]
-    fn test_graph_find_edge_in_direction() {
-        let mut graph = Graph::new();
-        let node1 = graph.add_node(Node {
-            position: glam::Vec2::new(0.0, 0.0),
-        });
-        let node2 = graph.add_node(Node {
-            position: glam::Vec2::new(16.0, 0.0),
-        });
-
-        graph.connect(node1, node2, false, None, Direction::Right).unwrap();
-
-        let edge = graph.find_edge_in_direction(node1, Direction::Right);
-        assert!(edge.is_some());
-        assert_eq!(edge.unwrap().target, node2);
-
-        // Test non-existent direction
-        assert!(graph.find_edge_in_direction(node1, Direction::Up).is_none());
-    }
-
-    #[test]
-    fn test_intersection_edges() {
-        let mut intersection = Intersection::default();
-        intersection.set(
-            Direction::Up,
-            Edge {
-                target: 1,
-                distance: 10.0,
-                direction: Direction::Up,
-            },
-        );
-        intersection.set(
-            Direction::Right,
-            Edge {
-                target: 2,
-                distance: 15.0,
-                direction: Direction::Right,
-            },
-        );
-
-        let edges: Vec<_> = intersection.edges().collect();
-        assert_eq!(edges.len(), 2);
-
-        let up_edge = edges.iter().find(|e| e.direction == Direction::Up).unwrap();
-        let right_edge = edges.iter().find(|e| e.direction == Direction::Right).unwrap();
-
-        assert_eq!(up_edge.target, 1);
-        assert_eq!(up_edge.distance, 10.0);
-        assert_eq!(right_edge.target, 2);
-        assert_eq!(right_edge.distance, 15.0);
-    }
-
-    #[test]
-    fn test_intersection_get() {
-        let mut intersection = Intersection::default();
-        let edge = Edge {
-            target: 1,
-            distance: 10.0,
-            direction: Direction::Up,
-        };
-        intersection.set(Direction::Up, edge);
-
-        let retrieved = intersection.get(Direction::Up);
-        assert!(retrieved.is_some());
-        assert_eq!(retrieved.unwrap().target, 1);
-
-        assert!(intersection.get(Direction::Down).is_none());
-    }
-
-    #[test]
-    fn test_intersection_set() {
-        let mut intersection = Intersection::default();
-        let edge = Edge {
-            target: 1,
-            distance: 10.0,
-            direction: Direction::Left,
-        };
-
-        intersection.set(Direction::Left, edge);
-        let retrieved = intersection.get(Direction::Left);
-        assert!(retrieved.is_some());
-        assert_eq!(retrieved.unwrap().target, 1);
-    }
-
-    #[test]
-    fn test_position_is_at_node() {
-        let pos = Position::AtNode(5);
-        assert!(pos.is_at_node());
-
-        let pos = Position::BetweenNodes {
-            from: 1,
-            to: 2,
-            traversed: 5.0,
-        };
-        assert!(!pos.is_at_node());
-    }
-
-    #[test]
-    fn test_position_from_node_id() {
-        let pos = Position::AtNode(5);
-        assert_eq!(pos.from_node_id(), 5);
-
-        let pos = Position::BetweenNodes {
-            from: 1,
-            to: 2,
-            traversed: 5.0,
-        };
-        assert_eq!(pos.from_node_id(), 1);
-    }
-
-    #[test]
-    fn test_position_to_node_id() {
-        let pos = Position::AtNode(5);
-        assert_eq!(pos.to_node_id(), None);
-
-        let pos = Position::BetweenNodes {
-            from: 1,
-            to: 2,
-            traversed: 5.0,
-        };
-        assert_eq!(pos.to_node_id(), Some(2));
-    }
-
-    #[test]
-    fn test_position_is_stopped() {
-        let pos = Position::AtNode(5);
-        assert!(pos.is_stopped());
-
-        let pos = Position::BetweenNodes {
-            from: 1,
-            to: 2,
-            traversed: 5.0,
-        };
-        assert!(!pos.is_stopped());
-    }
-
-    #[test]
-    fn test_traverser_new() {
-        let graph = create_test_graph();
-        let traverser = Traverser::new(&graph, 0, Direction::Left);
-
-        assert_eq!(traverser.direction, Direction::Left);
-        // The next_direction might be consumed immediately when the traverser starts moving
-        // So we just check that the direction is set correctly
-        assert_eq!(traverser.direction, Direction::Left);
-    }
-
-    #[test]
-    fn test_traverser_set_next_direction() {
-        let graph = create_test_graph();
-        let mut traverser = Traverser::new(&graph, 0, Direction::Left);
-
-        traverser.set_next_direction(Direction::Up);
-        assert!(traverser.next_direction.is_some());
-        assert_eq!(traverser.next_direction.unwrap().0, Direction::Up);
-
-        // Setting same direction should not change anything
-        traverser.set_next_direction(Direction::Up);
-        assert_eq!(traverser.next_direction.unwrap().0, Direction::Up);
-    }
-
-    #[test]
-    fn test_traverser_advance_at_node() {
-        let graph = create_test_graph();
-        let mut traverser = Traverser::new(&graph, 0, Direction::Right);
-
-        // Should start moving in the initial direction
-        traverser.advance(&graph, 5.0);
-
-        match traverser.position {
-            Position::BetweenNodes { from, to, traversed } => {
-                assert_eq!(from, 0);
-                assert_eq!(to, 1);
-                assert_eq!(traversed, 5.0);
-            }
-            _ => panic!("Expected to be between nodes"),
-        }
-    }
-
-    #[test]
-    fn test_traverser_advance_between_nodes() {
-        let graph = create_test_graph();
-        let mut traverser = Traverser::new(&graph, 0, Direction::Right);
-
-        // Move to between nodes
-        traverser.advance(&graph, 5.0);
-
-        // Advance further
-        traverser.advance(&graph, 3.0);
-
-        match traverser.position {
-            Position::BetweenNodes { from, to, traversed } => {
-                assert_eq!(from, 0);
-                assert_eq!(to, 1);
-                assert_eq!(traversed, 8.0);
-            }
-            _ => panic!("Expected to be between nodes"),
-        }
-    }
-
-    #[test]
-    fn test_edge_structure() {
-        let edge = Edge {
-            target: 5,
-            distance: 10.5,
-            direction: Direction::Up,
-        };
-
-        assert_eq!(edge.target, 5);
-        assert_eq!(edge.distance, 10.5);
-        assert_eq!(edge.direction, Direction::Up);
-    }
-
-    #[test]
-    fn test_node_structure() {
-        let node = Node {
-            position: glam::Vec2::new(10.0, 20.0),
-        };
-
-        assert_eq!(node.position, glam::Vec2::new(10.0, 20.0));
-    }
-}

src/entity/pacman.rs

@@ -2,7 +2,7 @@ use glam::{UVec2, Vec2};
 
 use crate::constants::BOARD_PIXEL_OFFSET;
 use crate::entity::direction::Direction;
-use crate::entity::graph::{Graph, NodeId, Position, Traverser};
+use crate::entity::graph::{Edge, EdgePermissions, Graph, NodeId, Position, Traverser};
 use crate::helpers::centered_with_size;
 use crate::texture::animated::AnimatedTexture;
 use crate::texture::directional::DirectionalAnimatedTexture;
@@ -11,6 +11,10 @@ use sdl2::keyboard::Keycode;
 use sdl2::render::{Canvas, RenderTarget};
 use std::collections::HashMap;
 
+fn can_pacman_traverse(edge: Edge) -> bool {
+    matches!(edge.permissions, EdgePermissions::All)
+}
+
 pub struct Pacman {
     pub traverser: Traverser,
     texture: DirectionalAnimatedTexture,
@@ -47,13 +51,13 @@ impl Pacman {
         }
 
         Self {
-            traverser: Traverser::new(graph, start_node, Direction::Left),
+            traverser: Traverser::new(graph, start_node, Direction::Left, &can_pacman_traverse),
             texture: DirectionalAnimatedTexture::new(textures, stopped_textures),
         }
     }
 
     pub fn tick(&mut self, dt: f32, graph: &Graph) {
-        self.traverser.advance(graph, dt * 60.0 * 1.125);
+        self.traverser.advance(graph, dt * 60.0 * 1.125, &can_pacman_traverse);
         self.texture.tick(dt);
     }
 
@@ -96,219 +100,3 @@ impl Pacman {
         }
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::entity::graph::{Graph, Node};
-    use crate::texture::sprite::{AtlasMapper, MapperFrame, SpriteAtlas};
-    use sdl2::keyboard::Keycode;
-    use std::collections::HashMap;
-
-    fn create_test_graph() -> Graph {
-        let mut graph = Graph::new();
-        let node1 = graph.add_node(Node {
-            position: glam::Vec2::new(0.0, 0.0),
-        });
-        let node2 = graph.add_node(Node {
-            position: glam::Vec2::new(16.0, 0.0),
-        });
-        let node3 = graph.add_node(Node {
-            position: glam::Vec2::new(0.0, 16.0),
-        });
-
-        graph.connect(node1, node2, false, None, Direction::Right).unwrap();
-        graph.connect(node1, node3, false, None, Direction::Down).unwrap();
-
-        graph
-    }
-
-    fn create_test_atlas() -> SpriteAtlas {
-        // Create a minimal test atlas with required tiles
-        let mut frames = HashMap::new();
-        frames.insert(
-            "pacman/up_a.png".to_string(),
-            MapperFrame {
-                x: 0,
-                y: 0,
-                width: 16,
-                height: 16,
-            },
-        );
-        frames.insert(
-            "pacman/up_b.png".to_string(),
-            MapperFrame {
-                x: 16,
-                y: 0,
-                width: 16,
-                height: 16,
-            },
-        );
-        frames.insert(
-            "pacman/down_a.png".to_string(),
-            MapperFrame {
-                x: 32,
-                y: 0,
-                width: 16,
-                height: 16,
-            },
-        );
-        frames.insert(
-            "pacman/down_b.png".to_string(),
-            MapperFrame {
-                x: 48,
-                y: 0,
-                width: 16,
-                height: 16,
-            },
-        );
-        frames.insert(
-            "pacman/left_a.png".to_string(),
-            MapperFrame {
-                x: 64,
-                y: 0,
-                width: 16,
-                height: 16,
-            },
-        );
-        frames.insert(
-            "pacman/left_b.png".to_string(),
-            MapperFrame {
-                x: 80,
-                y: 0,
-                width: 16,
-                height: 16,
-            },
-        );
-        frames.insert(
-            "pacman/right_a.png".to_string(),
-            MapperFrame {
-                x: 96,
-                y: 0,
-                width: 16,
-                height: 16,
-            },
-        );
-        frames.insert(
-            "pacman/right_b.png".to_string(),
-            MapperFrame {
-                x: 112,
-                y: 0,
-                width: 16,
-                height: 16,
-            },
-        );
-        frames.insert(
-            "pacman/full.png".to_string(),
-            MapperFrame {
-                x: 128,
-                y: 0,
-                width: 16,
-                height: 16,
-            },
-        );
-
-        let mapper = AtlasMapper { frames };
-        // Create a dummy texture (we won't actually render, just test the logic)
-        let dummy_texture = unsafe { std::mem::zeroed() };
-        SpriteAtlas::new(dummy_texture, mapper)
-    }
-
-    #[test]
-    fn test_pacman_new() {
-        let graph = create_test_graph();
-        let atlas = create_test_atlas();
-
-        let pacman = Pacman::new(&graph, 0, &atlas);
-
-        assert_eq!(pacman.traverser.direction, Direction::Left);
-        assert!(matches!(pacman.traverser.position, crate::entity::graph::Position::AtNode(0)));
-    }
-
-    #[test]
-    fn test_handle_key_valid_directions() {
-        let graph = create_test_graph();
-        let atlas = create_test_atlas();
-        let mut pacman = Pacman::new(&graph, 0, &atlas);
-
-        // Test that direction keys are handled correctly
-        // The traverser might consume next_direction immediately, so we check the actual direction
-        pacman.handle_key(Keycode::Up);
-        // Check that the direction was set (either in next_direction or current direction)
-        assert!(pacman.traverser.next_direction.is_some() || pacman.traverser.direction == Direction::Up);
-
-        pacman.handle_key(Keycode::Down);
-        assert!(pacman.traverser.next_direction.is_some() || pacman.traverser.direction == Direction::Down);
-
-        pacman.handle_key(Keycode::Left);
-        assert!(pacman.traverser.next_direction.is_some() || pacman.traverser.direction == Direction::Left);
-
-        pacman.handle_key(Keycode::Right);
-        assert!(pacman.traverser.next_direction.is_some() || pacman.traverser.direction == Direction::Right);
-    }
-
-    #[test]
-    fn test_handle_key_invalid_direction() {
-        let graph = create_test_graph();
-        let atlas = create_test_atlas();
-        let mut pacman = Pacman::new(&graph, 0, &atlas);
-
-        let original_direction = pacman.traverser.direction;
-        let original_next_direction = pacman.traverser.next_direction;
-
-        // Test invalid key
-        pacman.handle_key(Keycode::Space);
-
-        // Should not change direction
-        assert_eq!(pacman.traverser.direction, original_direction);
-        assert_eq!(pacman.traverser.next_direction, original_next_direction);
-    }
-
-    #[test]
-    fn test_get_pixel_pos_at_node() {
-        let graph = create_test_graph();
-        let atlas = create_test_atlas();
-        let pacman = Pacman::new(&graph, 0, &atlas);
-
-        let pos = pacman.get_pixel_pos(&graph);
-        assert_eq!(pos, glam::Vec2::new(0.0, 0.0));
-    }
-
-    #[test]
-    fn test_get_pixel_pos_between_nodes() {
-        let graph = create_test_graph();
-        let atlas = create_test_atlas();
-        let mut pacman = Pacman::new(&graph, 0, &atlas);
-
-        // Move pacman between nodes - need to advance with a larger distance to ensure movement
-        pacman.traverser.advance(&graph, 5.0); // Larger advance to ensure movement
-
-        let pos = pacman.get_pixel_pos(&graph);
-        // Should be between (0,0) and (16,0), but not exactly at (8,0) due to advance distance
-        assert!(pos.x >= 0.0 && pos.x <= 16.0);
-        assert_eq!(pos.y, 0.0);
-    }
-
-    #[test]
-    fn test_tick_updates_texture() {
-        let graph = create_test_graph();
-        let atlas = create_test_atlas();
-        let mut pacman = Pacman::new(&graph, 0, &atlas);
-
-        // Test that tick doesn't panic
-        pacman.tick(0.016, &graph); // 60 FPS frame time
-    }
-
-    #[test]
-    fn test_pacman_initial_direction() {
-        let graph = create_test_graph();
-        let atlas = create_test_atlas();
-        let pacman = Pacman::new(&graph, 0, &atlas);
-
-        // Pacman should start with the initial direction (Left)
-        assert_eq!(pacman.traverser.direction, Direction::Left);
-        // The next_direction might be consumed immediately when the traverser starts moving
-        // So we just check that the direction is set correctly
-        assert_eq!(pacman.traverser.direction, Direction::Left);
-    }
-}

src/game.rs

@@ -152,233 +152,3 @@ impl Game {
         Ok(())
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use sdl2::keyboard::Keycode;
-    use sdl2::pixels::Color;
-
-    fn create_test_game() -> Game {
-        // Create a minimal test game without SDL dependencies
-        // This is a simplified version for testing basic logic
-        let map = Map::new(RAW_BOARD);
-        let pacman_start_pos = map.find_starting_position(0).unwrap();
-        let pacman_start_node = *map
-            .grid_to_node
-            .get(&glam::IVec2::new(pacman_start_pos.x as i32, pacman_start_pos.y as i32))
-            .expect("Pac-Man starting position not found in graph");
-
-        // Create a dummy atlas for testing
-        let mut mapper = std::collections::HashMap::new();
-        mapper.insert(
-            "pacman/up_a.png".to_string(),
-            crate::texture::sprite::MapperFrame {
-                x: 0,
-                y: 0,
-                width: 16,
-                height: 16,
-            },
-        );
-        mapper.insert(
-            "pacman/up_b.png".to_string(),
-            crate::texture::sprite::MapperFrame {
-                x: 16,
-                y: 0,
-                width: 16,
-                height: 16,
-            },
-        );
-        mapper.insert(
-            "pacman/down_a.png".to_string(),
-            crate::texture::sprite::MapperFrame {
-                x: 32,
-                y: 0,
-                width: 16,
-                height: 16,
-            },
-        );
-        mapper.insert(
-            "pacman/down_b.png".to_string(),
-            crate::texture::sprite::MapperFrame {
-                x: 48,
-                y: 0,
-                width: 16,
-                height: 16,
-            },
-        );
-        mapper.insert(
-            "pacman/left_a.png".to_string(),
-            crate::texture::sprite::MapperFrame {
-                x: 64,
-                y: 0,
-                width: 16,
-                height: 16,
-            },
-        );
-        mapper.insert(
-            "pacman/left_b.png".to_string(),
-            crate::texture::sprite::MapperFrame {
-                x: 80,
-                y: 0,
-                width: 16,
-                height: 16,
-            },
-        );
-        mapper.insert(
-            "pacman/right_a.png".to_string(),
-            crate::texture::sprite::MapperFrame {
-                x: 96,
-                y: 0,
-                width: 16,
-                height: 16,
-            },
-        );
-        mapper.insert(
-            "pacman/right_b.png".to_string(),
-            crate::texture::sprite::MapperFrame {
-                x: 112,
-                y: 0,
-                width: 16,
-                height: 16,
-            },
-        );
-        mapper.insert(
-            "pacman/full.png".to_string(),
-            crate::texture::sprite::MapperFrame {
-                x: 128,
-                y: 0,
-                width: 16,
-                height: 16,
-            },
-        );
-        mapper.insert(
-            "maze/full.png".to_string(),
-            crate::texture::sprite::MapperFrame {
-                x: 0,
-                y: 0,
-                width: 224,
-                height: 248,
-            },
-        );
-
-        let atlas_mapper = crate::texture::sprite::AtlasMapper { frames: mapper };
-        let dummy_texture = unsafe { std::mem::zeroed() };
-        let atlas = crate::texture::sprite::SpriteAtlas::new(dummy_texture, atlas_mapper);
-
-        let mut map_texture = crate::texture::sprite::SpriteAtlas::get_tile(&atlas, "maze/full.png").unwrap();
-        map_texture.color = Some(Color::RGB(0x20, 0x20, 0xf9));
-
-        let text_texture = TextTexture::new(1.0);
-        let audio = Audio::new();
-        let pacman = Pacman::new(&map.graph, pacman_start_node, &atlas);
-
-        Game {
-            score: 0,
-            map,
-            pacman,
-            debug_mode: false,
-            map_texture,
-            text_texture,
-            audio,
-            atlas,
-        }
-    }
-
-    #[test]
-    fn test_game_keyboard_event_direction_keys() {
-        let mut game = create_test_game();
-
-        // Test that direction keys are handled
-        game.keyboard_event(Keycode::Up);
-        game.keyboard_event(Keycode::Down);
-        game.keyboard_event(Keycode::Left);
-        game.keyboard_event(Keycode::Right);
-
-        // Should not panic
-        assert!(true);
-    }
-
-    #[test]
-    fn test_game_keyboard_event_mute_toggle() {
-        let mut game = create_test_game();
-
-        let initial_mute_state = game.audio.is_muted();
-
-        // Toggle mute
-        game.keyboard_event(Keycode::M);
-
-        // Mute state should have changed
-        assert_eq!(game.audio.is_muted(), !initial_mute_state);
-
-        // Toggle again
-        game.keyboard_event(Keycode::M);
-
-        // Should be back to original state
-        assert_eq!(game.audio.is_muted(), initial_mute_state);
-    }
-
-    #[test]
-    fn test_game_tick() {
-        let mut game = create_test_game();
-
-        // Test that tick doesn't panic
-        game.tick(0.016); // 60 FPS frame time
-
-        assert!(true);
-    }
-
-    #[test]
-    fn test_game_initial_state() {
-        let game = create_test_game();
-
-        assert_eq!(game.score, 0);
-        assert!(!game.debug_mode);
-        assert!(game.map.graph.node_count() > 0);
-    }
-
-    #[test]
-    fn test_game_debug_mode_toggle() {
-        let mut game = create_test_game();
-
-        assert!(!game.debug_mode);
-
-        // Toggle debug mode (this would normally be done via Space key in the app)
-        game.debug_mode = !game.debug_mode;
-
-        assert!(game.debug_mode);
-    }
-
-    #[test]
-    fn test_game_score_increment() {
-        let mut game = create_test_game();
-
-        let initial_score = game.score;
-        game.score += 10;
-
-        assert_eq!(game.score, initial_score + 10);
-    }
-
-    #[test]
-    fn test_game_pacman_initialization() {
-        let game = create_test_game();
-
-        // Check that Pac-Man was initialized
-        assert_eq!(game.pacman.traverser.direction, crate::entity::direction::Direction::Left);
-        // The traverser might start moving immediately, so we just check the direction
-        assert_eq!(game.pacman.traverser.direction, crate::entity::direction::Direction::Left);
-    }
-
-    #[test]
-    fn test_game_map_initialization() {
-        let game = create_test_game();
-
-        // Check that map was initialized
-        assert!(game.map.graph.node_count() > 0);
-        assert!(!game.map.grid_to_node.is_empty());
-
-        // Check that Pac-Man's starting position exists
-        let pacman_pos = game.map.find_starting_position(0);
-        assert!(pacman_pos.is_some());
-    }
-}

src/helpers.rs

@@ -9,43 +9,3 @@ pub fn centered_with_size(pixel_pos: IVec2, size: UVec2) -> Rect {
         size.y,
     )
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_centered_with_size_basic() {
-        let rect = centered_with_size(IVec2::new(100, 100), UVec2::new(50, 30));
-        assert_eq!(rect.origin(), (75, 85));
-        assert_eq!(rect.size(), (50, 30));
-    }
-
-    #[test]
-    fn test_centered_with_size_odd_dimensions() {
-        let rect = centered_with_size(IVec2::new(50, 50), UVec2::new(51, 31));
-        assert_eq!(rect.origin(), (25, 35));
-        assert_eq!(rect.size(), (51, 31));
-    }
-
-    #[test]
-    fn test_centered_with_size_zero_position() {
-        let rect = centered_with_size(IVec2::new(0, 0), UVec2::new(100, 100));
-        assert_eq!(rect.origin(), (-50, -50));
-        assert_eq!(rect.size(), (100, 100));
-    }
-
-    #[test]
-    fn test_centered_with_size_negative_position() {
-        let rect = centered_with_size(IVec2::new(-100, -50), UVec2::new(80, 40));
-        assert_eq!(rect.origin(), (-140, -70));
-        assert_eq!(rect.size(), (80, 40));
-    }
-
-    #[test]
-    fn test_centered_with_size_large_dimensions() {
-        let rect = centered_with_size(IVec2::new(1000, 1000), UVec2::new(1000, 1000));
-        assert_eq!(rect.origin(), (500, 500));
-        assert_eq!(rect.size(), (1000, 1000));
-    }
-}

src/map/builder.rs

@@ -2,7 +2,7 @@
 
 use crate::constants::{MapTile, BOARD_CELL_SIZE, CELL_SIZE};
 use crate::entity::direction::{Direction, DIRECTIONS};
-use crate::entity::graph::{Graph, Node, NodeId};
+use crate::entity::graph::{EdgePermissions, Graph, Node, NodeId};
 use crate::map::parser::MapTileParser;
 use crate::map::render::MapRenderer;
 use crate::texture::sprite::{AtlasTile, SpriteAtlas};
@@ -11,18 +11,30 @@ use sdl2::render::{Canvas, RenderTarget};
 use std::collections::{HashMap, VecDeque};
 use tracing::debug;
 
-/// The game map, responsible for holding the tile-based layout and the navigation graph.
-///
-/// The map is represented as a 2D array of `MapTile`s. It also stores a navigation
-/// `Graph` that entities like Pac-Man and ghosts use for movement. The graph is
-/// generated from the walkable tiles of the map.
+/// The starting positions of the entities in the game.
+#[allow(dead_code)]
+pub struct NodePositions {
+    pub pacman: NodeId,
+    pub blinky: NodeId,
+    pub pinky: NodeId,
+    pub inky: NodeId,
+    pub clyde: NodeId,
+}
+
+/// The main map structure containing the game board and navigation graph.
 pub struct Map {
     /// The current state of the map.
+    #[allow(dead_code)]
     current: [[MapTile; BOARD_CELL_SIZE.y as usize]; BOARD_CELL_SIZE.x as usize],
     /// The node map for entity movement.
     pub graph: Graph,
     /// A mapping from grid positions to node IDs.
     pub grid_to_node: HashMap<IVec2, NodeId>,
+    /// A mapping of the starting positions of the entities.
+    #[allow(dead_code)]
+    pub start_positions: NodePositions,
+    /// Pac-Man's starting position.
+    pacman_start: Option<IVec2>,
 }
 
 impl Map {
@@ -41,6 +53,7 @@ impl Map {
         let map = parsed_map.tiles;
         let house_door = parsed_map.house_door;
         let tunnel_ends = parsed_map.tunnel_ends;
+        let pacman_start = parsed_map.pacman_start;
 
         let mut graph = Graph::new();
         let mut grid_to_node = HashMap::new();
@@ -48,25 +61,7 @@ impl Map {
         let cell_offset = Vec2::splat(CELL_SIZE as f32 / 2.0);
 
         // Find a starting point for the graph generation, preferably Pac-Man's position.
-        let start_pos = (0..BOARD_CELL_SIZE.y)
-            .flat_map(|y| (0..BOARD_CELL_SIZE.x).map(move |x| IVec2::new(x as i32, y as i32)))
-            .find(|&p| matches!(map[p.x as usize][p.y as usize], MapTile::StartingPosition(0)))
-            .unwrap_or_else(|| {
-                // Fallback to any valid walkable tile if Pac-Man's start is not found
-                (0..BOARD_CELL_SIZE.y)
-                    .flat_map(|y| (0..BOARD_CELL_SIZE.x).map(move |x| IVec2::new(x as i32, y as i32)))
-                    .find(|&p| {
-                        matches!(
-                            map[p.x as usize][p.y as usize],
-                            MapTile::Pellet
-                                | MapTile::PowerPellet
-                                | MapTile::Empty
-                                | MapTile::Tunnel
-                                | MapTile::StartingPosition(_)
-                        )
-                    })
-                    .expect("No valid starting position found on map for graph generation")
-            });
+        let start_pos = pacman_start.expect("Pac-Man's starting position not found");
 
         // Add the starting position to the graph/queue
         let mut queue = VecDeque::new();
@@ -100,7 +95,7 @@ impl Map {
                 // Skip if the new position is not a walkable tile
                 if matches!(
                     map[new_position.x as usize][new_position.y as usize],
-                    MapTile::Pellet | MapTile::PowerPellet | MapTile::Empty | MapTile::Tunnel | MapTile::StartingPosition(_)
+                    MapTile::Pellet | MapTile::PowerPellet | MapTile::Empty | MapTile::Tunnel
                 ) {
                     // Add the new position to the graph/queue
                     let pos = Vec2::new(
@@ -141,15 +136,26 @@ impl Map {
         }
 
         // Build house structure
-        Self::build_house(&mut graph, &grid_to_node, &house_door);
+        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);
+
+        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,
+        };
 
         // Build tunnel connections
         Self::build_tunnels(&mut graph, &grid_to_node, &tunnel_ends);
 
         Map {
             current: map,
-            grid_to_node,
             graph,
+            grid_to_node,
+            start_positions,
+            pacman_start,
         }
     }
 
@@ -163,14 +169,9 @@ impl Map {
     ///
     /// The starting position as a grid coordinate (`UVec2`), or `None` if not found.
     pub fn find_starting_position(&self, entity_id: u8) -> Option<UVec2> {
-        for (x, col) in self.current.iter().enumerate().take(BOARD_CELL_SIZE.x as usize) {
-            for (y, &cell) in col.iter().enumerate().take(BOARD_CELL_SIZE.y as usize) {
-                if let MapTile::StartingPosition(id) = cell {
-                    if id == entity_id {
-                        return Some(UVec2::new(x as u32, y as u32));
-                    }
-                }
-            }
+        // For now, only Pac-Man (entity_id 0) is supported
+        if entity_id == 0 {
+            return self.pacman_start.map(|pos| UVec2::new(pos.x as u32, pos.y as u32));
         }
         None
     }
@@ -193,7 +194,11 @@ impl Map {
     }
 
     /// Builds the house structure in the graph.
-    fn build_house(graph: &mut Graph, grid_to_node: &HashMap<IVec2, NodeId>, house_door: &[Option<IVec2>; 2]) {
+    fn build_house(
+        graph: &mut Graph,
+        grid_to_node: &HashMap<IVec2, NodeId>,
+        house_door: &[Option<IVec2>; 2],
+    ) -> (usize, usize, usize, usize) {
         // Calculate the position of the house entrance node
         let (house_entrance_node_id, house_entrance_node_position) = {
             // Translate the grid positions to the actual node ids
@@ -254,10 +259,29 @@ impl Map {
         // Create the center line
         let (center_center_node_id, center_top_node_id) = create_house_line(graph, center_line_center_position);
 
-        // Connect the house entrance to the top line
+        // Create a ghost-only, two-way connection for the house door.
+        // This prevents Pac-Man from entering or exiting through the door.
         graph
-            .connect(house_entrance_node_id, center_top_node_id, false, None, Direction::Down)
-            .expect("Failed to connect house entrance to top line");
+            .add_edge(
+                house_entrance_node_id,
+                center_top_node_id,
+                false,
+                None,
+                Direction::Down,
+                EdgePermissions::GhostsOnly,
+            )
+            .expect("Failed to create ghost-only entrance to house");
+
+        graph
+            .add_edge(
+                center_top_node_id,
+                house_entrance_node_id,
+                false,
+                None,
+                Direction::Up,
+                EdgePermissions::GhostsOnly,
+            )
+            .expect("Failed to create ghost-only exit from house");
 
         // Create the left line
         let (left_center_node_id, _) = create_house_line(
@@ -283,6 +307,13 @@ impl Map {
             .expect("Failed to connect house entrance to right top line");
 
         debug!("House entrance node id: {house_entrance_node_id}");
+
+        (
+            house_entrance_node_id,
+            left_center_node_id,
+            center_center_node_id,
+            right_center_node_id,
+        )
     }
 
     /// Builds the tunnel connections in the graph.
@@ -337,162 +368,3 @@ impl Map {
             .expect("Failed to connect left tunnel hidden node to right tunnel hidden node");
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::constants::{BOARD_CELL_SIZE, CELL_SIZE};
-    use glam::{IVec2, UVec2, Vec2};
-
-    fn create_minimal_test_board() -> [&'static str; BOARD_CELL_SIZE.y as usize] {
-        let mut board = [""; BOARD_CELL_SIZE.y as usize];
-        // Create a minimal valid board with house doors
-        board[0] = "############################";
-        board[1] = "#............##............#";
-        board[2] = "#.####.#####.##.#####.####.#";
-        board[3] = "#o####.#####.##.#####.####o#";
-        board[4] = "#.####.#####.##.#####.####.#";
-        board[5] = "#..........................#";
-        board[6] = "#.####.##.########.##.####.#";
-        board[7] = "#.####.##.########.##.####.#";
-        board[8] = "#......##....##....##......#";
-        board[9] = "######.##### ## #####.######";
-        board[10] = "     #.##### ## #####.#     ";
-        board[11] = "     #.##    ==    ##.#     ";
-        board[12] = "     #.## ######## ##.#     ";
-        board[13] = "######.## ######## ##.######";
-        board[14] = "T     .   ########   .     T";
-        board[15] = "######.## ######## ##.######";
-        board[16] = "     #.## ######## ##.#     ";
-        board[17] = "     #.##          ##.#     ";
-        board[18] = "     #.## ######## ##.#     ";
-        board[19] = "######.## ######## ##.######";
-        board[20] = "#............##............#";
-        board[21] = "#.####.#####.##.#####.####.#";
-        board[22] = "#.####.#####.##.#####.####.#";
-        board[23] = "#o..##.......0 .......##..o#";
-        board[24] = "###.##.##.########.##.##.###";
-        board[25] = "###.##.##.########.##.##.###";
-        board[26] = "#......##....##....##......#";
-        board[27] = "#.##########.##.##########.#";
-        board[28] = "#.##########.##.##########.#";
-        board[29] = "#..........................#";
-        board[30] = "############################";
-        board
-    }
-
-    #[test]
-    fn test_map_new() {
-        let board = create_minimal_test_board();
-        let map = Map::new(board);
-
-        assert!(map.graph.node_count() > 0);
-        assert!(!map.grid_to_node.is_empty());
-    }
-
-    #[test]
-    fn test_find_starting_position_pacman() {
-        let board = create_minimal_test_board();
-        let map = Map::new(board);
-
-        let pacman_pos = map.find_starting_position(0);
-        assert!(pacman_pos.is_some());
-
-        let pos = pacman_pos.unwrap();
-        // Pacman should be found somewhere in the board
-        assert!(pos.x < BOARD_CELL_SIZE.x);
-        assert!(pos.y < BOARD_CELL_SIZE.y);
-    }
-
-    #[test]
-    fn test_find_starting_position_ghost() {
-        let board = create_minimal_test_board();
-        let map = Map::new(board);
-
-        // Test for ghost 1 (might not exist in this board)
-        let ghost_pos = map.find_starting_position(1);
-        // Ghost 1 might not exist, so this could be None
-        if let Some(pos) = ghost_pos {
-            assert!(pos.x < BOARD_CELL_SIZE.x);
-            assert!(pos.y < BOARD_CELL_SIZE.y);
-        }
-    }
-
-    #[test]
-    fn test_find_starting_position_nonexistent() {
-        let board = create_minimal_test_board();
-        let map = Map::new(board);
-
-        let pos = map.find_starting_position(99); // Non-existent entity
-        assert!(pos.is_none());
-    }
-
-    #[test]
-    fn test_map_graph_construction() {
-        let board = create_minimal_test_board();
-        let map = Map::new(board);
-
-        // Check that nodes were created
-        assert!(map.graph.node_count() > 0);
-
-        // Check that grid_to_node mapping was created
-        assert!(!map.grid_to_node.is_empty());
-
-        // Check that some connections were made
-        let mut has_connections = false;
-        for intersection in &map.graph.adjacency_list {
-            if intersection.edges().next().is_some() {
-                has_connections = true;
-                break;
-            }
-        }
-        assert!(has_connections);
-    }
-
-    #[test]
-    fn test_map_grid_to_node_mapping() {
-        let board = create_minimal_test_board();
-        let map = Map::new(board);
-
-        // Check that Pac-Man's position is mapped
-        let pacman_pos = map.find_starting_position(0).unwrap();
-        let grid_pos = IVec2::new(pacman_pos.x as i32, pacman_pos.y as i32);
-
-        assert!(map.grid_to_node.contains_key(&grid_pos));
-        let node_id = map.grid_to_node[&grid_pos];
-        assert!(map.graph.get_node(node_id).is_some());
-    }
-
-    #[test]
-    fn test_map_node_positions() {
-        let board = create_minimal_test_board();
-        let map = Map::new(board);
-
-        // Check that node positions are correctly calculated
-        for (grid_pos, &node_id) in &map.grid_to_node {
-            let node = map.graph.get_node(node_id).unwrap();
-            let expected_pos = Vec2::new((grid_pos.x * CELL_SIZE as i32) as f32, (grid_pos.y * CELL_SIZE as i32) as f32)
-                + Vec2::splat(CELL_SIZE as f32 / 2.0);
-
-            assert_eq!(node.position, expected_pos);
-        }
-    }
-
-    #[test]
-    fn test_map_adjacent_connections() {
-        let board = create_minimal_test_board();
-        let map = Map::new(board);
-
-        // Check that adjacent walkable tiles are connected
-        // Find any node that has connections
-        let mut found_connected_node = false;
-        for (grid_pos, &node_id) in &map.grid_to_node {
-            let intersection = &map.graph.adjacency_list[node_id];
-            if intersection.edges().next().is_some() {
-                found_connected_node = true;
-                break;
-            }
-        }
-        assert!(found_connected_node);
-    }
-}

src/map/parser.rs

@@ -22,6 +22,8 @@ pub struct ParsedMap {
     pub house_door: [Option<IVec2>; 2],
     /// The positions of the tunnel end tiles.
     pub tunnel_ends: [Option<IVec2>; 2],
+    /// Pac-Man's starting position.
+    pub pacman_start: Option<IVec2>,
 }
 
 /// Parser for converting raw board layouts into structured map data.
@@ -44,8 +46,8 @@ impl MapTileParser {
             'o' => Ok(MapTile::PowerPellet),
             ' ' => Ok(MapTile::Empty),
             'T' => Ok(MapTile::Tunnel),
-            c @ '0'..='4' => Ok(MapTile::StartingPosition(c.to_digit(10).unwrap() as u8)),
-            '=' => Ok(MapTile::Wall), // House door is represented as a wall tile
+            'X' => Ok(MapTile::Empty), // Pac-Man's starting position, treated as empty
+            '=' => Ok(MapTile::Wall),  // House door is represented as a wall tile
             _ => Err(ParseError::UnknownCharacter(c)),
         }
     }
@@ -68,6 +70,7 @@ impl MapTileParser {
         let mut tiles = [[MapTile::Empty; BOARD_CELL_SIZE.y as usize]; BOARD_CELL_SIZE.x as usize];
         let mut house_door = [None; 2];
         let mut tunnel_ends = [None; 2];
+        let mut pacman_start: Option<IVec2> = None;
 
         for (y, line) in raw_board.iter().enumerate().take(BOARD_CELL_SIZE.y as usize) {
             for (x, character) in line.chars().enumerate().take(BOARD_CELL_SIZE.x as usize) {
@@ -92,6 +95,11 @@ impl MapTileParser {
                     _ => {}
                 }
 
+                // Track Pac-Man's starting position
+                if character == 'X' {
+                    pacman_start = Some(IVec2::new(x as i32, y as i32));
+                }
+
                 tiles[x][y] = tile;
             }
         }
@@ -106,63 +114,7 @@ impl MapTileParser {
             tiles,
             house_door,
             tunnel_ends,
+            pacman_start,
         })
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::constants::RAW_BOARD;
-
-    #[test]
-    fn test_parse_character() {
-        assert!(matches!(MapTileParser::parse_character('#').unwrap(), MapTile::Wall));
-        assert!(matches!(MapTileParser::parse_character('.').unwrap(), MapTile::Pellet));
-        assert!(matches!(MapTileParser::parse_character('o').unwrap(), MapTile::PowerPellet));
-        assert!(matches!(MapTileParser::parse_character(' ').unwrap(), MapTile::Empty));
-        assert!(matches!(MapTileParser::parse_character('T').unwrap(), MapTile::Tunnel));
-        assert!(matches!(
-            MapTileParser::parse_character('0').unwrap(),
-            MapTile::StartingPosition(0)
-        ));
-        assert!(matches!(
-            MapTileParser::parse_character('4').unwrap(),
-            MapTile::StartingPosition(4)
-        ));
-        assert!(matches!(MapTileParser::parse_character('=').unwrap(), MapTile::Wall));
-
-        // Test invalid character
-        assert!(MapTileParser::parse_character('X').is_err());
-    }
-
-    #[test]
-    fn test_parse_board() {
-        let result = MapTileParser::parse_board(RAW_BOARD);
-        assert!(result.is_ok());
-
-        let parsed = result.unwrap();
-
-        // Verify we have tiles
-        assert_eq!(parsed.tiles.len(), BOARD_CELL_SIZE.x as usize);
-        assert_eq!(parsed.tiles[0].len(), BOARD_CELL_SIZE.y as usize);
-
-        // Verify we found house door positions
-        assert!(parsed.house_door[0].is_some());
-        assert!(parsed.house_door[1].is_some());
-
-        // Verify we found tunnel ends
-        assert!(parsed.tunnel_ends[0].is_some());
-        assert!(parsed.tunnel_ends[1].is_some());
-    }
-
-    #[test]
-    fn test_parse_board_invalid_character() {
-        let mut invalid_board = RAW_BOARD.clone();
-        invalid_board[0] = "###########################X";
-
-        let result = MapTileParser::parse_board(invalid_board);
-        assert!(result.is_err());
-        assert!(matches!(result.unwrap_err(), ParseError::UnknownCharacter('X')));
-    }
-}

src/map/render.rs

@@ -65,80 +65,3 @@ impl MapRenderer {
         }
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::entity::graph::{Graph, Node};
-    use crate::texture::sprite::{AtlasMapper, MapperFrame};
-    use std::collections::HashMap;
-
-    fn create_test_graph() -> Graph {
-        let mut graph = Graph::new();
-        let node1 = graph.add_node(Node {
-            position: glam::Vec2::new(0.0, 0.0),
-        });
-        let node2 = graph.add_node(Node {
-            position: glam::Vec2::new(16.0, 0.0),
-        });
-        let node3 = graph.add_node(Node {
-            position: glam::Vec2::new(0.0, 16.0),
-        });
-
-        graph
-            .connect(node1, node2, false, None, crate::entity::direction::Direction::Right)
-            .unwrap();
-        graph
-            .connect(node1, node3, false, None, crate::entity::direction::Direction::Down)
-            .unwrap();
-
-        graph
-    }
-
-    fn create_test_atlas() -> SpriteAtlas {
-        let mut frames = HashMap::new();
-        frames.insert(
-            "maze/full.png".to_string(),
-            MapperFrame {
-                x: 0,
-                y: 0,
-                width: 224,
-                height: 248,
-            },
-        );
-        let mapper = AtlasMapper { frames };
-        let dummy_texture = unsafe { std::mem::zeroed() };
-        SpriteAtlas::new(dummy_texture, mapper)
-    }
-
-    #[test]
-    fn test_render_map_does_not_panic() {
-        // This test just ensures the function doesn't panic
-        // We can't easily test the actual rendering without SDL context
-        let atlas = create_test_atlas();
-        let _map_texture = SpriteAtlas::get_tile(&atlas, "maze/full.png").unwrap();
-
-        // The function should not panic even with dummy data
-        // Note: We can't actually call render_map without a canvas, but we can test the logic
-        assert!(true); // Placeholder test
-    }
-
-    #[test]
-    fn test_debug_render_nodes_does_not_panic() {
-        // This test just ensures the function doesn't panic
-        // We can't easily test the actual rendering without SDL context
-        let _graph = create_test_graph();
-
-        // The function should not panic even with dummy data
-        // Note: We can't actually call debug_render_nodes without a canvas, but we can test the logic
-        assert!(true); // Placeholder test
-    }
-
-    #[test]
-    fn test_map_renderer_structure() {
-        // Test that MapRenderer is a unit struct
-        let _renderer = MapRenderer;
-        // This should compile and not panic
-        assert!(true);
-    }
-}

src/texture/animated.rs

@@ -50,144 +50,27 @@ impl AnimatedTexture {
         tile.render(canvas, atlas, dest)
     }
 
-    // Helper methods for testing
+    /// Returns the current frame index.
+    #[allow(dead_code)]
     pub fn current_frame(&self) -> usize {
         self.current_frame
     }
 
+    /// Returns the time bank.
+    #[allow(dead_code)]
     pub fn time_bank(&self) -> f32 {
         self.time_bank
     }
 
+    /// Returns the frame duration.
+    #[allow(dead_code)]
     pub fn frame_duration(&self) -> f32 {
         self.frame_duration
     }
 
+    /// Returns the number of tiles in the animation.
+    #[allow(dead_code)]
     pub fn tiles_len(&self) -> usize {
         self.tiles.len()
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use glam::U16Vec2;
-    use sdl2::pixels::Color;
-
-    impl AtlasTile {
-        fn mock(id: u32) -> Self {
-            AtlasTile {
-                pos: U16Vec2::new(0, 0),
-                size: U16Vec2::new(16, 16),
-                color: Some(Color::RGB(id as u8, 0, 0)),
-            }
-        }
-    }
-
-    #[test]
-    fn test_new_animated_texture() {
-        let tiles = vec![AtlasTile::mock(1), AtlasTile::mock(2), AtlasTile::mock(3)];
-        let texture = AnimatedTexture::new(tiles.clone(), 0.1).unwrap();
-
-        assert_eq!(texture.current_frame(), 0);
-        assert_eq!(texture.time_bank(), 0.0);
-        assert_eq!(texture.frame_duration(), 0.1);
-        assert_eq!(texture.tiles_len(), 3);
-    }
-
-    #[test]
-    fn test_new_animated_texture_zero_duration() {
-        let tiles = vec![AtlasTile::mock(1), AtlasTile::mock(2)];
-        let result = AnimatedTexture::new(tiles, 0.0);
-        assert!(result.is_err());
-        assert!(matches!(result.unwrap_err(), AnimatedTextureError::InvalidFrameDuration(0.0)));
-    }
-
-    #[test]
-    fn test_new_animated_texture_negative_duration() {
-        let tiles = vec![AtlasTile::mock(1), AtlasTile::mock(2)];
-        let result = AnimatedTexture::new(tiles, -0.1);
-        assert!(result.is_err());
-        assert!(matches!(
-            result.unwrap_err(),
-            AnimatedTextureError::InvalidFrameDuration(-0.1)
-        ));
-    }
-
-    #[test]
-    fn test_tick_no_frame_change() {
-        let tiles = vec![AtlasTile::mock(1), AtlasTile::mock(2)];
-        let mut texture = AnimatedTexture::new(tiles, 0.1).unwrap();
-
-        // Tick with less than frame duration
-        texture.tick(0.05);
-        assert_eq!(texture.current_frame(), 0);
-        assert_eq!(texture.time_bank(), 0.05);
-    }
-
-    #[test]
-    fn test_tick_single_frame_change() {
-        let tiles = vec![AtlasTile::mock(1), AtlasTile::mock(2)];
-        let mut texture = AnimatedTexture::new(tiles, 0.1).unwrap();
-
-        // Tick with exactly frame duration
-        texture.tick(0.1);
-        assert_eq!(texture.current_frame(), 1);
-        assert_eq!(texture.time_bank(), 0.0);
-    }
-
-    #[test]
-    fn test_tick_multiple_frame_changes() {
-        let tiles = vec![AtlasTile::mock(1), AtlasTile::mock(2), AtlasTile::mock(3)];
-        let mut texture = AnimatedTexture::new(tiles, 0.1).unwrap();
-
-        // Tick with 2.5 frame durations
-        texture.tick(0.25);
-        assert_eq!(texture.current_frame(), 2);
-        assert!((texture.time_bank() - 0.05).abs() < 0.001);
-    }
-
-    #[test]
-    fn test_tick_wrap_around() {
-        let tiles = vec![AtlasTile::mock(1), AtlasTile::mock(2)];
-        let mut texture = AnimatedTexture::new(tiles, 0.1).unwrap();
-
-        // Advance to last frame
-        texture.tick(0.1);
-        assert_eq!(texture.current_frame(), 1);
-
-        // Advance again to wrap around
-        texture.tick(0.1);
-        assert_eq!(texture.current_frame(), 0);
-    }
-
-    #[test]
-    fn test_current_tile() {
-        let tiles = vec![AtlasTile::mock(1), AtlasTile::mock(2)];
-        let texture = AnimatedTexture::new(tiles, 0.1).unwrap();
-
-        // Should return first tile initially
-        assert_eq!(texture.current_tile().color.unwrap().r, 1);
-    }
-
-    #[test]
-    fn test_current_tile_after_frame_change() {
-        let tiles = vec![AtlasTile::mock(1), AtlasTile::mock(2)];
-        let mut texture = AnimatedTexture::new(tiles, 0.1).unwrap();
-
-        // Advance one frame
-        texture.tick(0.1);
-        assert_eq!(texture.current_tile().color.unwrap().r, 2);
-    }
-
-    #[test]
-    fn test_single_tile_animation() {
-        let tiles = vec![AtlasTile::mock(1)];
-        let mut texture = AnimatedTexture::new(tiles, 0.1).unwrap();
-
-        // Should stay on same frame
-        texture.tick(0.1);
-        assert_eq!(texture.current_frame(), 0);
-        assert_eq!(texture.current_tile().color.unwrap().r, 1);
-    }
-}

src/texture/blinking.rs

@@ -44,135 +44,3 @@ impl BlinkingTexture {
         self.blink_duration
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use glam::U16Vec2;
-    use sdl2::pixels::Color;
-
-    fn mock_atlas_tile(id: u32) -> AtlasTile {
-        AtlasTile {
-            pos: U16Vec2::new(0, 0),
-            size: U16Vec2::new(16, 16),
-            color: Some(Color::RGB(id as u8, 0, 0)),
-        }
-    }
-
-    #[test]
-    fn test_new_blinking_texture() {
-        let tile = mock_atlas_tile(1);
-        let texture = BlinkingTexture::new(tile, 0.5);
-
-        assert_eq!(texture.is_on(), true);
-        assert_eq!(texture.time_bank(), 0.0);
-        assert_eq!(texture.blink_duration(), 0.5);
-        assert_eq!(texture.tile().color.unwrap().r, 1);
-    }
-
-    #[test]
-    fn test_tick_no_blink_change() {
-        let tile = mock_atlas_tile(1);
-        let mut texture = BlinkingTexture::new(tile, 0.5);
-
-        // Tick with less than blink duration
-        texture.tick(0.25);
-        assert_eq!(texture.is_on(), true);
-        assert_eq!(texture.time_bank(), 0.25);
-    }
-
-    #[test]
-    fn test_tick_single_blink_change() {
-        let tile = mock_atlas_tile(1);
-        let mut texture = BlinkingTexture::new(tile, 0.5);
-
-        // Tick with exactly blink duration
-        texture.tick(0.5);
-        assert_eq!(texture.is_on(), false);
-        assert_eq!(texture.time_bank(), 0.0);
-    }
-
-    #[test]
-    fn test_tick_multiple_blink_changes() {
-        let tile = mock_atlas_tile(1);
-        let mut texture = BlinkingTexture::new(tile, 0.5);
-
-        // First blink
-        texture.tick(0.5);
-        assert_eq!(texture.is_on(), false);
-
-        // Second blink (back to on)
-        texture.tick(0.5);
-        assert_eq!(texture.is_on(), true);
-
-        // Third blink (back to off)
-        texture.tick(0.5);
-        assert_eq!(texture.is_on(), false);
-    }
-
-    #[test]
-    fn test_tick_partial_blink_duration() {
-        let tile = mock_atlas_tile(1);
-        let mut texture = BlinkingTexture::new(tile, 0.5);
-
-        // Tick with 1.25 blink durations
-        texture.tick(0.625);
-        assert_eq!(texture.is_on(), false);
-        assert_eq!(texture.time_bank(), 0.125);
-    }
-
-    #[test]
-    fn test_tick_with_zero_duration() {
-        let tile = mock_atlas_tile(1);
-        let mut texture = BlinkingTexture::new(tile, 0.0);
-
-        // Should not cause issues - skip the test if blink_duration is 0
-        if texture.blink_duration() > 0.0 {
-            texture.tick(0.1);
-            assert_eq!(texture.is_on(), true);
-        }
-    }
-
-    #[test]
-    fn test_tick_with_negative_duration() {
-        let tile = mock_atlas_tile(1);
-        let mut texture = BlinkingTexture::new(tile, -0.5);
-
-        // Should not cause issues - skip the test if blink_duration is negative
-        if texture.blink_duration() > 0.0 {
-            texture.tick(0.1);
-            assert_eq!(texture.is_on(), true);
-        }
-    }
-
-    #[test]
-    fn test_tick_with_negative_delta_time() {
-        let tile = mock_atlas_tile(1);
-        let mut texture = BlinkingTexture::new(tile, 0.5);
-
-        // Should not cause issues
-        texture.tick(-0.1);
-        assert_eq!(texture.is_on(), true);
-        assert_eq!(texture.time_bank(), -0.1);
-    }
-
-    #[test]
-    fn test_tile_access() {
-        let tile = mock_atlas_tile(42);
-        let texture = BlinkingTexture::new(tile, 0.5);
-
-        assert_eq!(texture.tile().color.unwrap().r, 42);
-    }
-
-    #[test]
-    fn test_clone() {
-        let tile = mock_atlas_tile(1);
-        let texture = BlinkingTexture::new(tile, 0.5);
-        let cloned = texture.clone();
-
-        assert_eq!(texture.is_on(), cloned.is_on());
-        assert_eq!(texture.time_bank(), cloned.time_bank());
-        assert_eq!(texture.blink_duration(), cloned.blink_duration());
-        assert_eq!(texture.tile().color.unwrap().r, cloned.tile().color.unwrap().r);
-    }
-}

src/texture/directional.rs

@@ -55,129 +55,27 @@ impl DirectionalAnimatedTexture {
         }
     }
 
-    // Helper methods for testing
+    /// Returns true if the texture has a direction.
+    #[allow(dead_code)]
     pub fn has_direction(&self, direction: Direction) -> bool {
         self.textures.contains_key(&direction)
     }
 
+    /// Returns true if the texture has a stopped direction.
+    #[allow(dead_code)]
     pub fn has_stopped_direction(&self, direction: Direction) -> bool {
         self.stopped_textures.contains_key(&direction)
     }
 
+    /// Returns the number of textures.
+    #[allow(dead_code)]
     pub fn texture_count(&self) -> usize {
         self.textures.len()
     }
 
+    /// Returns the number of stopped textures.
+    #[allow(dead_code)]
     pub fn stopped_texture_count(&self) -> usize {
         self.stopped_textures.len()
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::texture::sprite::AtlasTile;
-    use glam::U16Vec2;
-    use sdl2::pixels::Color;
-
-    fn mock_atlas_tile(id: u32) -> AtlasTile {
-        AtlasTile {
-            pos: U16Vec2::new(0, 0),
-            size: U16Vec2::new(16, 16),
-            color: Some(Color::RGB(id as u8, 0, 0)),
-        }
-    }
-
-    fn mock_animated_texture(id: u32) -> AnimatedTexture {
-        AnimatedTexture::new(vec![mock_atlas_tile(id)], 0.1).expect("Invalid frame duration")
-    }
-
-    #[test]
-    fn test_new_directional_animated_texture() {
-        let mut textures = HashMap::new();
-        let mut stopped_textures = HashMap::new();
-
-        textures.insert(Direction::Up, mock_animated_texture(1));
-        textures.insert(Direction::Down, mock_animated_texture(2));
-        stopped_textures.insert(Direction::Up, mock_animated_texture(3));
-        stopped_textures.insert(Direction::Down, mock_animated_texture(4));
-
-        let texture = DirectionalAnimatedTexture::new(textures, stopped_textures);
-
-        assert_eq!(texture.texture_count(), 2);
-        assert_eq!(texture.stopped_texture_count(), 2);
-        assert!(texture.has_direction(Direction::Up));
-        assert!(texture.has_direction(Direction::Down));
-        assert!(!texture.has_direction(Direction::Left));
-        assert!(texture.has_stopped_direction(Direction::Up));
-        assert!(texture.has_stopped_direction(Direction::Down));
-        assert!(!texture.has_stopped_direction(Direction::Left));
-    }
-
-    #[test]
-    fn test_tick() {
-        let mut textures = HashMap::new();
-        textures.insert(Direction::Up, mock_animated_texture(1));
-        textures.insert(Direction::Down, mock_animated_texture(2));
-
-        let mut texture = DirectionalAnimatedTexture::new(textures, HashMap::new());
-
-        // Should not panic
-        texture.tick(0.1);
-        assert_eq!(texture.texture_count(), 2);
-    }
-
-    #[test]
-    fn test_empty_texture() {
-        let texture = DirectionalAnimatedTexture::new(HashMap::new(), HashMap::new());
-
-        assert_eq!(texture.texture_count(), 0);
-        assert_eq!(texture.stopped_texture_count(), 0);
-        assert!(!texture.has_direction(Direction::Up));
-        assert!(!texture.has_stopped_direction(Direction::Up));
-    }
-
-    #[test]
-    fn test_partial_directions() {
-        let mut textures = HashMap::new();
-        textures.insert(Direction::Up, mock_animated_texture(1));
-
-        let texture = DirectionalAnimatedTexture::new(textures, HashMap::new());
-
-        assert_eq!(texture.texture_count(), 1);
-        assert!(texture.has_direction(Direction::Up));
-        assert!(!texture.has_direction(Direction::Down));
-        assert!(!texture.has_direction(Direction::Left));
-        assert!(!texture.has_direction(Direction::Right));
-    }
-
-    #[test]
-    fn test_clone() {
-        let mut textures = HashMap::new();
-        textures.insert(Direction::Up, mock_animated_texture(1));
-
-        let texture = DirectionalAnimatedTexture::new(textures, HashMap::new());
-        let cloned = texture.clone();
-
-        assert_eq!(texture.texture_count(), cloned.texture_count());
-        assert_eq!(texture.stopped_texture_count(), cloned.stopped_texture_count());
-        assert_eq!(texture.has_direction(Direction::Up), cloned.has_direction(Direction::Up));
-    }
-
-    #[test]
-    fn test_all_directions() {
-        let mut textures = HashMap::new();
-        textures.insert(Direction::Up, mock_animated_texture(1));
-        textures.insert(Direction::Down, mock_animated_texture(2));
-        textures.insert(Direction::Left, mock_animated_texture(3));
-        textures.insert(Direction::Right, mock_animated_texture(4));
-
-        let texture = DirectionalAnimatedTexture::new(textures, HashMap::new());
-
-        assert_eq!(texture.texture_count(), 4);
-        assert!(texture.has_direction(Direction::Up));
-        assert!(texture.has_direction(Direction::Down));
-        assert!(texture.has_direction(Direction::Left));
-        assert!(texture.has_direction(Direction::Right));
-    }
-}

src/texture/sprite.rs

@@ -50,11 +50,14 @@ impl AtlasTile {
         Ok(())
     }
 
-    // Helper methods for testing
+    /// 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
@@ -96,15 +99,20 @@ impl SpriteAtlas {
         &self.texture
     }
 
-    // Helper methods for testing
+    /// 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
     }
@@ -126,236 +134,3 @@ impl SpriteAtlas {
 pub unsafe fn texture_to_static(texture: Texture) -> Texture<'static> {
     std::mem::transmute(texture)
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use sdl2::pixels::Color;
-
-    // Mock texture for testing - we'll use a dummy approach since we can't create real SDL2 textures
-    fn mock_texture() -> Texture<'static> {
-        // This is unsafe and only for testing - in real usage this would be a proper texture
-        unsafe { std::mem::transmute(0usize) }
-    }
-
-    #[test]
-    fn test_atlas_tile_new() {
-        let pos = U16Vec2::new(10, 20);
-        let size = U16Vec2::new(32, 32);
-        let tile = AtlasTile::new(pos, size, None);
-
-        assert_eq!(tile.pos, pos);
-        assert_eq!(tile.size, size);
-        assert_eq!(tile.color, None);
-    }
-
-    #[test]
-    fn test_atlas_tile_with_color() {
-        let pos = U16Vec2::new(10, 20);
-        let size = U16Vec2::new(32, 32);
-        let color = Color::RGB(255, 0, 0);
-        let tile = AtlasTile::new(pos, size, None).with_color(color);
-
-        assert_eq!(tile.pos, pos);
-        assert_eq!(tile.size, size);
-        assert_eq!(tile.color, Some(color));
-    }
-
-    #[test]
-    fn test_mapper_frame() {
-        let frame = MapperFrame {
-            x: 10,
-            y: 20,
-            width: 32,
-            height: 32,
-        };
-
-        assert_eq!(frame.x, 10);
-        assert_eq!(frame.y, 20);
-        assert_eq!(frame.width, 32);
-        assert_eq!(frame.height, 32);
-    }
-
-    #[test]
-    fn test_atlas_mapper_new() {
-        let mut frames = HashMap::new();
-        frames.insert(
-            "test".to_string(),
-            MapperFrame {
-                x: 0,
-                y: 0,
-                width: 32,
-                height: 32,
-            },
-        );
-
-        let mapper = AtlasMapper { frames };
-
-        assert_eq!(mapper.frames.len(), 1);
-        assert!(mapper.frames.contains_key("test"));
-    }
-
-    #[test]
-    fn test_sprite_atlas_new() {
-        let mut frames = HashMap::new();
-        frames.insert(
-            "test".to_string(),
-            MapperFrame {
-                x: 0,
-                y: 0,
-                width: 32,
-                height: 32,
-            },
-        );
-
-        let mapper = AtlasMapper { frames };
-        let texture = mock_texture();
-        let atlas = SpriteAtlas::new(texture, mapper);
-
-        assert_eq!(atlas.tiles_count(), 1);
-        assert!(atlas.has_tile("test"));
-        assert_eq!(atlas.default_color(), None);
-    }
-
-    #[test]
-    fn test_sprite_atlas_get_tile() {
-        let mut frames = HashMap::new();
-        frames.insert(
-            "test".to_string(),
-            MapperFrame {
-                x: 10,
-                y: 20,
-                width: 32,
-                height: 64,
-            },
-        );
-
-        let mapper = AtlasMapper { frames };
-        let texture = mock_texture();
-        let atlas = SpriteAtlas::new(texture, mapper);
-
-        let tile = atlas.get_tile("test");
-        assert!(tile.is_some());
-
-        let tile = tile.unwrap();
-        assert_eq!(tile.pos, U16Vec2::new(10, 20));
-        assert_eq!(tile.size, U16Vec2::new(32, 64));
-        assert_eq!(tile.color, None);
-    }
-
-    #[test]
-    fn test_sprite_atlas_get_tile_nonexistent() {
-        let mapper = AtlasMapper { frames: HashMap::new() };
-        let texture = mock_texture();
-        let atlas = SpriteAtlas::new(texture, mapper);
-
-        let tile = atlas.get_tile("nonexistent");
-        assert!(tile.is_none());
-    }
-
-    #[test]
-    fn test_sprite_atlas_set_color() {
-        let mapper = AtlasMapper { frames: HashMap::new() };
-        let texture = mock_texture();
-        let mut atlas = SpriteAtlas::new(texture, mapper);
-
-        assert_eq!(atlas.default_color(), None);
-
-        let color = Color::RGB(255, 0, 0);
-        atlas.set_color(color);
-
-        assert_eq!(atlas.default_color(), Some(color));
-    }
-
-    #[test]
-    fn test_sprite_atlas_empty() {
-        let mapper = AtlasMapper { frames: HashMap::new() };
-        let texture = mock_texture();
-        let atlas = SpriteAtlas::new(texture, mapper);
-
-        assert_eq!(atlas.tiles_count(), 0);
-        assert!(!atlas.has_tile("any"));
-    }
-
-    #[test]
-    fn test_sprite_atlas_multiple_tiles() {
-        let mut frames = HashMap::new();
-        frames.insert(
-            "tile1".to_string(),
-            MapperFrame {
-                x: 0,
-                y: 0,
-                width: 32,
-                height: 32,
-            },
-        );
-        frames.insert(
-            "tile2".to_string(),
-            MapperFrame {
-                x: 32,
-                y: 0,
-                width: 64,
-                height: 64,
-            },
-        );
-
-        let mapper = AtlasMapper { frames };
-        let texture = mock_texture();
-        let atlas = SpriteAtlas::new(texture, mapper);
-
-        assert_eq!(atlas.tiles_count(), 2);
-        assert!(atlas.has_tile("tile1"));
-        assert!(atlas.has_tile("tile2"));
-        assert!(!atlas.has_tile("tile3"));
-    }
-
-    #[test]
-    fn test_atlas_tile_clone() {
-        let pos = U16Vec2::new(10, 20);
-        let size = U16Vec2::new(32, 32);
-        let color = Color::RGB(255, 0, 0);
-        let tile = AtlasTile::new(pos, size, Some(color));
-        let cloned = tile;
-
-        assert_eq!(tile.pos, cloned.pos);
-        assert_eq!(tile.size, cloned.size);
-        assert_eq!(tile.color, cloned.color);
-    }
-
-    #[test]
-    fn test_mapper_frame_clone() {
-        let frame = MapperFrame {
-            x: 10,
-            y: 20,
-            width: 32,
-            height: 64,
-        };
-        let cloned = frame;
-
-        assert_eq!(frame.x, cloned.x);
-        assert_eq!(frame.y, cloned.y);
-        assert_eq!(frame.width, cloned.width);
-        assert_eq!(frame.height, cloned.height);
-    }
-
-    #[test]
-    fn test_atlas_mapper_clone() {
-        let mut frames = HashMap::new();
-        frames.insert(
-            "test".to_string(),
-            MapperFrame {
-                x: 0,
-                y: 0,
-                width: 32,
-                height: 32,
-            },
-        );
-
-        let mapper = AtlasMapper { frames };
-        let cloned = mapper.clone();
-
-        assert_eq!(mapper.frames.len(), cloned.frames.len());
-        assert!(mapper.frames.contains_key("test"));
-        assert!(cloned.frames.contains_key("test"));
-    }
-}

src/texture/text.rs

@@ -151,228 +151,3 @@ impl TextTexture {
         (8.0 * self.scale) as u32
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::texture::sprite::{AtlasMapper, MapperFrame, SpriteAtlas};
-    use std::collections::HashMap;
-
-    fn create_mock_atlas() -> SpriteAtlas {
-        let mut frames = HashMap::new();
-        frames.insert(
-            "text/A.png".to_string(),
-            MapperFrame {
-                x: 0,
-                y: 0,
-                width: 8,
-                height: 8,
-            },
-        );
-        frames.insert(
-            "text/1.png".to_string(),
-            MapperFrame {
-                x: 8,
-                y: 0,
-                width: 8,
-                height: 8,
-            },
-        );
-        frames.insert(
-            "text/!.png".to_string(),
-            MapperFrame {
-                x: 16,
-                y: 0,
-                width: 8,
-                height: 8,
-            },
-        );
-        frames.insert(
-            "text/-.png".to_string(),
-            MapperFrame {
-                x: 24,
-                y: 0,
-                width: 8,
-                height: 8,
-            },
-        );
-        frames.insert(
-            "text/_double_quote.png".to_string(),
-            MapperFrame {
-                x: 32,
-                y: 0,
-                width: 8,
-                height: 8,
-            },
-        );
-        frames.insert(
-            "text/_forward_slash.png".to_string(),
-            MapperFrame {
-                x: 40,
-                y: 0,
-                width: 8,
-                height: 8,
-            },
-        );
-
-        let mapper = AtlasMapper { frames };
-        // Note: In real tests, we'd need a proper texture, but for unit tests we can work around this
-        unsafe { SpriteAtlas::new(std::mem::zeroed(), mapper) }
-    }
-
-    #[test]
-    fn test_text_texture_new() {
-        let text_texture = TextTexture::new(1.0);
-        assert_eq!(text_texture.scale(), 1.0);
-        assert!(text_texture.char_map.is_empty());
-    }
-
-    #[test]
-    fn test_text_texture_new_with_scale() {
-        let text_texture = TextTexture::new(2.5);
-        assert_eq!(text_texture.scale(), 2.5);
-    }
-
-    #[test]
-    fn test_char_to_tile_name_letters() {
-        let text_texture = TextTexture::new(1.0);
-
-        assert_eq!(text_texture.char_to_tile_name('A'), Some("text/A.png".to_string()));
-        assert_eq!(text_texture.char_to_tile_name('Z'), Some("text/Z.png".to_string()));
-        assert_eq!(text_texture.char_to_tile_name('a'), None); // lowercase not supported
-    }
-
-    #[test]
-    fn test_char_to_tile_name_numbers() {
-        let text_texture = TextTexture::new(1.0);
-
-        assert_eq!(text_texture.char_to_tile_name('0'), Some("text/0.png".to_string()));
-        assert_eq!(text_texture.char_to_tile_name('9'), Some("text/9.png".to_string()));
-    }
-
-    #[test]
-    fn test_char_to_tile_name_special_characters() {
-        let text_texture = TextTexture::new(1.0);
-
-        assert_eq!(text_texture.char_to_tile_name('!'), Some("text/!.png".to_string()));
-        assert_eq!(text_texture.char_to_tile_name('-'), Some("text/-.png".to_string()));
-        assert_eq!(
-            text_texture.char_to_tile_name('"'),
-            Some("text/_double_quote.png".to_string())
-        );
-        assert_eq!(
-            text_texture.char_to_tile_name('/'),
-            Some("text/_forward_slash.png".to_string())
-        );
-    }
-
-    #[test]
-    fn test_char_to_tile_name_unsupported() {
-        let text_texture = TextTexture::new(1.0);
-
-        assert_eq!(text_texture.char_to_tile_name(' '), None);
-        assert_eq!(text_texture.char_to_tile_name('@'), None);
-        assert_eq!(text_texture.char_to_tile_name('a'), None);
-        assert_eq!(text_texture.char_to_tile_name('z'), None);
-    }
-
-    #[test]
-    fn test_set_scale() {
-        let mut text_texture = TextTexture::new(1.0);
-        assert_eq!(text_texture.scale(), 1.0);
-
-        text_texture.set_scale(3.0);
-        assert_eq!(text_texture.scale(), 3.0);
-
-        text_texture.set_scale(0.5);
-        assert_eq!(text_texture.scale(), 0.5);
-    }
-
-    #[test]
-    fn test_text_width_empty_string() {
-        let text_texture = TextTexture::new(1.0);
-        assert_eq!(text_texture.text_width(""), 0);
-    }
-
-    #[test]
-    fn test_text_width_single_character() {
-        let text_texture = TextTexture::new(1.0);
-        assert_eq!(text_texture.text_width("A"), 8); // 8 pixels per character at scale 1.0
-    }
-
-    #[test]
-    fn test_text_width_multiple_characters() {
-        let text_texture = TextTexture::new(1.0);
-        assert_eq!(text_texture.text_width("ABC"), 24); // 3 * 8 = 24 pixels
-    }
-
-    #[test]
-    fn test_text_width_with_scale() {
-        let text_texture = TextTexture::new(2.0);
-        assert_eq!(text_texture.text_width("A"), 16); // 8 * 2 = 16 pixels
-        assert_eq!(text_texture.text_width("ABC"), 48); // 3 * 16 = 48 pixels
-    }
-
-    #[test]
-    fn test_text_width_with_unsupported_characters() {
-        let text_texture = TextTexture::new(1.0);
-        // Only supported characters should be counted
-        assert_eq!(text_texture.text_width("A B"), 16); // A and B only, space ignored
-        assert_eq!(text_texture.text_width("A@B"), 16); // A and B only, @ ignored
-    }
-
-    #[test]
-    fn test_text_height() {
-        let text_texture = TextTexture::new(1.0);
-        assert_eq!(text_texture.text_height(), 8); // 8 pixels per character at scale 1.0
-    }
-
-    #[test]
-    fn test_text_height_with_scale() {
-        let text_texture = TextTexture::new(2.0);
-        assert_eq!(text_texture.text_height(), 16); // 8 * 2 = 16 pixels
-    }
-
-    #[test]
-    fn test_text_height_with_fractional_scale() {
-        let text_texture = TextTexture::new(1.5);
-        assert_eq!(text_texture.text_height(), 12); // 8 * 1.5 = 12 pixels
-    }
-
-    #[test]
-    fn test_get_char_tile_caching() {
-        let mut text_texture = TextTexture::new(1.0);
-        let atlas = create_mock_atlas();
-
-        // First call should cache the tile
-        let tile1 = text_texture.get_char_tile(&atlas, 'A');
-        assert!(tile1.is_some());
-
-        // Second call should use cached tile
-        let tile2 = text_texture.get_char_tile(&atlas, 'A');
-        assert!(tile2.is_some());
-
-        // Both should be the same tile
-        assert_eq!(tile1.unwrap().pos, tile2.unwrap().pos);
-        assert_eq!(tile1.unwrap().size, tile2.unwrap().size);
-    }
-
-    #[test]
-    fn test_get_char_tile_unsupported_character() {
-        let mut text_texture = TextTexture::new(1.0);
-        let atlas = create_mock_atlas();
-
-        let tile = text_texture.get_char_tile(&atlas, ' ');
-        assert!(tile.is_none());
-    }
-
-    #[test]
-    fn test_get_char_tile_missing_from_atlas() {
-        let mut text_texture = TextTexture::new(1.0);
-        let atlas = create_mock_atlas();
-
-        // 'B' is not in our mock atlas
-        let tile = text_texture.get_char_tile(&atlas, 'B');
-        assert!(tile.is_none());
-    }
-}

tests/animated.rs

@@ -0,0 +1,61 @@
+use glam::U16Vec2;
+use pacman::texture::animated::{AnimatedTexture, AnimatedTextureError};
+use pacman::texture::sprite::AtlasTile;
+use sdl2::pixels::Color;
+
+fn mock_atlas_tile(id: u32) -> AtlasTile {
+    AtlasTile {
+        pos: U16Vec2::new(0, 0),
+        size: U16Vec2::new(16, 16),
+        color: Some(Color::RGB(id as u8, 0, 0)),
+    }
+}
+
+#[test]
+fn test_animated_texture_creation_errors() {
+    let tiles = vec![mock_atlas_tile(1), mock_atlas_tile(2)];
+
+    assert!(matches!(
+        AnimatedTexture::new(tiles.clone(), 0.0).unwrap_err(),
+        AnimatedTextureError::InvalidFrameDuration(0.0)
+    ));
+
+    assert!(matches!(
+        AnimatedTexture::new(tiles, -0.1).unwrap_err(),
+        AnimatedTextureError::InvalidFrameDuration(-0.1)
+    ));
+}
+
+#[test]
+fn test_animated_texture_advancement() {
+    let tiles = vec![mock_atlas_tile(1), mock_atlas_tile(2), mock_atlas_tile(3)];
+    let mut texture = AnimatedTexture::new(tiles, 0.1).unwrap();
+
+    assert_eq!(texture.current_frame(), 0);
+
+    texture.tick(0.25);
+    assert_eq!(texture.current_frame(), 2);
+    assert!((texture.time_bank() - 0.05).abs() < 0.001);
+}
+
+#[test]
+fn test_animated_texture_wrap_around() {
+    let tiles = vec![mock_atlas_tile(1), mock_atlas_tile(2)];
+    let mut texture = AnimatedTexture::new(tiles, 0.1).unwrap();
+
+    texture.tick(0.1);
+    assert_eq!(texture.current_frame(), 1);
+
+    texture.tick(0.1);
+    assert_eq!(texture.current_frame(), 0);
+}
+
+#[test]
+fn test_animated_texture_single_frame() {
+    let tiles = vec![mock_atlas_tile(1)];
+    let mut texture = AnimatedTexture::new(tiles, 0.1).unwrap();
+
+    texture.tick(0.1);
+    assert_eq!(texture.current_frame(), 0);
+    assert_eq!(texture.current_tile().color.unwrap().r, 1);
+}

tests/blinking.rs

@@ -0,0 +1,49 @@
+use glam::U16Vec2;
+use pacman::texture::blinking::BlinkingTexture;
+use pacman::texture::sprite::AtlasTile;
+use sdl2::pixels::Color;
+
+fn mock_atlas_tile(id: u32) -> AtlasTile {
+    AtlasTile {
+        pos: U16Vec2::new(0, 0),
+        size: U16Vec2::new(16, 16),
+        color: Some(Color::RGB(id as u8, 0, 0)),
+    }
+}
+
+#[test]
+fn test_blinking_texture() {
+    let tile = mock_atlas_tile(1);
+    let mut texture = BlinkingTexture::new(tile, 0.5);
+
+    assert_eq!(texture.is_on(), true);
+
+    texture.tick(0.5);
+    assert_eq!(texture.is_on(), false);
+
+    texture.tick(0.5);
+    assert_eq!(texture.is_on(), true);
+
+    texture.tick(0.5);
+    assert_eq!(texture.is_on(), false);
+}
+
+#[test]
+fn test_blinking_texture_partial_duration() {
+    let tile = mock_atlas_tile(1);
+    let mut texture = BlinkingTexture::new(tile, 0.5);
+
+    texture.tick(0.625);
+    assert_eq!(texture.is_on(), false);
+    assert_eq!(texture.time_bank(), 0.125);
+}
+
+#[test]
+fn test_blinking_texture_negative_time() {
+    let tile = mock_atlas_tile(1);
+    let mut texture = BlinkingTexture::new(tile, 0.5);
+
+    texture.tick(-0.1);
+    assert_eq!(texture.is_on(), true);
+    assert_eq!(texture.time_bank(), -0.1);
+}

tests/constants.rs

@@ -0,0 +1,28 @@
+use pacman::constants::*;
+
+#[test]
+fn test_raw_board_structure() {
+    assert_eq!(RAW_BOARD.len(), BOARD_CELL_SIZE.y as usize);
+
+    for row in RAW_BOARD.iter() {
+        assert_eq!(row.len(), BOARD_CELL_SIZE.x as usize);
+    }
+
+    // Test boundaries
+    assert!(RAW_BOARD[0].chars().all(|c| c == '#'));
+    assert!(RAW_BOARD[RAW_BOARD.len() - 1].chars().all(|c| c == '#'));
+
+    // Test tunnel row
+    let tunnel_row = RAW_BOARD[14];
+    assert_eq!(tunnel_row.chars().next().unwrap(), 'T');
+    assert_eq!(tunnel_row.chars().last().unwrap(), 'T');
+}
+
+#[test]
+fn test_raw_board_content() {
+    let power_pellet_count = RAW_BOARD.iter().flat_map(|row| row.chars()).filter(|&c| c == 'o').count();
+    assert_eq!(power_pellet_count, 4);
+
+    assert!(RAW_BOARD.iter().any(|row| row.contains('X')));
+    assert!(RAW_BOARD.iter().any(|row| row.contains("==")));
+}

tests/direction.rs

@@ -0,0 +1,31 @@
+use glam::IVec2;
+use pacman::entity::direction::*;
+
+#[test]
+fn test_direction_opposite() {
+    let test_cases = [
+        (Direction::Up, Direction::Down),
+        (Direction::Down, Direction::Up),
+        (Direction::Left, Direction::Right),
+        (Direction::Right, Direction::Left),
+    ];
+
+    for (dir, expected) in test_cases {
+        assert_eq!(dir.opposite(), expected);
+    }
+}
+
+#[test]
+fn test_direction_as_ivec2() {
+    let test_cases = [
+        (Direction::Up, -IVec2::Y),
+        (Direction::Down, IVec2::Y),
+        (Direction::Left, -IVec2::X),
+        (Direction::Right, IVec2::X),
+    ];
+
+    for (dir, expected) in test_cases {
+        assert_eq!(dir.as_ivec2(), expected);
+        assert_eq!(IVec2::from(dir), expected);
+    }
+}

tests/directional.rs

@@ -0,0 +1,55 @@
+use glam::U16Vec2;
+use pacman::entity::direction::Direction;
+use pacman::texture::animated::AnimatedTexture;
+use pacman::texture::directional::DirectionalAnimatedTexture;
+use pacman::texture::sprite::AtlasTile;
+use sdl2::pixels::Color;
+use std::collections::HashMap;
+
+fn mock_atlas_tile(id: u32) -> AtlasTile {
+    AtlasTile {
+        pos: U16Vec2::new(0, 0),
+        size: U16Vec2::new(16, 16),
+        color: Some(Color::RGB(id as u8, 0, 0)),
+    }
+}
+
+fn mock_animated_texture(id: u32) -> AnimatedTexture {
+    AnimatedTexture::new(vec![mock_atlas_tile(id)], 0.1).expect("Invalid frame duration")
+}
+
+#[test]
+fn test_directional_texture_partial_directions() {
+    let mut textures = HashMap::new();
+    textures.insert(Direction::Up, mock_animated_texture(1));
+
+    let texture = DirectionalAnimatedTexture::new(textures, HashMap::new());
+
+    assert_eq!(texture.texture_count(), 1);
+    assert!(texture.has_direction(Direction::Up));
+    assert!(!texture.has_direction(Direction::Down));
+    assert!(!texture.has_direction(Direction::Left));
+    assert!(!texture.has_direction(Direction::Right));
+}
+
+#[test]
+fn test_directional_texture_all_directions() {
+    let mut textures = HashMap::new();
+    let directions = [
+        (Direction::Up, 1),
+        (Direction::Down, 2),
+        (Direction::Left, 3),
+        (Direction::Right, 4),
+    ];
+
+    for (direction, id) in directions {
+        textures.insert(direction, mock_animated_texture(id));
+    }
+
+    let texture = DirectionalAnimatedTexture::new(textures, HashMap::new());
+
+    assert_eq!(texture.texture_count(), 4);
+    for direction in &[Direction::Up, Direction::Down, Direction::Left, Direction::Right] {
+        assert!(texture.has_direction(*direction));
+    }
+}

tests/game.rs

@@ -0,0 +1,21 @@
+use pacman::constants::RAW_BOARD;
+use pacman::map::Map;
+
+#[test]
+fn test_game_map_creation() {
+    let map = Map::new(RAW_BOARD);
+
+    assert!(map.graph.node_count() > 0);
+    assert!(!map.grid_to_node.is_empty());
+
+    // Should find Pac-Man's starting position
+    let pacman_pos = map.find_starting_position(0);
+    assert!(pacman_pos.is_some());
+}
+
+#[test]
+fn test_game_score_initialization() {
+    // This would require creating a full Game instance, but we can test the concept
+    let map = Map::new(RAW_BOARD);
+    assert!(map.find_starting_position(0).is_some());
+}

tests/graph.rs

@@ -0,0 +1,149 @@
+use pacman::entity::direction::Direction;
+use pacman::entity::graph::{EdgePermissions, Graph, Node, Position, Traverser};
+
+fn create_test_graph() -> Graph {
+    let mut graph = Graph::new();
+    let node1 = graph.add_node(Node {
+        position: glam::Vec2::new(0.0, 0.0),
+    });
+    let node2 = graph.add_node(Node {
+        position: glam::Vec2::new(16.0, 0.0),
+    });
+    let node3 = graph.add_node(Node {
+        position: glam::Vec2::new(0.0, 16.0),
+    });
+
+    graph.connect(node1, node2, false, None, Direction::Right).unwrap();
+    graph.connect(node1, node3, false, None, Direction::Down).unwrap();
+
+    graph
+}
+
+#[test]
+fn test_graph_basic_operations() {
+    let mut graph = Graph::new();
+    let node1 = graph.add_node(Node {
+        position: glam::Vec2::new(0.0, 0.0),
+    });
+    let node2 = graph.add_node(Node {
+        position: glam::Vec2::new(16.0, 0.0),
+    });
+
+    assert_eq!(graph.node_count(), 2);
+    assert!(graph.get_node(node1).is_some());
+    assert!(graph.get_node(node2).is_some());
+    assert!(graph.get_node(999).is_none());
+}
+
+#[test]
+fn test_graph_connect() {
+    let mut graph = Graph::new();
+    let node1 = graph.add_node(Node {
+        position: glam::Vec2::new(0.0, 0.0),
+    });
+    let node2 = graph.add_node(Node {
+        position: glam::Vec2::new(16.0, 0.0),
+    });
+
+    assert!(graph.connect(node1, node2, false, None, Direction::Right).is_ok());
+
+    let edge1 = graph.find_edge_in_direction(node1, Direction::Right);
+    let edge2 = graph.find_edge_in_direction(node2, Direction::Left);
+
+    assert!(edge1.is_some());
+    assert!(edge2.is_some());
+    assert_eq!(edge1.unwrap().target, node2);
+    assert_eq!(edge2.unwrap().target, node1);
+}
+
+#[test]
+fn test_graph_connect_errors() {
+    let mut graph = Graph::new();
+    let node1 = graph.add_node(Node {
+        position: glam::Vec2::new(0.0, 0.0),
+    });
+
+    assert!(graph.connect(node1, 999, false, None, Direction::Right).is_err());
+    assert!(graph.connect(999, node1, false, None, Direction::Right).is_err());
+}
+
+#[test]
+fn test_graph_edge_permissions() {
+    let mut graph = Graph::new();
+    let node1 = graph.add_node(Node {
+        position: glam::Vec2::new(0.0, 0.0),
+    });
+    let node2 = graph.add_node(Node {
+        position: glam::Vec2::new(16.0, 0.0),
+    });
+
+    graph
+        .add_edge(node1, node2, false, None, Direction::Right, EdgePermissions::GhostsOnly)
+        .unwrap();
+
+    let edge = graph.find_edge_in_direction(node1, Direction::Right).unwrap();
+    assert_eq!(edge.permissions, EdgePermissions::GhostsOnly);
+}
+
+#[test]
+fn test_traverser_basic() {
+    let graph = create_test_graph();
+    let mut traverser = Traverser::new(&graph, 0, Direction::Left, &|_| true);
+
+    traverser.set_next_direction(Direction::Up);
+    assert!(traverser.next_direction.is_some());
+    assert_eq!(traverser.next_direction.unwrap().0, Direction::Up);
+}
+
+#[test]
+fn test_traverser_advance() {
+    let graph = create_test_graph();
+    let mut traverser = Traverser::new(&graph, 0, Direction::Right, &|_| true);
+
+    traverser.advance(&graph, 5.0, &|_| true);
+
+    match traverser.position {
+        Position::BetweenNodes { from, to, traversed } => {
+            assert_eq!(from, 0);
+            assert_eq!(to, 1);
+            assert_eq!(traversed, 5.0);
+        }
+        _ => panic!("Expected to be between nodes"),
+    }
+
+    traverser.advance(&graph, 3.0, &|_| true);
+
+    match traverser.position {
+        Position::BetweenNodes { from, to, traversed } => {
+            assert_eq!(from, 0);
+            assert_eq!(to, 1);
+            assert_eq!(traversed, 8.0);
+        }
+        _ => panic!("Expected to be between nodes"),
+    }
+}
+
+#[test]
+fn test_traverser_with_permissions() {
+    let mut graph = Graph::new();
+    let node1 = graph.add_node(Node {
+        position: glam::Vec2::new(0.0, 0.0),
+    });
+    let node2 = graph.add_node(Node {
+        position: glam::Vec2::new(16.0, 0.0),
+    });
+
+    graph
+        .add_edge(node1, node2, false, None, Direction::Right, EdgePermissions::GhostsOnly)
+        .unwrap();
+
+    // Pacman can't traverse ghost-only edges
+    let mut traverser = Traverser::new(&graph, node1, Direction::Right, &|edge| {
+        matches!(edge.permissions, EdgePermissions::All)
+    });
+
+    traverser.advance(&graph, 5.0, &|edge| matches!(edge.permissions, EdgePermissions::All));
+
+    // Should still be at the node since it can't traverse
+    assert!(traverser.position.is_at_node());
+}

tests/helpers.rs

@@ -0,0 +1,19 @@
+use glam::{IVec2, UVec2};
+use pacman::helpers::centered_with_size;
+
+#[test]
+fn test_centered_with_size() {
+    let test_cases = [
+        ((100, 100), (50, 30), (75, 85)),
+        ((50, 50), (51, 31), (25, 35)),
+        ((0, 0), (100, 100), (-50, -50)),
+        ((-100, -50), (80, 40), (-140, -70)),
+        ((1000, 1000), (1000, 1000), (500, 500)),
+    ];
+
+    for ((pos_x, pos_y), (size_x, size_y), (expected_x, expected_y)) in test_cases {
+        let rect = centered_with_size(IVec2::new(pos_x, pos_y), UVec2::new(size_x, size_y));
+        assert_eq!(rect.origin(), (expected_x, expected_y));
+        assert_eq!(rect.size(), (size_x, size_y));
+    }
+}

tests/map_builder.rs

@@ -0,0 +1,86 @@
+use glam::Vec2;
+use pacman::constants::{BOARD_CELL_SIZE, CELL_SIZE};
+use pacman::map::Map;
+
+fn create_minimal_test_board() -> [&'static str; BOARD_CELL_SIZE.y as usize] {
+    let mut board = [""; BOARD_CELL_SIZE.y as usize];
+    board[0] = "############################";
+    board[1] = "#............##............#";
+    board[2] = "#.####.#####.##.#####.####.#";
+    board[3] = "#o####.#####.##.#####.####o#";
+    board[4] = "#.####.#####.##.#####.####.#";
+    board[5] = "#..........................#";
+    board[6] = "#.####.##.########.##.####.#";
+    board[7] = "#.####.##.########.##.####.#";
+    board[8] = "#......##....##....##......#";
+    board[9] = "######.##### ## #####.######";
+    board[10] = "     #.##### ## #####.#     ";
+    board[11] = "     #.##    ==    ##.#     ";
+    board[12] = "     #.## ######## ##.#     ";
+    board[13] = "######.## ######## ##.######";
+    board[14] = "T     .   ########   .     T";
+    board[15] = "######.## ######## ##.######";
+    board[16] = "     #.## ######## ##.#     ";
+    board[17] = "     #.##          ##.#     ";
+    board[18] = "     #.## ######## ##.#     ";
+    board[19] = "######.## ######## ##.######";
+    board[20] = "#............##............#";
+    board[21] = "#.####.#####.##.#####.####.#";
+    board[22] = "#.####.#####.##.#####.####.#";
+    board[23] = "#o..##.......X .......##..o#";
+    board[24] = "###.##.##.########.##.##.###";
+    board[25] = "###.##.##.########.##.##.###";
+    board[26] = "#......##....##....##......#";
+    board[27] = "#.##########.##.##########.#";
+    board[28] = "#.##########.##.##########.#";
+    board[29] = "#..........................#";
+    board[30] = "############################";
+    board
+}
+
+#[test]
+fn test_map_creation() {
+    let board = create_minimal_test_board();
+    let map = Map::new(board);
+
+    assert!(map.graph.node_count() > 0);
+    assert!(!map.grid_to_node.is_empty());
+
+    // Check that some connections were made
+    let mut has_connections = false;
+    for intersection in &map.graph.adjacency_list {
+        if intersection.edges().next().is_some() {
+            has_connections = true;
+            break;
+        }
+    }
+    assert!(has_connections);
+}
+
+#[test]
+fn test_map_starting_positions() {
+    let board = create_minimal_test_board();
+    let map = Map::new(board);
+
+    let pacman_pos = map.find_starting_position(0);
+    assert!(pacman_pos.is_some());
+    assert!(pacman_pos.unwrap().x < BOARD_CELL_SIZE.x);
+    assert!(pacman_pos.unwrap().y < BOARD_CELL_SIZE.y);
+
+    let nonexistent_pos = map.find_starting_position(99);
+    assert_eq!(nonexistent_pos, None);
+}
+
+#[test]
+fn test_map_node_positions() {
+    let board = create_minimal_test_board();
+    let map = Map::new(board);
+
+    for (grid_pos, &node_id) in &map.grid_to_node {
+        let node = map.graph.get_node(node_id).unwrap();
+        let expected_pos = Vec2::new((grid_pos.x * CELL_SIZE as i32) as f32, (grid_pos.y * CELL_SIZE as i32) as f32)
+            + Vec2::splat(CELL_SIZE as f32 / 2.0);
+
+        assert_eq!(node.position, expected_pos);
+    }
+}

tests/pacman.rs

@@ -0,0 +1,107 @@
+use pacman::entity::direction::Direction;
+use pacman::entity::graph::{Graph, Node};
+use pacman::entity::pacman::Pacman;
+use pacman::texture::sprite::{AtlasMapper, MapperFrame, SpriteAtlas};
+use sdl2::keyboard::Keycode;
+use std::collections::HashMap;
+
+fn create_test_graph() -> Graph {
+    let mut graph = Graph::new();
+    let node1 = graph.add_node(Node {
+        position: glam::Vec2::new(0.0, 0.0),
+    });
+    let node2 = graph.add_node(Node {
+        position: glam::Vec2::new(16.0, 0.0),
+    });
+    let node3 = graph.add_node(Node {
+        position: glam::Vec2::new(0.0, 16.0),
+    });
+
+    graph.connect(node1, node2, false, None, Direction::Right).unwrap();
+    graph.connect(node1, node3, false, None, Direction::Down).unwrap();
+
+    graph
+}
+
+fn create_test_atlas() -> SpriteAtlas {
+    let mut frames = HashMap::new();
+    let directions = ["up", "down", "left", "right"];
+
+    for (i, dir) in directions.iter().enumerate() {
+        frames.insert(
+            format!("pacman/{dir}_a.png"),
+            MapperFrame {
+                x: i as u16 * 16,
+                y: 0,
+                width: 16,
+                height: 16,
+            },
+        );
+        frames.insert(
+            format!("pacman/{dir}_b.png"),
+            MapperFrame {
+                x: i as u16 * 16,
+                y: 16,
+                width: 16,
+                height: 16,
+            },
+        );
+    }
+
+    frames.insert(
+        "pacman/full.png".to_string(),
+        MapperFrame {
+            x: 64,
+            y: 0,
+            width: 16,
+            height: 16,
+        },
+    );
+
+    let mapper = AtlasMapper { frames };
+    let dummy_texture = unsafe { std::mem::zeroed() };
+    SpriteAtlas::new(dummy_texture, mapper)
+}
+
+#[test]
+fn test_pacman_creation() {
+    let graph = create_test_graph();
+    let atlas = create_test_atlas();
+    let pacman = Pacman::new(&graph, 0, &atlas);
+
+    assert!(pacman.traverser.position.is_at_node());
+    assert_eq!(pacman.traverser.direction, Direction::Left);
+}
+
+#[test]
+fn test_pacman_key_handling() {
+    let graph = create_test_graph();
+    let atlas = create_test_atlas();
+    let mut pacman = Pacman::new(&graph, 0, &atlas);
+
+    let test_cases = [
+        (Keycode::Up, Direction::Up),
+        (Keycode::Down, Direction::Down),
+        (Keycode::Left, Direction::Left),
+        (Keycode::Right, Direction::Right),
+    ];
+
+    for (key, expected_direction) in test_cases {
+        pacman.handle_key(key);
+        assert!(pacman.traverser.next_direction.is_some() || pacman.traverser.direction == expected_direction);
+    }
+}
+
+#[test]
+fn test_pacman_invalid_key() {
+    let graph = create_test_graph();
+    let atlas = create_test_atlas();
+    let mut pacman = Pacman::new(&graph, 0, &atlas);
+
+    let original_direction = pacman.traverser.direction;
+    let original_next_direction = pacman.traverser.next_direction;
+
+    pacman.handle_key(Keycode::Space);
+    assert_eq!(pacman.traverser.direction, original_direction);
+    assert_eq!(pacman.traverser.next_direction, original_next_direction);
+}

tests/parser.rs

@@ -0,0 +1,46 @@
+use pacman::constants::{BOARD_CELL_SIZE, RAW_BOARD};
+use pacman::map::parser::{MapTileParser, ParseError};
+
+#[test]
+fn test_parse_character() {
+    let test_cases = [
+        ('#', pacman::constants::MapTile::Wall),
+        ('.', pacman::constants::MapTile::Pellet),
+        ('o', pacman::constants::MapTile::PowerPellet),
+        (' ', pacman::constants::MapTile::Empty),
+        ('T', pacman::constants::MapTile::Tunnel),
+        ('X', pacman::constants::MapTile::Empty),
+        ('=', pacman::constants::MapTile::Wall),
+    ];
+
+    for (char, _expected) in test_cases {
+        assert!(matches!(MapTileParser::parse_character(char).unwrap(), _expected));
+    }
+
+    assert!(MapTileParser::parse_character('Z').is_err());
+}
+
+#[test]
+fn test_parse_board() {
+    let result = MapTileParser::parse_board(RAW_BOARD);
+    assert!(result.is_ok());
+
+    let parsed = result.unwrap();
+    assert_eq!(parsed.tiles.len(), BOARD_CELL_SIZE.x as usize);
+    assert_eq!(parsed.tiles[0].len(), BOARD_CELL_SIZE.y as usize);
+    assert!(parsed.house_door[0].is_some());
+    assert!(parsed.house_door[1].is_some());
+    assert!(parsed.tunnel_ends[0].is_some());
+    assert!(parsed.tunnel_ends[1].is_some());
+    assert!(parsed.pacman_start.is_some());
+}
+
+#[test]
+fn test_parse_board_invalid_character() {
+    let mut invalid_board = RAW_BOARD.clone();
+    invalid_board[0] = "###########################Z";
+
+    let result = MapTileParser::parse_board(invalid_board);
+    assert!(result.is_err());
+    assert!(matches!(result.unwrap_err(), ParseError::UnknownCharacter('Z')));
+}

tests/sprite.rs

@@ -0,0 +1,78 @@
+use pacman::texture::sprite::{AtlasMapper, MapperFrame, SpriteAtlas};
+use sdl2::pixels::Color;
+use std::collections::HashMap;
+
+fn mock_texture() -> sdl2::render::Texture<'static> {
+    unsafe { std::mem::transmute(0usize) }
+}
+
+#[test]
+fn test_sprite_atlas_basic() {
+    let mut frames = HashMap::new();
+    frames.insert(
+        "test".to_string(),
+        MapperFrame {
+            x: 10,
+            y: 20,
+            width: 32,
+            height: 64,
+        },
+    );
+
+    let mapper = AtlasMapper { frames };
+    let texture = mock_texture();
+    let atlas = SpriteAtlas::new(texture, mapper);
+
+    let tile = atlas.get_tile("test");
+    assert!(tile.is_some());
+    let tile = tile.unwrap();
+    assert_eq!(tile.pos, glam::U16Vec2::new(10, 20));
+    assert_eq!(tile.size, glam::U16Vec2::new(32, 64));
+    assert_eq!(tile.color, None);
+}
+
+#[test]
+fn test_sprite_atlas_multiple_tiles() {
+    let mut frames = HashMap::new();
+    frames.insert(
+        "tile1".to_string(),
+        MapperFrame {
+            x: 0,
+            y: 0,
+            width: 32,
+            height: 32,
+        },
+    );
+    frames.insert(
+        "tile2".to_string(),
+        MapperFrame {
+            x: 32,
+            y: 0,
+            width: 64,
+            height: 64,
+        },
+    );
+
+    let mapper = AtlasMapper { frames };
+    let texture = mock_texture();
+    let atlas = SpriteAtlas::new(texture, mapper);
+
+    assert_eq!(atlas.tiles_count(), 2);
+    assert!(atlas.has_tile("tile1"));
+    assert!(atlas.has_tile("tile2"));
+    assert!(!atlas.has_tile("tile3"));
+    assert!(atlas.get_tile("nonexistent").is_none());
+}
+
+#[test]
+fn test_sprite_atlas_color() {
+    let mapper = AtlasMapper { frames: HashMap::new() };
+    let texture = mock_texture();
+    let mut atlas = SpriteAtlas::new(texture, mapper);
+
+    assert_eq!(atlas.default_color(), None);
+
+    let color = Color::RGB(255, 0, 0);
+    atlas.set_color(color);
+    assert_eq!(atlas.default_color(), Some(color));
+}

web.build.ts

@@ -0,0 +1,262 @@
+import { $ } from "bun";
+import { existsSync, promises as fs } from "fs";
+import { platform } from "os";
+import { dirname, join, relative, resolve } from "path";
+import { match, P } from "ts-pattern";
+
+type Os =
+  | { type: "linux"; wsl: boolean }
+  | { type: "windows" }
+  | { type: "macos" };
+
+const os: Os = match(platform())
+  .with("win32", () => ({ type: "windows" as const }))
+  .with("linux", () => ({
+    type: "linux" as const,
+    // We detect WSL by checking for the presence of the WSLInterop file.
+    // This is a semi-standard method of detecting WSL, which is more than workable for this already hacky script.
+    wsl: existsSync("/proc/sys/fs/binfmt_misc/WSLInterop"),
+  }))
+  .with("darwin", () => ({ type: "macos" as const }))
+  .otherwise(() => {
+    throw new Error(`Unsupported platform: ${platform()}`);
+  });
+
+function log(msg: string) {
+  console.log(`[web.build] ${msg}`);
+}
+
+/**
+ * Build the application with Emscripten, generate the CSS, and copy the files into 'dist'.
+ *
+ * @param release - Whether to build in release mode.
+ * @param env - The environment variables to inject into build commands.
+ */
+async function build(release: boolean, env: Record<string, string>) {
+  log(
+    `Building for 'wasm32-unknown-emscripten' for ${
+      release ? "release" : "debug"
+    }`
+  );
+  await $`cargo build --target=wasm32-unknown-emscripten ${
+    release ? "--release" : ""
+  }`.env(env);
+
+  log("Invoking @tailwindcss/cli");
+  // unfortunately, bunx doesn't seem to work with @tailwindcss/cli, so we have to use npx directly
+  await $`npx --yes @tailwindcss/cli --minify --input styles.css --output build.css --cwd assets/site`;
+
+  const buildType = release ? "release" : "debug";
+  const siteFolder = resolve("assets/site");
+  const outputFolder = resolve(`target/wasm32-unknown-emscripten/${buildType}`);
+  const dist = resolve("dist");
+
+  // The files to copy into 'dist'
+  const files = [
+    ...["index.html", "favicon.ico", "build.css", "TerminalVector.ttf"].map(
+      (file) => ({
+        src: join(siteFolder, file),
+        dest: join(dist, file),
+        optional: false,
+      })
+    ),
+    ...["pacman.wasm", "pacman.js", "deps/pacman.data"].map((file) => ({
+      src: join(outputFolder, file),
+      dest: join(dist, file.split("/").pop() || file),
+      optional: false,
+    })),
+    {
+      src: join(outputFolder, "pacman.wasm.map"),
+      dest: join(dist, "pacman.wasm.map"),
+      optional: true,
+    },
+  ];
+
+  // Create required destination folders
+  await Promise.all(
+    // Get the dirname of files, remove duplicates
+    [...new Set(files.map(({ dest }) => dirname(dest)))]
+      // Create the folders
+      .map(async (dir) => {
+        // If the folder doesn't exist, create it
+        if (!(await fs.exists(dir))) {
+          log(`Creating folder ${dir}`);
+          await fs.mkdir(dir, { recursive: true });
+        }
+      })
+  );
+
+  // Copy the files to the dist folder
+  log("Copying files into dist");
+  await Promise.all(
+    files.map(async ({ optional, src, dest }) => {
+      match({ optional, exists: await fs.exists(src) })
+        // If optional and doesn't exist, skip
+        .with({ optional: true, exists: false }, () => {
+          log(
+            `Optional file ${os.type === "windows" ? "\\" : "/"}${relative(
+              process.cwd(),
+              src
+            )} does not exist, skipping...`
+          );
+        })
+        // If not optional and doesn't exist, throw an error
+        .with({ optional: false, exists: false }, () => {
+          throw new Error(`Required file ${src} does not exist`);
+        })
+        // Otherwise, copy the file
+        .otherwise(async () => await fs.copyFile(src, dest));
+    })
+  );
+}
+
+/**
+ * Checks to see if the Emscripten SDK is activated for a Windows or *nix machine by looking for a .exe file and the equivalent file on Linux/macOS. Returns both results for handling.
+ * @param emsdkDir - The directory containing the Emscripten SDK.
+ * @returns A record of environment variables.
+ */
+async function checkEmsdkType(
+  emsdkDir: string
+): Promise<{ windows: boolean; nix: boolean }> {
+  const binary = resolve(join(emsdkDir, "upstream", "bin", "clang"));
+
+  return {
+    windows: await fs.exists(binary + ".exe"),
+    nix: await fs.exists(binary),
+  };
+}
+
+/**
+ * Activate the Emscripten SDK environment variables.
+ * Technically, this doesn't actaully activate the environment variables for the current shell,
+ * it just runs the environment sourcing script and returns the environment variables for future command invocations.
+ * @param emsdkDir - The directory containing the Emscripten SDK.
+ * @returns A record of environment variables.
+ */
+async function activateEmsdk(
+  emsdkDir: string
+): Promise<{ vars: Record<string, string> } | { err: string }> {
+  // Determine the environment script to use based on the OS
+  const envScript = match(os)
+    .with({ type: "windows" }, () => join(emsdkDir, "emsdk_env.bat"))
+    .with({ type: P.union("linux", "macos") }, () =>
+      join(emsdkDir, "emsdk_env.sh")
+    )
+    .exhaustive();
+
+  // Run the environment script and capture the output
+  const { stdout, stderr, exitCode } = await match(os)
+    .with({ type: "windows" }, () =>
+      // run the script, ignore it's output ('>nul'), then print the environment variables ('set')
+      $`cmd /c "${envScript} >nul && set"`.quiet()
+    )
+    .with({ type: P.union("linux", "macos") }, () =>
+      // run the script with bash, ignore it's output ('> /dev/null'), then print the environment variables ('env')
+      $`bash -c "source '${envScript}' && env"`.quiet()
+    )
+    .exhaustive();
+
+  if (exitCode !== 0) {
+    return { err: stderr.toString() };
+  }
+
+  // Parse the output into a record of environment variables
+  const vars = Object.fromEntries(
+    stdout
+      .toString()
+      .split(os.type === "windows" ? /\r?\n/ : "\n") // Split output into lines, handling Windows CRLF vs *nix LF
+      .map((line) => line.split("=", 2)) // Parse each line as KEY=VALUE (limit to 2 parts)
+      .filter(([k, v]) => k && v) // Keep only valid key-value pairs (both parts exist)
+  );
+
+  return { vars };
+}
+
+async function main() {
+  // Print the OS detected
+  log(
+    "OS Detected: " +
+      match(os)
+        .with({ type: "windows" }, () => "Windows")
+        .with({ type: "linux" }, ({ wsl: isWsl }) =>
+          isWsl ? "Linux (via WSL)" : "Linux"
+        )
+        .with({ type: "macos" }, () => "macOS")
+        .exhaustive()
+  );
+
+  const release = process.env.RELEASE !== "0";
+  const emsdkDir = resolve("./emsdk");
+  // Ensure the emsdk directory exists before attempting to activate or use it
+  if (!(await fs.exists(emsdkDir))) {
+    log(
+      `Emscripten SDK directory not found at ${emsdkDir}. Please install or clone 'emsdk' and try again.`
+    );
+    process.exit(1);
+  }
+  const vars = match(await activateEmsdk(emsdkDir)) // result handling
+    .with({ vars: P.select() }, (vars) => vars)
+    .with({ err: P.any }, ({ err }) => {
+      log("Error activating Emscripten SDK: " + err);
+      process.exit(1);
+    })
+    .exhaustive();
+
+  // Check if the Emscripten SDK is activated/installed properly for the current OS
+  match({
+    os: os,
+    ...(await checkEmsdkType(emsdkDir)),
+  })
+    // If the Emscripten SDK is not activated/installed properly, exit with an error
+    .with(
+      {
+        nix: false,
+        windows: false,
+      },
+      () => {
+        log(
+          "Emscripten SDK does not appear to be activated/installed properly."
+        );
+        process.exit(1);
+      }
+    )
+    // If the Emscripten SDK is activated for Windows, but is currently running on a *nix OS, exit with an error
+    .with(
+      {
+        nix: false,
+        windows: true,
+        os: { type: P.not("windows") },
+      },
+      () => {
+        log(
+          "Emscripten SDK appears to be activated for Windows, but is currently running on a *nix OS."
+        );
+        process.exit(1);
+      }
+    )
+    // If the Emscripten SDK is activated for *nix, but is currently running on a Windows OS, exit with an error
+    .with(
+      {
+        nix: true,
+        windows: false,
+        os: { type: "windows" },
+      },
+      () => {
+        log(
+          "Emscripten SDK appears to be activated for *nix, but is currently running on a Windows OS."
+        );
+        process.exit(1);
+      }
+    );
+
+  // Build the application
+  await build(release, vars);
+}
+
+/**
+ * Main entry point.
+ */
+main().catch((err) => {
+  console.error("[web.build] Error:", err);
+  process.exit(1);
+});