fix: use sdl2 internal methods for loading resources for emscripten asset handling

ci: fix vcpkg cache keys to use target for platforms with multiple targets, allow restore oldkey
ci: install zlib for linux builds, correct deps/.data filepath
2025-12-06 07:15:41 -06:00 · 2025-07-24 01:07:22 -05:00 · 2025-07-24 01:04:21 -05:00 · 2025-07-24 01:04:21 -05:00 · 2025-07-24 00:49:22 -05:00 · 2025-07-24 00:48:49 -05:00
50 changed files with 737 additions and 836 deletions
--- a/.cargo/config.toml
+++ b/.cargo/config.toml
@@ -8,5 +8,5 @@ rustflags = [
    # "-C", "link-args=-sALLOW_MEMORY_GROWTH=1",
    "-C", "link-args=-sUSE_SDL=2 -sUSE_SDL_IMAGE=2 -sUSE_SDL_MIXER=2 -sUSE_OGG=1 -sUSE_SDL_GFX=2 -sUSE_SDL_TTF=2 -sSDL2_IMAGE_FORMATS=['png']",
    # USE_OGG, USE_VORBIS for OGG/VORBIS usage
-    "-C", "link-args=--preload-file assets/",
-]
+    "-C", "link-args=--preload-file assets/game/",
+]
--- a/.gitattributes
+++ b/.gitattributes
@@ -0,0 +1 @@
+* text=auto eol=lf
--- a/.github/workflows/build.yaml
+++ b/.github/workflows/build.yaml
@@ -0,0 +1,136 @@
+name: Build
+
+on: [push]
+
+permissions:
+  contents: write
+
+env:
+  RUST_TOOLCHAIN: 1.86.0
+
+jobs:
+  build:
+    name: Build (${{ matrix.target }})
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-latest
+            target: x86_64-unknown-linux-gnu
+            artifact_name: pacman
+          - os: macos-13
+            target: x86_64-apple-darwin
+            artifact_name: pacman
+          - os: macos-latest
+            target: aarch64-apple-darwin
+            artifact_name: pacman
+          - os: windows-latest
+            target: x86_64-pc-windows-gnu
+            artifact_name: pacman.exe
+    runs-on: ${{ matrix.os }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Rust Toolchain
+        uses: dtolnay/rust-toolchain@master
+        with:
+          target: ${{ matrix.target }}
+          toolchain: ${{ env.RUST_TOOLCHAIN }}
+
+      - name: Rust Cache
+        uses: Swatinem/rust-cache@v2
+
+      - name: Cache vcpkg
+        uses: actions/cache@v4
+        with:
+          path: target/vcpkg
+          key: vcpkg-${{ runner.os }}-${{ matrix.target }}-${{ hashFiles('Cargo.toml', 'Cargo.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-vcpkg
+            vcpkg-${{ runner.os }}-${{ matrix.target }}-
+
+      - name: Vcpkg Linux Dependencies
+        if: runner.os == 'Linux'
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y build-essential gettext libltdl-dev zlib1g-dev
+
+      - name: Vcpkg
+        run: |
+          cargo install cargo-vcpkg
+          cargo vcpkg -v build
+
+      - name: Build
+        run: cargo build --release
+
+      - name: Acquire Package Version
+        shell: bash
+        run: |
+          PACKAGE_VERSION=$(cargo metadata --format-version 1 --no-deps | jq '.packages[0].version' -r)
+          echo "PACKAGE_VERSION=${PACKAGE_VERSION}" >> $GITHUB_ENV
+
+      - name: Upload Artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: "pacman-${{ env.PACKAGE_VERSION }}-${{ matrix.target }}"
+          path: ./target/release/${{ matrix.artifact_name }}
+          retention-days: 7
+          if-no-files-found: error
+
+  wasm:
+    name: Build (wasm32-unknown-emscripten)
+    runs-on: ubuntu-latest
+    permissions:
+      pages: write
+      id-token: write
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Emscripten SDK
+        uses: mymindstorm/setup-emsdk@v14
+        with:
+          version: 3.1.43
+          actions-cache-folder: "emsdk-cache"
+
+      - name: Setup Rust (WASM32 Emscripten)
+        uses: dtolnay/rust-toolchain@master
+        with:
+          target: wasm32-unknown-emscripten
+          toolchain: ${{ env.RUST_TOOLCHAIN }}
+
+      - name: Rust Cache
+        uses: Swatinem/rust-cache@v2
+
+      - name: Install pnpm
+        uses: pnpm/action-setup@v3
+        with:
+          version: 8
+          run_install: true
+
+      - name: Build with Emscripten
+        run: |
+          cargo build --target=wasm32-unknown-emscripten --release
+
+      - name: Assemble
+        run: |
+          echo "Generating CSS"
+          pnpx postcss-cli ./assets/site/styles.scss -o ./assets/site/build.css
+
+          echo "Copying WASM files"
+
+          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
+
+      - name: Upload Artifact
+        uses: actions/upload-pages-artifact@v3
+        with:
+          path: "./dist/"
+          retention-days: 7
+
+      - name: Deploy
+        uses: actions/deploy-pages@v4
--- a/.github/workflows/deploy.yaml
+++ b/.github/workflows/deploy.yaml
@@ -1,225 +0,0 @@
-name: Build
-
-on: [push]
-
-permissions:
-  contents: write
-
-jobs:
-  wasm:
-    runs-on: ubuntu-latest
-
-    permissions:
-      pages: write
-      id-token: write
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Setup Emscripten SDK
-        uses: mymindstorm/setup-emsdk@v14
-        with:
-          version: 3.1.43
-
-      - name: Setup Rust (WASM32 Emscripten)
-        uses: dtolnay/rust-toolchain@stable
-        with:
-          target: wasm32-unknown-emscripten
-
-      - name: Rust Cache
-        uses: Swatinem/rust-cache@v2
-
-      - name: Install pnpm
-        uses: pnpm/action-setup@v3
-        with:
-          version: 8
-          run_install: true
-
-      - name: Build
-        run: ./scripts/build.sh -er # release mode, skip emsdk
-
-      - name: Upload Artifact
-        uses: actions/upload-pages-artifact@v3
-        with:
-          path: "./dist/"
-          retention-days: 7
-
-      - name: Deploy
-        uses: actions/deploy-pages@v4
-
-  linux:
-    runs-on: ubuntu-latest
-    env:
-      TARGET: x86_64-unknown-linux-gnu
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Install SDL2 Packages
-        run: sudo apt-get install libsdl2-dev libsdl2-image-dev libsdl2-mixer-dev libsdl2-ttf-dev libsdl2-gfx-dev
-
-      - name: Setup Rust Toolchain (Linux)
-        uses: dtolnay/rust-toolchain@stable
-        with:
-          target: ${{ env.TARGET }}
-
-      - name: Rust Cache
-        uses: Swatinem/rust-cache@v2
-
-      - name: Build
-        run: cargo build --release
-
-      - name: Assemble Archive
-        run: |
-          mkdir /tmp/example/
-          cp ./target/release/pacman /tmp/example/
-          chmod a+x /tmp/example/pacman
-          mkdir /tmp/example/assets
-          cp ./assets/TerminalVector.ttf ./assets/fruit.png /tmp/example/assets
-
-      - name: Install Cargo Binstall
-        uses: cargo-bins/cargo-binstall@main
-
-      - name: Acquire Package Version
-        run: |
-          cargo binstall toml-cli -y
-          PACKAGE_VERSION=$(toml get ./Cargo.toml package.version --raw)
-          echo "PACKAGE_VERSION=${PACKAGE_VERSION}" >> $GITHUB_ENV
-
-      - name: Upload Artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: "pacman-${{ env.PACKAGE_VERSION }}-${{ env.TARGET }}"
-          path: /tmp/example/
-          retention-days: 7
-          if-no-files-found: error
-
-  macos:
-    runs-on: macos-13
-    env:
-      TARGET: x86_64-apple-darwin
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Install SDL2 Packages
-        run: brew install sdl2 sdl2_image sdl2_mixer sdl2_ttf sdl2_gfx
-
-      - name: Setup Rust Toolchain (MacOS)
-        uses: dtolnay/rust-toolchain@stable
-        with:
-          target: ${{ env.TARGET }}
-
-      - name: Rust Cache
-        uses: Swatinem/rust-cache@v2
-
-      - name: Build
-        run: cargo build --release
-
-      - name: Assemble Archive
-        run: |
-          mkdir /tmp/example/
-          cp ./target/release/pacman /tmp/example/
-          mkdir /tmp/example/assets
-          cp ./assets/TerminalVector.ttf ./assets/fruit.png /tmp/example/assets
-
-      - name: Install Cargo Binstall
-        uses: cargo-bins/cargo-binstall@main
-
-      - name: Acquire Package Version
-        run: |
-          cargo binstall toml-cli -y
-          PACKAGE_VERSION=$(toml get ./Cargo.toml package.version --raw)
-          echo "PACKAGE_VERSION=${PACKAGE_VERSION}" >> $GITHUB_ENV
-
-      - name: Upload Artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: "pacman-${{ env.PACKAGE_VERSION }}-${{ env.TARGET }}"
-          path: /tmp/example/
-          retention-days: 7
-          if-no-files-found: error
-
-  windows:
-    env:
-      TARGET: x86_64-pc-windows-gnu
-      SDL2: 2.30.2
-      SDL2_TTF: 2.22.0
-      SDL2_MIXER: 2.8.0
-      SDL2_IMAGE: 2.8.2
-      # SDL2_GFX: 1.0.4
-    runs-on: windows-latest
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Download SDL2 Libraries
-        run: |
-          curl -L "https://github.com/libsdl-org/SDL/releases/download/release-${{ env.SDL2 }}/SDL2-devel-${{ env.SDL2 }}-VC.zip" -o "sdl2_devel.zip"
-          curl -L "https://github.com/libsdl-org/SDL_mixer/releases/download/release-${{ env.SDL2_MIXER }}/SDL2_mixer-devel-${{ env.SDL2_MIXER }}-VC.zip" -o "sdl2_mixer_devel.zip"
-          curl -L "https://github.com/libsdl-org/SDL_ttf/releases/download/release-${{ env.SDL2_TTF }}/SDL2_ttf-devel-${{ env.SDL2_TTF }}-VC.zip" -o "sdl2_ttf_devel.zip"
-          curl -L "https://github.com/libsdl-org/SDL_image/releases/download/release-${{ env.SDL2_IMAGE }}/SDL2_image-devel-${{ env.SDL2_IMAGE }}-VC.zip" -o "sdl2_image_devel.zip"
-
-      - name: Extract SDL2 DLLs
-        run: |
-          7z x ./sdl2_devel.zip -o"./tmp/"
-          mv ./tmp/SDL2-${{ env.SDL2 }}/lib/x64/SDL2.dll ./
-          mv ./tmp/SDL2-${{ env.SDL2 }}/lib/x64/SDL2.lib ./
-
-          7z x ./sdl2_mixer_devel.zip -o"./tmp/"
-          mv ./tmp/SDL2_mixer-${{ env.SDL2_MIXER }}/lib/x64/SDL2_mixer.dll ./
-          mv ./tmp/SDL2_mixer-${{ env.SDL2_MIXER }}/lib/x64/SDL2_mixer.lib ./
-
-          7z x ./sdl2_ttf_devel.zip -o"./tmp/"
-          mv ./tmp/SDL2_ttf-${{ env.SDL2_TTF }}/lib/x64/SDL2_ttf.dll ./
-          mv ./tmp/SDL2_ttf-${{ env.SDL2_TTF }}/lib/x64/SDL2_ttf.lib ./
-
-          7z x ./sdl2_image_devel.zip -o"./tmp/"
-          mv ./tmp/SDL2_image-${{ env.SDL2_IMAGE }}/lib/x64/SDL2_image.dll ./
-          mv ./tmp/SDL2_image-${{ env.SDL2_IMAGE }}/lib/x64/SDL2_image.lib ./
-
-      - name: Install SDL2_gfx
-        run: |
-          C:\vcpkg\vcpkg.exe install sdl2-gfx:x64-windows-release
-          cp C:\vcpkg\packages\sdl2-gfx_x64-windows-release\bin\SDL2_gfx.dll ./
-          cp C:\vcpkg\packages\sdl2-gfx_x64-windows-release\lib\SDL2_gfx.lib ./
-
-      - name: Setup Rust (Windows)
-        uses: dtolnay/rust-toolchain@stable
-        with:
-          targets: ${{ env.TARGET }}
-
-      - name: Rust Cache
-        uses: Swatinem/rust-cache@v2
-
-      - name: Build
-        run: cargo build --release
-
-      - name: Prepare Archive
-        run: |
-          New-Item -Type Directory ./release/
-          Move-Item -Path ./target/release/pacman.exe -Destination ./release/
-          Move-Item -Path ./SDL2.dll, ./SDL2_image.dll, ./SDL2_ttf.dll, ./SDL2_mixer.dll, ./SDL2_gfx.dll -Destination ./release/
-          New-Item -Type Directory ./release/assets/
-          Move-Item -Path ./assets/TerminalVector.ttf, ./assets/fruit.png -Destination ./release/assets/
-
-      - name: Install Cargo Binstall
-        uses: cargo-bins/cargo-binstall@main
-
-      - name: Acquire Package Version
-        run: |
-          cargo binstall toml-cli -y
-          PACKAGE_VERSION=$(toml get ./Cargo.toml package.version --raw)
-          echo "PACKAGE_VERSION=${PACKAGE_VERSION}" >> $env:GITHUB_ENV
-
-      - name: Upload Artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: "pacman-${{ env.PACKAGE_VERSION }}-${{ env.TARGET }}"
-          path: ./release/
-          retention-days: 7
-          if-no-files-found: error
--- a/.gitignore
+++ b/.gitignore
@@ -3,5 +3,5 @@
 .idea
 *.dll
 rust-sdl2-emscripten/
-assets/build.css
-emsdk/
+assets/site/build.css
+emsdk/
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -0,0 +1,22 @@
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v5.0.0
+    hooks:
+      - id: trailing-whitespace
+      - id: end-of-file-fixer
+      - id: check-added-large-files
+      - id: check-merge-conflict
+      - id: check-case-conflict
+      - id: check-toml
+      - id: check-yaml
+      - id: forbid-submodules
+      - id: mixed-line-ending
+
+  - repo: local
+    hooks:
+      - id: cargo-fmt
+        name: cargo fmt
+        entry: cargo fmt --all --
+        language: system
+        types: [rust]
+        pass_filenames: false
--- a/BUILD.md
+++ b/BUILD.md
@@ -1,7 +0,0 @@
-# Building Pac-Man
-
-## GitHub Actions Workflow
-
-1. Build workflow produces executables & WASM files for all platforms
-2. Uploaded as artifacts
-3. Deployment workflow downloads artifacts and uploads to GitHub Pages
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -11,6 +11,12 @@ dependencies = [
 "memchr",
 ]

+[[package]]
+name = "anyhow"
+version = "1.0.98"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e16d2d3311acee920a9eb8d33b8cbc1787ce4a264e85f964c2404b969bdcd487"
+
 [[package]]
 name = "autocfg"
 version = "1.5.0"
@@ -71,6 +77,12 @@ dependencies = [
 "wasi",
 ]

+[[package]]
+name = "glam"
+version = "0.30.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50a99dbe56b72736564cfa4b85bf9a33079f16ae8b74983ab06af3b1a3696b11"
+
 [[package]]
 name = "hashbrown"
 version = "0.15.4"
@@ -150,9 +162,9 @@ dependencies = [

 [[package]]
 name = "once_cell"
-version = "1.18.0"
+version = "1.21.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd8b5dd2ae5ed71462c540258bedcb51965123ad7e7ccf4b9a8cafaa4a63576d"
+checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"

 [[package]]
 name = "overload"
@@ -164,12 +176,16 @@ checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39"
 name = "pacman"
 version = "0.1.0"
 dependencies = [
+ "anyhow",
+ "glam",
 "lazy_static",
 "libc",
+ "once_cell",
 "pathfinding",
 "rand",
 "sdl2",
 "spin_sleep",
+ "thiserror 1.0.69",
 "tracing",
 "tracing-error",
 "tracing-subscriber",
@@ -187,7 +203,7 @@ dependencies = [
 "integer-sqrt",
 "num-traits",
 "rustc-hash",
- "thiserror",
+ "thiserror 2.0.12",
 ]

 [[package]]
@@ -374,13 +390,33 @@ dependencies = [
 "unicode-ident",
 ]

+[[package]]
+name = "thiserror"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
+dependencies = [
+ "thiserror-impl 1.0.69",
+]
+
 [[package]]
 name = "thiserror"
 version = "2.0.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "567b8a2dae586314f7be2a752ec7474332959c6460e02bde30d702a66d488708"
 dependencies = [
- "thiserror-impl",
+ "thiserror-impl 2.0.12",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
 ]

 [[package]]
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -14,6 +14,10 @@ sdl2 = { version = "0.38.0", features = ["image", "ttf"] }
 spin_sleep = "1.3.2"
 rand = "0.9.2"
 pathfinding = "4.14"
+once_cell = "1.21.3"
+thiserror = "1.0"
+anyhow = "1.0"
+glam = "0.30.4"

 [target.'cfg(target_os = "windows")'.dependencies.winapi]
 version = "0.3"
@@ -31,13 +35,15 @@ default-features = false
 features = ["ttf","image","gfx","mixer","static-link","use-vcpkg"]

 [package.metadata.vcpkg]
-dependencies = ["sdl2", "sdl2-image[libjpeg-turbo,tiff,libwebp]", "sdl2-ttf", "sdl2-gfx", "sdl2-mixer"]
+dependencies = ["sdl2", "sdl2-image", "sdl2-ttf", "sdl2-gfx", "sdl2-mixer"]
 git = "https://github.com/microsoft/vcpkg"
 rev = "2024.05.24" # release 2024.05.24 # to check for a new one, check https://github.com/microsoft/vcpkg/releases

 [package.metadata.vcpkg.target]
 x86_64-pc-windows-msvc = { triplet = "x64-windows-static-md" }
-stable-x86_64-unknown-linux-gnu = { triplet = "x86_64-unknown-linux-gnu" }
+x86_64-unknown-linux-gnu = { triplet = "x64-linux" }
+x86_64-apple-darwin = { triplet = "x64-osx" }
+aarch64-apple-darwin = { triplet = "arm64-osx" }

 [target.'cfg(target_os = "emscripten")'.dependencies]
 libc = "0.2.16"
--- a/IMPLEMENTATION.md
+++ b/IMPLEMENTATION.md
@@ -1,35 +0,0 @@
-# Implementation
-
-A document detailing the implementation the project from rendering, to game logic, to build systems.
-
-## Rendering
-
-1. Map
-    - May require procedural text generation later on (cacheable?)
-2. Pacman
-3. Ghosts
-    - Requires colors
-4. Items
-5. Interface
-    - Requires fonts
-
-## Grid System
-
-1. How does the grid system work?
-
-The grid is 28 x 36 (although, the map texture is 28 x 37), and each cell is 24x24 (pixels).
-Many of the walls in the map texture only occupy a portion of the cell, so some items are able to render across multiple cells.
-24x24 assets include pellets, the energizer, and the map itself ()
-
-2. What constraints must be enforced on Ghosts and PacMan?
-
-3. How do movement transitions work?
-
-All entities store a precise position, and a direction. This position is only used for animation, rendering, and collision purposes. Otherwise, a separate 'cell position' (which is 24 times less precise, owing to the fact that it is based on the entity's position within the grid).
-
-When an entity is transitioning between cells, movement directions are acknowledged, but won't take effect until the next cell has been entered completely.
-
-4. Between transitions, how does collision detection work?
-
-It appears the original implementation used cell-level detection.
-I worry this may be prone to division errors. Make sure to use rounding (50% >=).
--- a/assets/game/24/energizer.png
+++ b/assets/game/24/energizer.png
--- a/assets/game/24/pellet.png
+++ b/assets/game/24/pellet.png
--- a/assets/game/32/fruit.png
+++ b/assets/game/32/fruit.png
--- a/assets/game/32/game_over.png
+++ b/assets/game/32/game_over.png
--- a/assets/game/32/ghost_body.png
+++ b/assets/game/32/ghost_body.png
--- a/assets/game/32/ghost_eyes.png
+++ b/assets/game/32/ghost_eyes.png
--- a/assets/game/32/life.png
+++ b/assets/game/32/life.png
--- a/assets/game/32/pacman.png
+++ b/assets/game/32/pacman.png
--- a/assets/game/door.png
+++ b/assets/game/door.png
--- a/assets/game/font/konami.ttf
+++ b/assets/game/font/konami.ttf
--- a/assets/game/map.png
+++ b/assets/game/map.png
--- a/assets/game/wav/1.ogg
+++ b/assets/game/wav/1.ogg
--- a/assets/game/wav/2.ogg
+++ b/assets/game/wav/2.ogg
--- a/assets/game/wav/3.ogg
+++ b/assets/game/wav/3.ogg
--- a/assets/game/wav/4.ogg
+++ b/assets/game/wav/4.ogg
--- a/assets/site/TerminalVector.ttf
+++ b/assets/site/TerminalVector.ttf
--- a/assets/site/build.css
+++ b/assets/site/build.css
@@ -0,0 +1,23 @@
+@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= */
--- a/assets/site/favicon.ico
+++ b/assets/site/favicon.ico
--- a/assets/site/index.html
+++ b/assets/site/index.html
--- a/assets/site/styles.scss
+++ b/assets/site/styles.scss
--- a/assets/wav/eating.wav
+++ b/assets/wav/eating.wav
--- a/assets/wav/waka_ka.wav
+++ b/assets/wav/waka_ka.wav
--- a/assets/wav/waka_wa.wav
+++ b/assets/wav/waka_wa.wav
--- a/build.sh
+++ b/build.sh
@@ -52,20 +52,18 @@ else
 fi

 echo "Generating CSS"
-pnpx postcss-cli ./assets/styles.scss -o ./assets/build.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/index.html dist

-# cp assets/*.woff* dist
-cp assets/build.css dist
-cp assets/favicon.ico dist
-cp $output_folder/pacman.wasm dist
-cp $output_folder/pacman.js dist
-# only if .data file exists
-cp $output_folder/deps/pacman.data dist
+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
--- a/build.ts
+++ b/build.ts
@@ -56,40 +56,47 @@ async function setupEmscripten() {

 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 $`cargo build --target=wasm32-unknown-emscripten --release`;
+    await $`env RUSTFLAGS=${rustcFlags} cargo build --target=wasm32-unknown-emscripten --release`;
  } else {
-    await $`cargo build --target=wasm32-unknown-emscripten`;
+    await $`env RUSTFLAGS=${rustcFlags} cargo build --target=wasm32-unknown-emscripten`;
  }

  console.log("Generating CSS...");
-  await $`pnpx postcss-cli ./assets/styles.scss -o ./assets/build.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/index.html dist`;
-  await $`cp assets/*.woff* dist`;
-  await $`cp assets/build.css dist`;
-  await $`cp assets/favicon.ico dist`;
-  await $`cp ${outputFolder}/spiritus.wasm dist`;
-  await $`cp ${outputFolder}/spiritus.js 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}/deps/spiritus.data`);
-    await $`cp ${outputFolder}/deps/spiritus.data dist`;
+    await fs.access(`${outputFolder}/pacman.data`);
+    await $`cp ${outputFolder}/pacman.data dist`;
  } catch (e) {
-    console.log("No spiritus.data file found, skipping copy.");
+    console.log("No pacman.data file found, skipping copy.");
  }

  // Check if .map file exists before copying
  try {
-    await fs.access(`${outputFolder}/spiritus.wasm.map`);
-    await $`cp ${outputFolder}/spiritus.wasm.map dist`;
+    await fs.access(`${outputFolder}/pacman.wasm.map`);
+    await $`cp ${outputFolder}/pacman.wasm.map dist`;
  } catch (e) {
-    console.log("No spiritus.wasm.map file found, skipping copy.");
+    console.log("No pacman.wasm.map file found, skipping copy.");
  }

  console.log("WASM files copied.");
--- a/rustfmt.toml
+++ b/rustfmt.toml
@@ -0,0 +1,6 @@
+# Rustfmt configuration
+edition = "2021"
+max_width = 130
+tab_spaces = 4
+newline_style = "Unix"
+use_small_heuristics = "Default"
--- a/src/animation.rs
+++ b/src/animation.rs
@@ -9,13 +9,7 @@ use crate::direction::Direction;

 /// Trait for drawable atlas-based textures
 pub trait FrameDrawn {
-    fn render(
-        &self,
-        canvas: &mut Canvas<Window>,
-        position: (i32, i32),
-        direction: Direction,
-        frame: Option<u32>,
-    );
+    fn render(&self, canvas: &mut Canvas<Window>, position: (i32, i32), direction: Direction, frame: Option<u32>);
 }

 /// A texture atlas abstraction for static (non-animated) rendering.
@@ -28,13 +22,7 @@ pub struct AtlasTexture<'a> {
 }

 impl<'a> AtlasTexture<'a> {
-    pub fn new(
-        texture: Texture<'a>,
-        frame_count: u32,
-        frame_width: u32,
-        frame_height: u32,
-        offset: Option<(i32, i32)>,
-    ) -> Self {
+    pub fn new(texture: Texture<'a>, frame_count: u32, frame_width: u32, frame_height: u32, offset: Option<(i32, i32)>) -> Self {
        AtlasTexture {
            raw_texture: texture,
            frame_count,
@@ -62,13 +50,7 @@ impl<'a> AtlasTexture<'a> {
 }

 impl<'a> FrameDrawn for AtlasTexture<'a> {
-    fn render(
-        &self,
-        canvas: &mut Canvas<Window>,
-        position: (i32, i32),
-        direction: Direction,
-        frame: Option<u32>,
-    ) {
+    fn render(&self, canvas: &mut Canvas<Window>, position: (i32, i32), direction: Direction, frame: Option<u32>) {
        let texture_source_frame_rect = self.get_frame_rect(frame.unwrap_or(0));
        let canvas_destination_rect = Rect::new(
            position.0 + self.offset.0,
@@ -141,29 +123,13 @@ impl<'a> AnimatedAtlasTexture<'a> {
        }
    }

-    pub fn pause(&mut self) {
-        self.paused = true;
-    }
-    pub fn resume(&mut self) {
-        self.paused = false;
-    }
-    pub fn is_paused(&self) -> bool {
-        self.paused
-    }
-
    pub fn set_color_modulation(&mut self, r: u8, g: u8, b: u8) {
        self.atlas.set_color_modulation(r, g, b);
    }
 }

 impl<'a> FrameDrawn for AnimatedAtlasTexture<'a> {
-    fn render(
-        &self,
-        canvas: &mut Canvas<Window>,
-        position: (i32, i32),
-        direction: Direction,
-        frame: Option<u32>,
-    ) {
+    fn render(&self, canvas: &mut Canvas<Window>, position: (i32, i32), direction: Direction, frame: Option<u32>) {
        let frame = frame.unwrap_or_else(|| self.current_frame());
        self.atlas.render(canvas, position, direction, Some(frame));
    }
--- a/src/asset.rs
+++ b/src/asset.rs
@@ -0,0 +1,95 @@
+//! Cross-platform asset loading abstraction.
+//! On desktop, assets are embedded using include_bytes!; on Emscripten, assets are loaded from the filesystem.
+
+use std::borrow::Cow;
+use std::io;
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum AssetError {
+    #[error("IO error: {0}")]
+    Io(#[from] io::Error),
+    #[error("Asset not found: {0}")]
+    NotFound(String),
+    #[error("Invalid asset format: {0}")]
+    InvalidFormat(String),
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum Asset {
+    Wav1,
+    Wav2,
+    Wav3,
+    Wav4,
+    Pacman,
+    Pellet,
+    Energizer,
+    Map,
+    FontKonami,
+    GhostBody,
+    GhostEyes,
+    // Add more as needed
+}
+
+impl Asset {
+    pub fn path(&self) -> &str {
+        use Asset::*;
+        match self {
+            Wav1 => "wav/1.ogg",
+            Wav2 => "wav/2.ogg",
+            Wav3 => "wav/3.ogg",
+            Wav4 => "wav/4.ogg",
+            Pacman => "32/pacman.png",
+            Pellet => "24/pellet.png",
+            Energizer => "24/energizer.png",
+            Map => "map.png",
+            FontKonami => "font/konami.ttf",
+            GhostBody => "32/ghost_body.png",
+            GhostEyes => "32/ghost_eyes.png",
+        }
+    }
+}
+
+#[cfg(not(target_os = "emscripten"))]
+mod imp {
+    use super::*;
+    macro_rules! asset_bytes_enum {
+        ( $asset:expr ) => {
+            match $asset {
+                Asset::Wav1 => Cow::Borrowed(include_bytes!("../assets/game/wav/1.ogg")),
+                Asset::Wav2 => Cow::Borrowed(include_bytes!("../assets/game/wav/2.ogg")),
+                Asset::Wav3 => Cow::Borrowed(include_bytes!("../assets/game/wav/3.ogg")),
+                Asset::Wav4 => Cow::Borrowed(include_bytes!("../assets/game/wav/4.ogg")),
+                Asset::Pacman => Cow::Borrowed(include_bytes!("../assets/game/32/pacman.png")),
+                Asset::Pellet => Cow::Borrowed(include_bytes!("../assets/game/24/pellet.png")),
+                Asset::Energizer => Cow::Borrowed(include_bytes!("../assets/game/24/energizer.png")),
+                Asset::Map => Cow::Borrowed(include_bytes!("../assets/game/map.png")),
+                Asset::FontKonami => Cow::Borrowed(include_bytes!("../assets/game/font/konami.ttf")),
+                Asset::GhostBody => Cow::Borrowed(include_bytes!("../assets/game/32/ghost_body.png")),
+                Asset::GhostEyes => Cow::Borrowed(include_bytes!("../assets/game/32/ghost_eyes.png")),
+            }
+        };
+    }
+    pub fn get_asset_bytes(asset: Asset) -> Result<Cow<'static, [u8]>, AssetError> {
+        Ok(asset_bytes_enum!(asset))
+    }
+}
+
+#[cfg(target_os = "emscripten")]
+mod imp {
+    use super::*;
+    use sdl2::rwops::RWops;
+    use std::io::Read;
+    pub fn get_asset_bytes(asset: Asset) -> Result<Cow<'static, [u8]>, AssetError> {
+        let path = format!("assets/game/{}", asset.path());
+        let mut rwops = RWops::from_file(&path, "rb").map_err(|_| AssetError::NotFound(asset.path().to_string()))?;
+        let len = rwops.len().ok_or_else(|| AssetError::NotFound(asset.path().to_string()))?;
+        let mut buf = vec![0u8; len];
+        rwops
+            .read_exact(&mut buf)
+            .map_err(|e| AssetError::Io(std::io::Error::new(std::io::ErrorKind::Other, e)))?;
+        Ok(Cow::Owned(buf))
+    }
+}
+
+pub use imp::get_asset_bytes;
--- a/src/audio.rs
+++ b/src/audio.rs
@@ -1,16 +1,11 @@
 //! This module handles the audio playback for the game.
+use crate::asset::{get_asset_bytes, Asset};
 use sdl2::{
    mixer::{self, Chunk, InitFlag, LoaderRWops, DEFAULT_FORMAT},
    rwops::RWops,
 };

-const SOUND_1_DATA: &[u8] = include_bytes!("../assets/wav/1.ogg");
-const SOUND_2_DATA: &[u8] = include_bytes!("../assets/wav/2.ogg");
-const SOUND_3_DATA: &[u8] = include_bytes!("../assets/wav/3.ogg");
-const SOUND_4_DATA: &[u8] = include_bytes!("../assets/wav/4.ogg");
-
-/// An array of all the sound effect data.
-const SOUND_DATA: [&[u8]; 4] = [SOUND_1_DATA, SOUND_2_DATA, SOUND_3_DATA, SOUND_4_DATA];
+const SOUND_ASSETS: [Asset; 4] = [Asset::Wav1, Asset::Wav2, Asset::Wav3, Asset::Wav4];

 /// The audio system for the game.
 ///
@@ -20,6 +15,7 @@ pub struct Audio {
    _mixer_context: mixer::Sdl2MixerContext,
    sounds: Vec<Chunk>,
    next_sound_index: usize,
+    muted: bool,
 }

 impl Audio {
@@ -29,26 +25,26 @@ impl Audio {
        let format = DEFAULT_FORMAT;
        let channels = 4;
        let chunk_size = 128;
+
        mixer::open_audio(frequency, format, 1, chunk_size).expect("Failed to open audio");
        mixer::allocate_channels(channels);

        // set channel volume
        for i in 0..channels {
-            mixer::Channel(i as i32).set_volume(32);
+            mixer::Channel(i).set_volume(32);
        }

        let mixer_context = mixer::init(InitFlag::OGG).expect("Failed to initialize SDL2_mixer");

-        let sounds: Vec<Chunk> = SOUND_DATA
+        let sounds: Vec<Chunk> = SOUND_ASSETS
            .iter()
            .enumerate()
-            .map(|(i, data)| {
-                let rwops = RWops::from_bytes(data)
-                    .expect(&format!("Failed to create RWops for sound {}", i + 1));
-                rwops.load_wav().expect(&format!(
-                    "Failed to load sound {} from embedded data",
-                    i + 1
-                ))
+            .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();

@@ -56,21 +52,16 @@ impl Audio {
            _mixer_context: mixer_context,
            sounds,
            next_sound_index: 0,
+            muted: false,
        }
    }

    /// Plays the "eat" sound effect.
-    ///
-    /// This function also logs the time since the last sound effect was played.
    pub fn eat(&mut self) {
        if let Some(chunk) = self.sounds.get(self.next_sound_index) {
            match mixer::Channel(0).play(chunk, 0) {
                Ok(channel) => {
-                    tracing::info!(
-                        "Playing sound #{} on channel {:?}",
-                        self.next_sound_index + 1,
-                        channel
-                    );
+                    tracing::trace!("Playing sound #{} on channel {:?}", self.next_sound_index + 1, channel);
                }
                Err(e) => {
                    tracing::warn!("Could not play sound #{}: {}", self.next_sound_index + 1, e);
@@ -79,4 +70,18 @@ impl Audio {
        }
        self.next_sound_index = (self.next_sound_index + 1) % self.sounds.len();
    }
+
+    /// Instantly mute or unmute all channels.
+    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);
+        }
+        self.muted = mute;
+    }
+
+    pub fn is_muted(&self) -> bool {
+        self.muted
+    }
 }
--- a/src/constants.rs
+++ b/src/constants.rs
@@ -73,6 +73,19 @@ impl FruitType {
            FruitType::Key => 5000,
        }
    }
+
+    pub fn index(self) -> usize {
+        match self {
+            FruitType::Cherry => 0,
+            FruitType::Strawberry => 1,
+            FruitType::Orange => 2,
+            FruitType::Apple => 3,
+            FruitType::Melon => 4,
+            FruitType::Galaxian => 5,
+            FruitType::Bell => 6,
+            FruitType::Key => 7,
+        }
+    }
 }

 /// The raw layout of the game board, as a 2D array of characters.
--- a/src/debug.rs
+++ b/src/debug.rs
@@ -1,10 +1,10 @@
 //! Debug rendering utilities for Pac-Man.
 use crate::{
    constants::{MapTile, BOARD_HEIGHT, BOARD_WIDTH},
-    direction::Direction,
    ghosts::blinky::Blinky,
    map::Map,
 };
+use glam::{IVec2, UVec2};
 use sdl2::{pixels::Color, render::Canvas, video::Window};

 #[derive(PartialEq, Eq, Clone, Copy)]
@@ -18,26 +18,22 @@ pub enum DebugMode {
 pub struct DebugRenderer;

 impl DebugRenderer {
-    pub fn draw_cell(canvas: &mut Canvas<Window>, map: &Map, cell: (u32, u32), color: Color) {
+    pub fn draw_cell(canvas: &mut Canvas<Window>, _map: &Map, cell: UVec2, color: Color) {
        let position = Map::cell_to_pixel(cell);
        canvas.set_draw_color(color);
        canvas
-            .draw_rect(sdl2::rect::Rect::new(
-                position.0 as i32,
-                position.1 as i32,
-                24,
-                24,
-            ))
+            .draw_rect(sdl2::rect::Rect::new(position.x, position.y, 24, 24))
            .expect("Could not draw rectangle");
    }

-    pub fn draw_debug_grid(canvas: &mut Canvas<Window>, map: &Map, pacman_cell: (u32, u32)) {
+    pub fn draw_debug_grid(canvas: &mut Canvas<Window>, map: &Map, pacman_cell: UVec2) {
        for x in 0..BOARD_WIDTH {
            for y in 0..BOARD_HEIGHT {
-                let tile = map.get_tile((x as i32, y as i32)).unwrap_or(MapTile::Empty);
+                let tile = map.get_tile(IVec2::new(x as i32, y as i32)).unwrap_or(MapTile::Empty);
+                let cell = UVec2::new(x, y);
                let mut color = None;
-                if (x, y) == pacman_cell {
-                    Self::draw_cell(canvas, map, (x, y), Color::CYAN);
+                if cell == pacman_cell {
+                    Self::draw_cell(canvas, map, cell, Color::CYAN);
                } else {
                    color = match tile {
                        MapTile::Empty => None,
@@ -49,31 +45,28 @@ impl DebugRenderer {
                    };
                }
                if let Some(color) = color {
-                    Self::draw_cell(canvas, map, (x, y), color);
+                    Self::draw_cell(canvas, map, cell, color);
                }
            }
        }
    }

-    pub fn draw_next_cell(canvas: &mut Canvas<Window>, map: &Map, next_cell: (u32, u32)) {
+    pub fn draw_next_cell(canvas: &mut Canvas<Window>, map: &Map, next_cell: UVec2) {
        Self::draw_cell(canvas, map, next_cell, Color::YELLOW);
    }

    pub fn draw_valid_positions(canvas: &mut Canvas<Window>, map: &mut Map) {
        let valid_positions_vec = map.get_valid_playable_positions().clone();
        for &pos in &valid_positions_vec {
-            Self::draw_cell(canvas, map, (pos.x, pos.y), Color::RGB(255, 140, 0));
-            // ORANGE
+            Self::draw_cell(canvas, map, pos, Color::RGB(255, 140, 0));
        }
    }

    pub fn draw_pathfinding(canvas: &mut Canvas<Window>, blinky: &Blinky, map: &Map) {
-        if let Some((path, _)) = blinky.get_path_to_target({
-            let (tx, ty) = blinky.get_target_tile();
-            (tx as u32, ty as u32)
-        }) {
-            for &(x, y) in &path {
-                Self::draw_cell(canvas, map, (x, y), Color::YELLOW);
+        let target = blinky.get_target_tile();
+        if let Some((path, _)) = blinky.get_path_to_target(target.as_uvec2()) {
+            for pos in &path {
+                Self::draw_cell(canvas, map, *pos, Color::YELLOW);
            }
        }
    }
--- a/src/edible.rs
+++ b/src/edible.rs
@@ -2,8 +2,9 @@
 use crate::animation::{AtlasTexture, FrameDrawn};
 use crate::constants::{FruitType, MapTile, BOARD_HEIGHT, BOARD_WIDTH};
 use crate::direction::Direction;
-use crate::entity::{Entity, Renderable};
+use crate::entity::{Entity, Renderable, StaticEntity};
 use crate::map::Map;
+use glam::{IVec2, UVec2};
 use sdl2::{render::Canvas, video::Window};
 use std::cell::RefCell;
 use std::rc::Rc;
@@ -16,68 +17,59 @@ pub enum EdibleKind {
 }

 pub struct Edible<'a> {
-    pub base: crate::entity::StaticEntity,
+    pub base: StaticEntity,
    pub kind: EdibleKind,
-    pub sprite: std::rc::Rc<AtlasTexture<'a>>,
+    pub sprite: Rc<AtlasTexture<'a>>,
 }

 impl<'a> Edible<'a> {
-    pub fn new(
-        kind: EdibleKind,
-        cell_position: (u32, u32),
-        sprite: std::rc::Rc<AtlasTexture<'a>>,
-    ) -> Self {
-        let pixel_position = crate::map::Map::cell_to_pixel(cell_position);
+    pub fn new(kind: EdibleKind, cell_position: UVec2, sprite: Rc<AtlasTexture<'a>>) -> Self {
+        let pixel_position = Map::cell_to_pixel(cell_position);
        Edible {
-            base: crate::entity::StaticEntity::new(pixel_position, cell_position),
+            base: StaticEntity::new(pixel_position, cell_position),
            kind,
            sprite,
        }
    }

    /// Checks collision with Pac-Man (or any entity)
-    pub fn collide(&self, pacman: &dyn crate::entity::Entity) -> bool {
+    pub fn collide(&self, pacman: &dyn Entity) -> bool {
        self.base.is_colliding(pacman)
    }
 }

 impl<'a> Entity for Edible<'a> {
-    fn base(&self) -> &crate::entity::StaticEntity {
+    fn base(&self) -> &StaticEntity {
        &self.base
    }
 }

 impl<'a> Renderable for Edible<'a> {
    fn render(&self, canvas: &mut Canvas<Window>) {
-        self.sprite
-            .render(canvas, self.base.pixel_position, Direction::Right, Some(0));
+        let pos = self.base.pixel_position;
+        self.sprite.render(canvas, (pos.x, pos.y), Direction::Right, Some(0));
    }
 }

 /// Reconstruct all edibles from the original map layout
 pub fn reconstruct_edibles<'a>(
    map: Rc<RefCell<Map>>,
-    pellet_sprite: std::rc::Rc<AtlasTexture<'a>>,
-    power_pellet_sprite: std::rc::Rc<AtlasTexture<'a>>,
-    fruit_sprite: std::rc::Rc<AtlasTexture<'a>>,
+    pellet_sprite: Rc<AtlasTexture<'a>>,
+    power_pellet_sprite: Rc<AtlasTexture<'a>>,
+    _fruit_sprite: Rc<AtlasTexture<'a>>,
 ) -> Vec<Edible<'a>> {
    let mut edibles = Vec::new();
    for x in 0..BOARD_WIDTH {
        for y in 0..BOARD_HEIGHT {
-            let tile = map.borrow().get_tile((x as i32, y as i32));
-            let cell = (x, y);
+            let tile = map.borrow().get_tile(IVec2::new(x as i32, y as i32));
            match tile {
                Some(MapTile::Pellet) => {
-                    edibles.push(Edible::new(
-                        EdibleKind::Pellet,
-                        cell,
-                        Rc::clone(&pellet_sprite),
-                    ));
+                    edibles.push(Edible::new(EdibleKind::Pellet, UVec2::new(x, y), Rc::clone(&pellet_sprite)));
                }
                Some(MapTile::PowerPellet) => {
                    edibles.push(Edible::new(
                        EdibleKind::PowerPellet,
-                        cell,
+                        UVec2::new(x, y),
                        Rc::clone(&power_pellet_sprite),
                    ));
                }
--- a/src/entity.rs
+++ b/src/entity.rs
@@ -4,6 +4,7 @@ use crate::{
    map::Map,
    modulation::SimpleTickModulator,
 };
+use glam::{IVec2, UVec2};
 use std::cell::RefCell;
 use std::rc::Rc;

@@ -14,9 +15,9 @@ pub trait Entity {

    /// Returns true if the entity is colliding with the other entity.
    fn is_colliding(&self, other: &dyn Entity) -> bool {
-        let (x, y) = self.base().pixel_position;
-        let (other_x, other_y) = other.base().pixel_position;
-        x == other_x && y == other_y
+        let a = self.base().pixel_position;
+        let b = other.base().pixel_position;
+        a == b
    }
 }

@@ -24,7 +25,7 @@ pub trait Entity {
 pub trait Moving {
    fn move_forward(&mut self);
    fn update_cell_position(&mut self);
-    fn next_cell(&self, direction: Option<Direction>) -> (i32, i32);
+    fn next_cell(&self, direction: Option<Direction>) -> IVec2;
    fn is_wall_ahead(&self, direction: Option<Direction>) -> bool;
    fn handle_tunnel(&mut self) -> bool;
    fn is_grid_aligned(&self) -> bool;
@@ -33,12 +34,12 @@ pub trait Moving {

 /// A struct for static (non-moving) entities with position only.
 pub struct StaticEntity {
-    pub pixel_position: (i32, i32),
-    pub cell_position: (u32, u32),
+    pub pixel_position: IVec2,
+    pub cell_position: UVec2,
 }

 impl StaticEntity {
-    pub fn new(pixel_position: (i32, i32), cell_position: (u32, u32)) -> Self {
+    pub fn new(pixel_position: IVec2, cell_position: UVec2) -> Self {
        Self {
            pixel_position,
            cell_position,
@@ -58,8 +59,8 @@ pub struct MovableEntity {

 impl MovableEntity {
    pub fn new(
-        pixel_position: (i32, i32),
-        cell_position: (u32, u32),
+        pixel_position: IVec2,
+        cell_position: UVec2,
        direction: Direction,
        speed: u32,
        modulation: SimpleTickModulator,
@@ -76,10 +77,10 @@ impl MovableEntity {
    }

    /// Returns the position within the current cell, in pixels.
-    pub fn internal_position(&self) -> (u32, u32) {
-        (
-            self.base.pixel_position.0 as u32 % CELL_SIZE,
-            self.base.pixel_position.1 as u32 % CELL_SIZE,
+    pub fn internal_position(&self) -> UVec2 {
+        UVec2::new(
+            (self.base.pixel_position.x as u32) % CELL_SIZE,
+            (self.base.pixel_position.y as u32) % CELL_SIZE,
        )
    }
 }
@@ -94,24 +95,21 @@ impl Moving for MovableEntity {
    fn move_forward(&mut self) {
        let speed = self.speed as i32;
        match self.direction {
-            Direction::Right => self.base.pixel_position.0 += speed,
-            Direction::Left => self.base.pixel_position.0 -= speed,
-            Direction::Up => self.base.pixel_position.1 -= speed,
-            Direction::Down => self.base.pixel_position.1 += speed,
+            Direction::Right => self.base.pixel_position.x += speed,
+            Direction::Left => self.base.pixel_position.x -= speed,
+            Direction::Up => self.base.pixel_position.y -= speed,
+            Direction::Down => self.base.pixel_position.y += speed,
        }
    }
    fn update_cell_position(&mut self) {
-        self.base.cell_position = (
-            (self.base.pixel_position.0 as u32 / CELL_SIZE) - BOARD_OFFSET.0,
-            (self.base.pixel_position.1 as u32 / CELL_SIZE) - BOARD_OFFSET.1,
+        self.base.cell_position = UVec2::new(
+            (self.base.pixel_position.x as u32 / CELL_SIZE) - BOARD_OFFSET.0,
+            (self.base.pixel_position.y as u32 / CELL_SIZE) - BOARD_OFFSET.1,
        );
    }
-    fn next_cell(&self, direction: Option<Direction>) -> (i32, i32) {
+    fn next_cell(&self, direction: Option<Direction>) -> IVec2 {
        let (x, y) = direction.unwrap_or(self.direction).offset();
-        (
-            self.base.cell_position.0 as i32 + x,
-            self.base.cell_position.1 as i32 + y,
-        )
+        IVec2::new(self.base.cell_position.x as i32 + x, self.base.cell_position.y as i32 + y)
    }
    fn is_wall_ahead(&self, direction: Option<Direction>) -> bool {
        let next_cell = self.next_cell(direction);
@@ -119,25 +117,23 @@ impl Moving for MovableEntity {
    }
    fn handle_tunnel(&mut self) -> bool {
        if !self.in_tunnel {
-            let current_tile = self.map.borrow().get_tile((
-                self.base.cell_position.0 as i32,
-                self.base.cell_position.1 as i32,
-            ));
+            let current_tile = self
+                .map
+                .borrow()
+                .get_tile(IVec2::new(self.base.cell_position.x as i32, self.base.cell_position.y as i32));
            if matches!(current_tile, Some(MapTile::Tunnel)) {
                self.in_tunnel = true;
            }
        }
        if self.in_tunnel {
-            if self.base.cell_position.0 == 0 {
-                self.base.cell_position.0 = BOARD_WIDTH - 2;
-                self.base.pixel_position =
-                    Map::cell_to_pixel((self.base.cell_position.0, self.base.cell_position.1));
+            if self.base.cell_position.x == 0 {
+                self.base.cell_position.x = BOARD_WIDTH - 2;
+                self.base.pixel_position = Map::cell_to_pixel(self.base.cell_position);
                self.in_tunnel = false;
                true
-            } else if self.base.cell_position.0 == BOARD_WIDTH - 1 {
-                self.base.cell_position.0 = 1;
-                self.base.pixel_position =
-                    Map::cell_to_pixel((self.base.cell_position.0, self.base.cell_position.1));
+            } else if self.base.cell_position.x == BOARD_WIDTH - 1 {
+                self.base.cell_position.x = 1;
+                self.base.pixel_position = Map::cell_to_pixel(self.base.cell_position);
                self.in_tunnel = false;
                true
            } else {
@@ -148,7 +144,7 @@ impl Moving for MovableEntity {
        }
    }
    fn is_grid_aligned(&self) -> bool {
-        self.internal_position() == (0, 0)
+        self.internal_position() == UVec2::ZERO
    }
    fn set_direction_if_valid(&mut self, new_direction: Direction) -> bool {
        if new_direction == self.direction {
--- a/src/game.rs
+++ b/src/game.rs
@@ -1,7 +1,9 @@
 //! This module contains the main game logic and state.
 use std::cell::RefCell;
+use std::ops::Not;
 use std::rc::Rc;

+use glam::UVec2;
 use rand::seq::IteratorRandom;
 use sdl2::image::LoadTexture;
 use sdl2::keyboard::Keycode;
@@ -10,32 +12,18 @@ use sdl2::rwops::RWops;
 use sdl2::ttf::Font;
 use sdl2::video::WindowContext;
 use sdl2::{pixels::Color, render::Canvas, video::Window};
-use tracing::event;

+use crate::animation::AtlasTexture;
+use crate::asset::{get_asset_bytes, Asset};
 use crate::audio::Audio;
-use crate::{
-    animation::{AtlasTexture, FrameDrawn},
-    constants::{MapTile, BOARD_HEIGHT, BOARD_WIDTH, RAW_BOARD},
-    direction::Direction,
-    entity::{Entity, Renderable},
-    ghosts::blinky::Blinky,
-    map::Map,
-    pacman::Pacman,
-};
-
+use crate::constants::RAW_BOARD;
 use crate::debug::{DebugMode, DebugRenderer};
+use crate::direction::Direction;
 use crate::edible::{reconstruct_edibles, Edible, EdibleKind};
-
-// Embed texture data directly into the executable
-static PACMAN_TEXTURE_DATA: &[u8] = include_bytes!("../assets/32/pacman.png");
-static PELLET_TEXTURE_DATA: &[u8] = include_bytes!("../assets/24/pellet.png");
-static POWER_PELLET_TEXTURE_DATA: &[u8] = include_bytes!("../assets/24/energizer.png");
-static MAP_TEXTURE_DATA: &[u8] = include_bytes!("../assets/map.png");
-static FONT_DATA: &[u8] = include_bytes!("../assets/font/konami.ttf");
-
-// Add ghost texture data
-static GHOST_BODY_TEXTURE_DATA: &[u8] = include_bytes!("../assets/32/ghost_body.png");
-static GHOST_EYES_TEXTURE_DATA: &[u8] = include_bytes!("../assets/32/ghost_eyes.png");
+use crate::entity::Renderable;
+use crate::ghosts::blinky::Blinky;
+use crate::map::Map;
+use crate::pacman::Pacman;

 /// The main game state.
 ///
@@ -48,15 +36,15 @@ pub struct Game<'a> {
    power_pellet_texture: Rc<AtlasTexture<'a>>,
    font: Font<'a, 'static>,
    pacman: Rc<RefCell<Pacman<'a>>>,
-    map: Rc<std::cell::RefCell<Map>>,
+    map: Rc<RefCell<Map>>,
    debug_mode: DebugMode,
    score: u32,
-    audio: crate::audio::Audio,
+    pub audio: Audio,
    blinky: Blinky<'a>,
    edibles: Vec<Edible<'a>>,
 }

-impl Game<'_> {
+impl<'a> Game<'a> {
    /// Creates a new `Game` instance.
    ///
    /// # Arguments
@@ -65,73 +53,67 @@ impl Game<'_> {
    /// * `texture_creator` - The SDL texture creator.
    /// * `ttf_context` - The SDL TTF context.
    /// * `_audio_subsystem` - The SDL audio subsystem (currently unused).
-    pub fn new<'a>(
+    pub fn new(
        canvas: &'a mut Canvas<Window>,
        texture_creator: &'a TextureCreator<WindowContext>,
        ttf_context: &'a sdl2::ttf::Sdl2TtfContext,
        _audio_subsystem: &'a sdl2::AudioSubsystem,
    ) -> Game<'a> {
-        let map = Rc::new(std::cell::RefCell::new(Map::new(RAW_BOARD)));
+        let map = Rc::new(RefCell::new(Map::new(RAW_BOARD)));

-        // Load Pacman texture from embedded data
+        // Load Pacman texture from asset API
+        let pacman_bytes = get_asset_bytes(Asset::Pacman).expect("Failed to load asset");
        let pacman_atlas = texture_creator
-            .load_texture_bytes(PACMAN_TEXTURE_DATA)
-            .expect("Could not load pacman texture from embedded data");
-        let pacman = Rc::new(std::cell::RefCell::new(Pacman::new(
-            (1, 1),
-            pacman_atlas,
-            Rc::clone(&map),
-        )));
+            .load_texture_bytes(&pacman_bytes)
+            .expect("Could not load pacman texture from asset API");
+        let pacman = Rc::new(RefCell::new(Pacman::new(UVec2::new(1, 1), pacman_atlas, Rc::clone(&map))));

        // Load ghost textures
+        let ghost_body_bytes = get_asset_bytes(Asset::GhostBody).expect("Failed to load asset");
        let ghost_body = texture_creator
-            .load_texture_bytes(GHOST_BODY_TEXTURE_DATA)
-            .expect("Could not load ghost body texture from embedded data");
+            .load_texture_bytes(&ghost_body_bytes)
+            .expect("Could not load ghost body texture from asset API");
+        let ghost_eyes_bytes = get_asset_bytes(Asset::GhostEyes).expect("Failed to load asset");
        let ghost_eyes = texture_creator
-            .load_texture_bytes(GHOST_EYES_TEXTURE_DATA)
-            .expect("Could not load ghost eyes texture from embedded data");
+            .load_texture_bytes(&ghost_eyes_bytes)
+            .expect("Could not load ghost eyes texture from asset API");

        // Create Blinky
        let blinky = Blinky::new(
-            (13, 11), // Starting position just above ghost house
+            UVec2::new(13, 11), // Starting position just above ghost house
            ghost_body,
            ghost_eyes,
            Rc::clone(&map),
            Rc::clone(&pacman),
        );

-        // Load pellet texture from embedded data
+        // Load pellet texture from asset API
+        let pellet_bytes = get_asset_bytes(Asset::Pellet).expect("Failed to load asset");
        let pellet_texture = Rc::new(AtlasTexture::new(
            texture_creator
-                .load_texture_bytes(PELLET_TEXTURE_DATA)
-                .expect("Could not load pellet texture from embedded data"),
+                .load_texture_bytes(&pellet_bytes)
+                .expect("Could not load pellet texture from asset API"),
            1,
            24,
            24,
            None,
        ));
+        let power_pellet_bytes = get_asset_bytes(Asset::Energizer).expect("Failed to load asset");
        let power_pellet_texture = Rc::new(AtlasTexture::new(
            texture_creator
-                .load_texture_bytes(POWER_PELLET_TEXTURE_DATA)
-                .expect("Could not load power pellet texture from embedded data"),
+                .load_texture_bytes(&power_pellet_bytes)
+                .expect("Could not load power pellet texture from asset API"),
            1,
            24,
            24,
            None,
        ));

-        // Load font from embedded data
-        let font_rwops = RWops::from_bytes(FONT_DATA).expect("Failed to create RWops for font");
-        let font = ttf_context
-            .load_font_from_rwops(font_rwops, 24)
-            .expect("Could not load font from embedded data");
-
-        let audio = Audio::new();
-
-        // Load map texture from embedded data
+        // Load map texture from asset API
+        let map_bytes = get_asset_bytes(Asset::Map).expect("Failed to load asset");
        let mut map_texture = texture_creator
-            .load_texture_bytes(MAP_TEXTURE_DATA)
-            .expect("Could not load map texture from embedded data");
+            .load_texture_bytes(&map_bytes)
+            .expect("Could not load map texture from asset API");
        map_texture.set_color_mod(0, 0, 255);

        let edibles = reconstruct_edibles(
@@ -141,6 +123,18 @@ impl Game<'_> {
            Rc::clone(&pellet_texture), // placeholder for fruit sprite
        );

+        // Load font from asset API
+        let font = {
+            let font_bytes = get_asset_bytes(Asset::FontKonami).expect("Failed to load asset").into_owned();
+            let font_bytes_static: &'static [u8] = Box::leak(font_bytes.into_boxed_slice());
+            let font_rwops = RWops::from_bytes(font_bytes_static).expect("Failed to create RWops for font");
+            ttf_context
+                .load_font_from_rwops(font_rwops, 24)
+                .expect("Could not load font from asset API")
+        };
+
+        let audio = Audio::new();
+
        Game {
            canvas,
            pacman,
@@ -181,10 +175,15 @@ impl Game<'_> {
            return;
        }

+        // Toggle mute
+        if keycode == Keycode::M {
+            self.audio.set_mute(self.audio.is_muted().not());
+            return;
+        }
+
        // Reset game
        if keycode == Keycode::R {
            self.reset();
-            return;
        }
    }

@@ -208,29 +207,31 @@ impl Game<'_> {
        // Reset the score
        self.score = 0;

-        // Get valid positions from the cached flood fill
-        let mut map = self.map.borrow_mut();
-        let valid_positions = map.get_valid_playable_positions();
-        let mut rng = rand::rng();
+        // Get valid positions from the cached flood fill and randomize positions in a single block
+        {
+            let mut map = self.map.borrow_mut();
+            let valid_positions = map.get_valid_playable_positions();
+            let mut rng = rand::rng();

-        // Randomize Pac-Man position
-        if let Some(pos) = valid_positions.iter().choose(&mut rng) {
-            let mut pacman = self.pacman.borrow_mut();
-            pacman.base.base.pixel_position = Map::cell_to_pixel((pos.x, pos.y));
-            pacman.base.base.cell_position = (pos.x, pos.y);
-            pacman.base.in_tunnel = false;
-            pacman.base.direction = Direction::Right;
-            pacman.next_direction = None;
-            pacman.stopped = false;
-        }
+            // Randomize Pac-Man position
+            if let Some(pos) = valid_positions.iter().choose(&mut rng) {
+                let mut pacman = self.pacman.borrow_mut();
+                pacman.base.base.pixel_position = Map::cell_to_pixel(*pos);
+                pacman.base.base.cell_position = *pos;
+                pacman.base.in_tunnel = false;
+                pacman.base.direction = Direction::Right;
+                pacman.next_direction = None;
+                pacman.stopped = false;
+            }

-        // Randomize ghost position
-        if let Some(pos) = valid_positions.iter().choose(&mut rng) {
-            self.blinky.base.base.pixel_position = Map::cell_to_pixel((pos.x, pos.y));
-            self.blinky.base.base.cell_position = (pos.x, pos.y);
-            self.blinky.base.in_tunnel = false;
-            self.blinky.base.direction = Direction::Left;
-            self.blinky.mode = crate::ghost::GhostMode::Chase;
+            // Randomize ghost position
+            if let Some(pos) = valid_positions.iter().choose(&mut rng) {
+                self.blinky.base.base.pixel_position = Map::cell_to_pixel(*pos);
+                self.blinky.base.base.cell_position = *pos;
+                self.blinky.base.in_tunnel = false;
+                self.blinky.base.direction = Direction::Left;
+                self.blinky.mode = crate::ghost::GhostMode::Chase;
+            }
        }

        self.edibles = reconstruct_edibles(
@@ -289,8 +290,7 @@ impl Game<'_> {
            .copy(&self.map_texture, None, None)
            .expect("Could not render texture on canvas");

-        // Remove old pellet rendering
-        // Instead, render all edibles
+        // Render all edibles
        for edible in &self.edibles {
            edible.render(self.canvas);
        }
@@ -307,18 +307,9 @@ impl Game<'_> {
        // Draw the debug grid
        match self.debug_mode {
            DebugMode::Grid => {
-                DebugRenderer::draw_debug_grid(
-                    self.canvas,
-                    &self.map.borrow(),
-                    self.pacman.borrow().base.base.cell_position,
-                );
-                let next_cell =
-                    <Pacman as crate::entity::Moving>::next_cell(&*self.pacman.borrow(), None);
-                DebugRenderer::draw_next_cell(
-                    self.canvas,
-                    &self.map.borrow(),
-                    (next_cell.0 as u32, next_cell.1 as u32),
-                );
+                DebugRenderer::draw_debug_grid(self.canvas, &self.map.borrow(), self.pacman.borrow().base.base.cell_position);
+                let next_cell = <Pacman as crate::entity::Moving>::next_cell(&*self.pacman.borrow(), None);
+                DebugRenderer::draw_next_cell(self.canvas, &self.map.borrow(), next_cell.as_uvec2());
            }
            DebugMode::ValidPositions => {
                DebugRenderer::draw_valid_positions(self.canvas, &mut self.map.borrow_mut());
@@ -346,7 +337,7 @@ impl Game<'_> {

        // Render the score and high score
        self.render_text(
-            &format!("{}UP   HIGH SCORE   ", lives),
+            &format!("{lives}UP   HIGH SCORE   "),
            (24 * lives_offset + x_offset, y_offset),
            Color::WHITE,
        );
@@ -359,11 +350,7 @@ impl Game<'_> {

    /// Renders text to the screen at the given position.
    fn render_text(&mut self, text: &str, position: (i32, i32), color: Color) {
-        let surface = self
-            .font
-            .render(text)
-            .blended(color)
-            .expect("Could not render text surface");
+        let surface = self.font.render(text).blended(color).expect("Could not render text surface");

        let texture_creator = self.canvas.texture_creator();
        let texture = texture_creator
--- a/src/ghost.rs
+++ b/src/ghost.rs
@@ -1,15 +1,17 @@
-use pathfinding::prelude::dijkstra;
 use rand::Rng;

-use crate::{
-    animation::{AnimatedAtlasTexture, FrameDrawn},
-    constants::{MapTile, BOARD_WIDTH},
-    direction::Direction,
-    entity::{Entity, MovableEntity, Moving, Renderable, StaticEntity},
-    map::Map,
-    modulation::{SimpleTickModulator, TickModulator},
-    pacman::Pacman,
-};
+use crate::animation::{AnimatedAtlasTexture, FrameDrawn};
+use crate::constants::{MapTile, BOARD_WIDTH};
+use crate::direction::Direction;
+use crate::entity::{Entity, MovableEntity, Moving, Renderable};
+use crate::map::Map;
+use crate::modulation::{SimpleTickModulator, TickModulator};
+use crate::pacman::Pacman;
+use glam::{IVec2, UVec2};
+use sdl2::pixels::Color;
+use sdl2::render::Texture;
+use std::cell::RefCell;
+use std::rc::Rc;

 /// The different modes a ghost can be in
 #[derive(Debug, Clone, Copy, PartialEq)]
@@ -37,12 +39,12 @@ pub enum GhostType {

 impl GhostType {
    /// Returns the color of the ghost.
-    pub fn color(&self) -> sdl2::pixels::Color {
+    pub fn color(&self) -> Color {
        match self {
-            GhostType::Blinky => sdl2::pixels::Color::RGB(255, 0, 0),
-            GhostType::Pinky => sdl2::pixels::Color::RGB(255, 184, 255),
-            GhostType::Inky => sdl2::pixels::Color::RGB(0, 255, 255),
-            GhostType::Clyde => sdl2::pixels::Color::RGB(255, 184, 82),
+            GhostType::Blinky => Color::RGB(255, 0, 0),
+            GhostType::Pinky => Color::RGB(255, 184, 255),
+            GhostType::Inky => Color::RGB(0, 255, 255),
+            GhostType::Clyde => Color::RGB(255, 184, 82),
        }
    }
 }
@@ -56,7 +58,7 @@ pub struct Ghost<'a> {
    /// The type/personality of this ghost
    pub ghost_type: GhostType,
    /// Reference to Pac-Man for targeting
-    pub pacman: std::rc::Rc<std::cell::RefCell<Pacman<'a>>>,
+    pub pacman: Rc<RefCell<Pacman<'a>>>,
    pub body_sprite: AnimatedAtlasTexture<'a>,
    pub eyes_sprite: AnimatedAtlasTexture<'a>,
 }
@@ -65,11 +67,11 @@ impl Ghost<'_> {
    /// Creates a new ghost instance
    pub fn new<'a>(
        ghost_type: GhostType,
-        starting_position: (u32, u32),
-        body_texture: sdl2::render::Texture<'a>,
-        eyes_texture: sdl2::render::Texture<'a>,
-        map: std::rc::Rc<std::cell::RefCell<Map>>,
-        pacman: std::rc::Rc<std::cell::RefCell<Pacman<'a>>>,
+        starting_position: UVec2,
+        body_texture: Texture<'a>,
+        eyes_texture: Texture<'a>,
+        map: Rc<RefCell<Map>>,
+        pacman: Rc<RefCell<Pacman<'a>>>,
    ) -> Ghost<'a> {
        let color = ghost_type.color();
        let mut body_sprite = AnimatedAtlasTexture::new(body_texture, 8, 2, 32, 32, Some((-4, -4)));
@@ -93,7 +95,7 @@ impl Ghost<'_> {
    }

    /// Gets the target tile for this ghost based on its current mode
-    pub fn get_target_tile(&self) -> (i32, i32) {
+    pub fn get_target_tile(&self) -> IVec2 {
        match self.mode {
            GhostMode::Scatter => self.get_scatter_target(),
            GhostMode::Chase => self.get_chase_target(),
@@ -104,37 +106,29 @@ impl Ghost<'_> {
    }

    /// Gets this ghost's home corner target for scatter mode
-    fn get_scatter_target(&self) -> (i32, i32) {
+    fn get_scatter_target(&self) -> IVec2 {
        match self.ghost_type {
-            GhostType::Blinky => (25, 0), // Top right
-            GhostType::Pinky => (2, 0),   // Top left
-            GhostType::Inky => (27, 35),  // Bottom right
-            GhostType::Clyde => (0, 35),  // Bottom left
+            GhostType::Blinky => IVec2::new(25, 0), // Top right
+            GhostType::Pinky => IVec2::new(2, 0),   // Top left
+            GhostType::Inky => IVec2::new(27, 35),  // Bottom right
+            GhostType::Clyde => IVec2::new(0, 35),  // Bottom left
        }
    }

    /// Gets a random adjacent tile for frightened mode
-    fn get_random_target(&self) -> (i32, i32) {
+    fn get_random_target(&self) -> IVec2 {
        let mut rng = rand::rng();
        let mut possible_moves = Vec::new();

        // Check all four directions
-        for dir in &[
-            Direction::Up,
-            Direction::Down,
-            Direction::Left,
-            Direction::Right,
-        ] {
+        for dir in &[Direction::Up, Direction::Down, Direction::Left, Direction::Right] {
            // Don't allow reversing direction
            if *dir == self.base.direction.opposite() {
                continue;
            }

            let next_cell = self.base.next_cell(Some(*dir));
-            if !matches!(
-                self.base.map.borrow().get_tile(next_cell),
-                Some(MapTile::Wall)
-            ) {
+            if !matches!(self.base.map.borrow().get_tile(next_cell), Some(MapTile::Wall)) {
                possible_moves.push(next_cell);
            }
        }
@@ -149,53 +143,49 @@ impl Ghost<'_> {
    }

    /// Gets the ghost house target for returning eyes
-    fn get_house_target(&self) -> (i32, i32) {
-        (13, 14) // Center of ghost house
+    fn get_house_target(&self) -> IVec2 {
+        IVec2::new(13, 14) // Center of ghost house
    }

    /// Gets the exit point target when leaving house
-    fn get_house_exit_target(&self) -> (i32, i32) {
-        (13, 11) // Just above ghost house
+    fn get_house_exit_target(&self) -> IVec2 {
+        IVec2::new(13, 11) // Just above ghost house
    }

    /// Gets this ghost's chase mode target (to be implemented by each ghost type)
-    fn get_chase_target(&self) -> (i32, i32) {
+    fn get_chase_target(&self) -> IVec2 {
        let pacman = self.pacman.borrow();
        let cell = pacman.base().cell_position;
-        (cell.0 as i32, cell.1 as i32)
+        IVec2::new(cell.x as i32, cell.y as i32)
    }

    /// Calculates the path to the target tile using the A* algorithm.
-    pub fn get_path_to_target(&self, target: (u32, u32)) -> Option<(Vec<(u32, u32)>, u32)> {
+    pub fn get_path_to_target(&self, target: UVec2) -> Option<(Vec<UVec2>, u32)> {
        let start = self.base.base.cell_position;
        let map = self.base.map.borrow();
-
+        use pathfinding::prelude::dijkstra;
        dijkstra(
            &start,
            |&p| {
                let mut successors = vec![];
-                let tile = map.get_tile((p.0 as i32, p.1 as i32));
+                let tile = map.get_tile(IVec2::new(p.x as i32, p.y as i32));
                // Tunnel wrap: if currently in a tunnel, add the opposite exit as a neighbor
                if let Some(MapTile::Tunnel) = tile {
-                    if p.0 == 0 {
-                        successors.push(((BOARD_WIDTH - 2, p.1), 1));
-                    } else if p.0 == BOARD_WIDTH - 1 {
-                        successors.push(((1, p.1), 1));
+                    if p.x == 0 {
+                        successors.push((UVec2::new(BOARD_WIDTH - 2, p.y), 1));
+                    } else if p.x == BOARD_WIDTH - 1 {
+                        successors.push((UVec2::new(1, p.y), 1));
                    }
                }
-                for dir in &[
-                    Direction::Up,
-                    Direction::Down,
-                    Direction::Left,
-                    Direction::Right,
-                ] {
+                for dir in &[Direction::Up, Direction::Down, Direction::Left, Direction::Right] {
                    let (dx, dy) = dir.offset();
-                    let next_p = (p.0 as i32 + dx, p.1 as i32 + dy);
+                    let next_p = IVec2::new(p.x as i32 + dx, p.y as i32 + dy);
                    if let Some(tile) = map.get_tile(next_p) {
                        if tile == MapTile::Wall {
                            continue;
                        }
-                        successors.push(((next_p.0 as u32, next_p.1 as u32), 1));
+                        let next_u = UVec2::new(next_p.x as u32, next_p.y as u32);
+                        successors.push((next_u, 1));
                    }
                }
                successors
@@ -207,9 +197,8 @@ impl Ghost<'_> {
    /// Changes the ghost's mode and handles direction reversal
    pub fn set_mode(&mut self, new_mode: GhostMode) {
        // Don't reverse if going to/from frightened or if in house
-        let should_reverse = self.mode != GhostMode::House
-            && new_mode != GhostMode::Frightened
-            && self.mode != GhostMode::Frightened;
+        let should_reverse =
+            self.mode != GhostMode::House && new_mode != GhostMode::Frightened && self.mode != GhostMode::Frightened;

        self.mode = new_mode;

@@ -222,8 +211,7 @@ impl Ghost<'_> {
        };

        if should_reverse {
-            self.base
-                .set_direction_if_valid(self.base.direction.opposite());
+            self.base.set_direction_if_valid(self.base.direction.opposite());
        }
    }

@@ -239,14 +227,13 @@ impl Ghost<'_> {
            if !self.base.handle_tunnel() {
                // Pathfinding logic (only if not in tunnel)
                let target_tile = self.get_target_tile();
-                if let Some((path, _)) =
-                    self.get_path_to_target((target_tile.0 as u32, target_tile.1 as u32))
-                {
+                if let Some((path, _)) = self.get_path_to_target(target_tile.as_uvec2()) {
                    if path.len() > 1 {
                        let next_move = path[1];
-                        let (x, y) = self.base.base.cell_position;
-                        let dx = next_move.0 as i32 - x as i32;
-                        let dy = next_move.1 as i32 - y as i32;
+                        let x = self.base.base.cell_position.x;
+                        let y = self.base.base.cell_position.y;
+                        let dx = next_move.x as i32 - x as i32;
+                        let dy = next_move.y as i32 - y as i32;
                        let new_direction = if dx > 0 {
                            Direction::Right
                        } else if dx < 0 {
@@ -284,7 +271,7 @@ impl<'a> Moving for Ghost<'a> {
    fn update_cell_position(&mut self) {
        self.base.update_cell_position();
    }
-    fn next_cell(&self, direction: Option<Direction>) -> (i32, i32) {
+    fn next_cell(&self, direction: Option<Direction>) -> IVec2 {
        self.base.next_cell(direction)
    }
    fn is_wall_ahead(&self, direction: Option<Direction>) -> bool {
@@ -301,10 +288,10 @@ impl<'a> Moving for Ghost<'a> {
    }
 }

-impl Renderable for Ghost<'_> {
+impl<'a> Renderable for Ghost<'a> {
    fn render(&self, canvas: &mut sdl2::render::Canvas<sdl2::video::Window>) {
        let pos = self.base.base.pixel_position;
-        self.body_sprite.render(canvas, pos, Direction::Right, None);
+        self.body_sprite.render(canvas, (pos.x, pos.y), Direction::Right, None);
        // Inline the eye_frame logic here
        let eye_frame = if self.mode == GhostMode::Frightened {
            4 // Frightened frame
@@ -317,6 +304,6 @@ impl Renderable for Ghost<'_> {
            }
        };
        self.eyes_sprite
-            .render(canvas, pos, Direction::Right, Some(eye_frame));
+            .render(canvas, (pos.x, pos.y), Direction::Right, Some(eye_frame));
    }
 }
--- a/src/ghosts/blinky.rs
+++ b/src/ghosts/blinky.rs
@@ -4,12 +4,12 @@ use std::rc::Rc;
 use sdl2::render::{Canvas, Texture};
 use sdl2::video::Window;

-use crate::{
-    entity::{Entity, MovableEntity, Renderable},
-    ghost::{Ghost, GhostMode, GhostType},
-    map::Map,
-    pacman::Pacman,
-};
+use crate::direction::Direction;
+use crate::entity::{Entity, Moving, Renderable, StaticEntity};
+use crate::ghost::{Ghost, GhostMode, GhostType};
+use crate::map::Map;
+use crate::pacman::Pacman;
+use glam::{IVec2, UVec2};

 pub struct Blinky<'a> {
    ghost: Ghost<'a>,
@@ -17,29 +17,22 @@ pub struct Blinky<'a> {

 impl<'a> Blinky<'a> {
    pub fn new(
-        starting_position: (u32, u32),
+        starting_position: UVec2,
        body_texture: Texture<'a>,
        eyes_texture: Texture<'a>,
        map: Rc<RefCell<Map>>,
        pacman: Rc<RefCell<Pacman<'a>>>,
    ) -> Blinky<'a> {
        Blinky {
-            ghost: Ghost::new(
-                GhostType::Blinky,
-                starting_position,
-                body_texture,
-                eyes_texture,
-                map,
-                pacman,
-            ),
+            ghost: Ghost::new(GhostType::Blinky, starting_position, body_texture, eyes_texture, map, pacman),
        }
    }

    /// Gets Blinky's chase target - directly targets Pac-Man's current position
-    fn get_chase_target(&self) -> (i32, i32) {
+    fn get_chase_target(&self) -> IVec2 {
        let pacman = self.ghost.pacman.borrow();
        let cell = pacman.base().cell_position;
-        (cell.0 as i32, cell.1 as i32)
+        IVec2::new(cell.x as i32, cell.y as i32)
    }

    pub fn set_mode(&mut self, mode: GhostMode) {
@@ -51,29 +44,29 @@ impl<'a> Blinky<'a> {
    }
 }

-impl<'a> crate::entity::Entity for Blinky<'a> {
-    fn base(&self) -> &crate::entity::StaticEntity {
+impl<'a> Entity for Blinky<'a> {
+    fn base(&self) -> &StaticEntity {
        self.ghost.base.base()
    }
 }

-impl<'a> crate::entity::Renderable for Blinky<'a> {
+impl<'a> Renderable for Blinky<'a> {
    fn render(&self, canvas: &mut Canvas<Window>) {
        self.ghost.render(canvas);
    }
 }

-impl<'a> crate::entity::Moving for Blinky<'a> {
+impl<'a> Moving for Blinky<'a> {
    fn move_forward(&mut self) {
        self.ghost.move_forward();
    }
    fn update_cell_position(&mut self) {
        self.ghost.update_cell_position();
    }
-    fn next_cell(&self, direction: Option<crate::direction::Direction>) -> (i32, i32) {
+    fn next_cell(&self, direction: Option<Direction>) -> IVec2 {
        self.ghost.next_cell(direction)
    }
-    fn is_wall_ahead(&self, direction: Option<crate::direction::Direction>) -> bool {
+    fn is_wall_ahead(&self, direction: Option<Direction>) -> bool {
        self.ghost.is_wall_ahead(direction)
    }
    fn handle_tunnel(&mut self) -> bool {
@@ -82,7 +75,7 @@ impl<'a> crate::entity::Moving for Blinky<'a> {
    fn is_grid_aligned(&self) -> bool {
        self.ghost.is_grid_aligned()
    }
-    fn set_direction_if_valid(&mut self, new_direction: crate::direction::Direction) -> bool {
+    fn set_direction_if_valid(&mut self, new_direction: Direction) -> bool {
        self.ghost.set_direction_if_valid(new_direction)
    }
 }
--- a/src/helper.rs
+++ b/src/helper.rs
@@ -1,28 +1,23 @@
 //! This module contains helper functions that are used throughout the game.

+use glam::UVec2;
+
 /// Checks if two grid positions are adjacent to each other
 ///
 /// # Arguments
 /// * `a` - First position as (x, y) coordinates
-/// * `b` - Second position as (x, y) coordinates  
+/// * `b` - Second position as (x, y) coordinates
 /// * `diagonal` - Whether to consider diagonal adjacency (true) or only orthogonal (false)
 ///
 /// # Returns
 /// * `true` if positions are adjacent according to the diagonal parameter
 /// * `false` otherwise
-pub fn is_adjacent(a: (u32, u32), b: (u32, u32), diagonal: bool) -> bool {
-    let (ax, ay) = a;
-    let (bx, by) = b;
-
-    // Calculate absolute differences between coordinates
-    let dx = if ax > bx { ax - bx } else { bx - ax };
-    let dy = if ay > by { ay - by } else { by - ay };
-
+pub fn is_adjacent(a: UVec2, b: UVec2, diagonal: bool) -> bool {
+    let dx = a.x.abs_diff(b.x);
+    let dy = a.y.abs_diff(b.y);
    if diagonal {
-        // For diagonal adjacency: both differences must be ≤ 1 and at least one > 0
-        dx <= 1 && dy <= 1 && (dx + dy) > 0
+        dx <= 1 && dy <= 1 && (dx != 0 || dy != 0)
    } else {
-        // For orthogonal adjacency: exactly one difference must be 1, the other 0
        (dx == 1 && dy == 0) || (dx == 0 && dy == 1)
    }
 }
@@ -36,22 +31,22 @@ mod tests {
        // Test orthogonal adjacency (diagonal = false)

        // Same position should not be adjacent
-        assert!(!is_adjacent((0, 0), (0, 0), false));
+        assert!(!is_adjacent(UVec2::new(0, 0), UVec2::new(0, 0), false));

        // Adjacent positions should be true
-        assert!(is_adjacent((0, 0), (1, 0), false)); // Right
-        assert!(is_adjacent((0, 0), (0, 1), false)); // Down
-        assert!(is_adjacent((1, 1), (0, 1), false)); // Left
-        assert!(is_adjacent((1, 1), (1, 0), false)); // Up
+        assert!(is_adjacent(UVec2::new(0, 0), UVec2::new(1, 0), false)); // Right
+        assert!(is_adjacent(UVec2::new(0, 0), UVec2::new(0, 1), false)); // Down
+        assert!(is_adjacent(UVec2::new(1, 1), UVec2::new(0, 1), false)); // Left
+        assert!(is_adjacent(UVec2::new(1, 1), UVec2::new(1, 0), false)); // Up

        // Diagonal positions should be false
-        assert!(!is_adjacent((0, 0), (1, 1), false));
-        assert!(!is_adjacent((0, 1), (1, 0), false));
+        assert!(!is_adjacent(UVec2::new(0, 0), UVec2::new(1, 1), false));
+        assert!(!is_adjacent(UVec2::new(0, 1), UVec2::new(1, 0), false));

        // Positions more than 1 step away should be false
-        assert!(!is_adjacent((0, 0), (2, 0), false));
-        assert!(!is_adjacent((0, 0), (0, 2), false));
-        assert!(!is_adjacent((0, 0), (2, 2), false));
+        assert!(!is_adjacent(UVec2::new(0, 0), UVec2::new(2, 0), false));
+        assert!(!is_adjacent(UVec2::new(0, 0), UVec2::new(0, 2), false));
+        assert!(!is_adjacent(UVec2::new(0, 0), UVec2::new(2, 2), false));
    }

    #[test]
@@ -59,54 +54,54 @@ mod tests {
        // Test diagonal adjacency (diagonal = true)

        // Same position should not be adjacent
-        assert!(!is_adjacent((0, 0), (0, 0), true));
+        assert!(!is_adjacent(UVec2::new(0, 0), UVec2::new(0, 0), true));

        // Orthogonal adjacent positions should be true
-        assert!(is_adjacent((0, 0), (1, 0), true)); // Right
-        assert!(is_adjacent((0, 0), (0, 1), true)); // Down
-        assert!(is_adjacent((1, 1), (0, 1), true)); // Left
-        assert!(is_adjacent((1, 1), (1, 0), true)); // Up
+        assert!(is_adjacent(UVec2::new(0, 0), UVec2::new(1, 0), true)); // Right
+        assert!(is_adjacent(UVec2::new(0, 0), UVec2::new(0, 1), true)); // Down
+        assert!(is_adjacent(UVec2::new(1, 1), UVec2::new(0, 1), true)); // Left
+        assert!(is_adjacent(UVec2::new(1, 1), UVec2::new(1, 0), true)); // Up

        // Diagonal adjacent positions should be true
-        assert!(is_adjacent((0, 0), (1, 1), true)); // Down-right
-        assert!(is_adjacent((1, 0), (0, 1), true)); // Down-left
-        assert!(is_adjacent((0, 1), (1, 0), true)); // Up-right
-        assert!(is_adjacent((1, 1), (0, 0), true)); // Up-left
+        assert!(is_adjacent(UVec2::new(0, 0), UVec2::new(1, 1), true)); // Down-right
+        assert!(is_adjacent(UVec2::new(1, 0), UVec2::new(0, 1), true)); // Down-left
+        assert!(is_adjacent(UVec2::new(0, 1), UVec2::new(1, 0), true)); // Up-right
+        assert!(is_adjacent(UVec2::new(1, 1), UVec2::new(0, 0), true)); // Up-left

        // Positions more than 1 step away should be false
-        assert!(!is_adjacent((0, 0), (2, 0), true));
-        assert!(!is_adjacent((0, 0), (0, 2), true));
-        assert!(!is_adjacent((0, 0), (2, 2), true));
-        assert!(!is_adjacent((0, 0), (1, 2), true));
+        assert!(!is_adjacent(UVec2::new(0, 0), UVec2::new(2, 0), true));
+        assert!(!is_adjacent(UVec2::new(0, 0), UVec2::new(0, 2), true));
+        assert!(!is_adjacent(UVec2::new(0, 0), UVec2::new(2, 2), true));
+        assert!(!is_adjacent(UVec2::new(0, 0), UVec2::new(1, 2), true));
    }

    #[test]
    fn test_edge_cases() {
        // Test with larger coordinates
-        assert!(is_adjacent((100, 100), (101, 100), false));
-        assert!(is_adjacent((100, 100), (100, 101), false));
-        assert!(!is_adjacent((100, 100), (102, 100), false));
+        assert!(is_adjacent(UVec2::new(100, 100), UVec2::new(101, 100), false));
+        assert!(is_adjacent(UVec2::new(100, 100), UVec2::new(100, 101), false));
+        assert!(!is_adjacent(UVec2::new(100, 100), UVec2::new(102, 100), false));

-        assert!(is_adjacent((100, 100), (101, 101), true));
-        assert!(!is_adjacent((100, 100), (102, 102), true));
+        assert!(is_adjacent(UVec2::new(100, 100), UVec2::new(101, 101), true));
+        assert!(!is_adjacent(UVec2::new(100, 100), UVec2::new(102, 102), true));

        // Test with zero coordinates
-        assert!(is_adjacent((0, 0), (1, 0), false));
-        assert!(is_adjacent((0, 0), (0, 1), false));
-        assert!(is_adjacent((0, 0), (1, 1), true));
+        assert!(is_adjacent(UVec2::new(0, 0), UVec2::new(1, 0), false));
+        assert!(is_adjacent(UVec2::new(0, 0), UVec2::new(0, 1), false));
+        assert!(is_adjacent(UVec2::new(0, 0), UVec2::new(1, 1), true));
    }

    #[test]
    fn test_commutative_property() {
        // The function should work the same regardless of parameter order
        assert_eq!(
-            is_adjacent((1, 2), (2, 2), false),
-            is_adjacent((2, 2), (1, 2), false)
+            is_adjacent(UVec2::new(1, 2), UVec2::new(2, 2), false),
+            is_adjacent(UVec2::new(2, 2), UVec2::new(1, 2), false)
        );

        assert_eq!(
-            is_adjacent((1, 2), (2, 3), true),
-            is_adjacent((2, 3), (1, 2), true)
+            is_adjacent(UVec2::new(1, 2), UVec2::new(2, 3), true),
+            is_adjacent(UVec2::new(2, 3), UVec2::new(1, 2), true)
        );
    }
 }
--- a/src/main.rs
+++ b/src/main.rs
@@ -11,7 +11,7 @@ use tracing_subscriber::layer::SubscriberExt;

 #[cfg(windows)]
 use winapi::{
-    shared::{ntdef::NULL, windef::HWND},
+    shared::ntdef::NULL,
    um::{
        fileapi::{CreateFileA, OPEN_EXISTING},
        handleapi::INVALID_HANDLE_VALUE,
@@ -29,13 +29,13 @@ use winapi::{
 /// terminal, this function does nothing.
 #[cfg(windows)]
 unsafe fn attach_console() {
-    if GetConsoleWindow() != std::ptr::null_mut() as HWND {
+    if !std::ptr::eq(GetConsoleWindow(), std::ptr::null_mut()) {
        return;
    }

    if AttachConsole(winapi::um::wincon::ATTACH_PARENT_PROCESS) != 0 {
        let handle = CreateFileA(
-            "CONOUT$\0".as_ptr() as *const i8,
+            c"CONOUT$".as_ptr(),
            GENERIC_READ | GENERIC_WRITE,
            FILE_SHARE_READ | FILE_SHARE_WRITE,
            std::ptr::null_mut(),
@@ -53,9 +53,12 @@ unsafe fn attach_console() {
 }

 mod animation;
+mod asset;
 mod audio;
 mod constants;
+mod debug;
 mod direction;
+mod edible;
 mod entity;
 mod game;
 mod ghost;
@@ -64,8 +67,6 @@ mod helper;
 mod map;
 mod modulation;
 mod pacman;
-mod debug;
-mod edible;

 /// The main entry point of the application.
 ///
@@ -98,26 +99,17 @@ pub fn main() {
        .build()
        .expect("Could not initialize window");

-    let mut canvas = window
-        .into_canvas()
-        .build()
-        .expect("Could not build canvas");
+    let mut canvas = window.into_canvas().build().expect("Could not build canvas");

    canvas
        .set_logical_size(WINDOW_WIDTH, WINDOW_HEIGHT)
        .expect("Could not set logical size");

    let texture_creator = canvas.texture_creator();
-    let mut game = Game::new(
-        &mut canvas,
-        &texture_creator,
-        &ttf_context,
-        &audio_subsystem,
-    );
+    let mut game = Game::new(&mut canvas, &texture_creator, &ttf_context, &audio_subsystem);
+    game.audio.set_mute(cfg!(debug_assertions));

-    let mut event_pump = sdl_context
-        .event_pump()
-        .expect("Could not get SDL EventPump");
+    let mut event_pump = sdl_context.event_pump().expect("Could not get SDL EventPump");

    // Initial draw and tick
    game.draw();
@@ -168,11 +160,7 @@ pub fn main() {
                    ..
                } => {
                    paused = !paused;
-                    event!(
-                        tracing::Level::INFO,
-                        "{}",
-                        if paused { "Paused" } else { "Unpaused" }
-                    );
+                    event!(tracing::Level::INFO, "{}", if paused { "Paused" } else { "Unpaused" });
                }
                Event::KeyDown { keycode, .. } => {
                    game.keyboard_event(keycode.unwrap());
--- a/src/map.rs
+++ b/src/map.rs
@@ -3,48 +3,9 @@ use rand::seq::IteratorRandom;

 use crate::constants::{MapTile, BOARD_OFFSET, CELL_SIZE};
 use crate::constants::{BOARD_HEIGHT, BOARD_WIDTH};
+use glam::{IVec2, UVec2};
+use once_cell::sync::OnceCell;
 use std::collections::{HashSet, VecDeque};
-use std::ops::Add;
-
-#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct SignedPosition {
-    pub x: i32,
-    pub y: i32,
-}
-
-#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct Position {
-    pub x: u32,
-    pub y: u32,
-}
-
-impl Add<SignedPosition> for Position {
-    type Output = Position;
-    fn add(self, rhs: SignedPosition) -> Self::Output {
-        Position {
-            x: (self.x as i32 + rhs.x) as u32,
-            y: (self.y as i32 + rhs.y) as u32,
-        }
-    }
-}
-
-impl PartialEq<(u32, u32)> for Position {
-    fn eq(&self, other: &(u32, u32)) -> bool {
-        self.x == other.0 && self.y == other.1
-    }
-}
-
-impl Position {
-    pub fn as_i32(&self) -> (i32, i32) {
-        (self.x as i32, self.y as i32)
-    }
-    pub fn wrapping_add(&self, dx: i32, dy: i32) -> Position {
-        Position {
-            x: (self.x as i32 + dx) as u32,
-            y: (self.y as i32 + dy) as u32,
-        }
-    }
-}

 /// The game map.
 ///
@@ -66,49 +27,34 @@ impl Map {
    pub fn new(raw_board: [&str; BOARD_HEIGHT as usize]) -> Map {
        let mut map = [[MapTile::Empty; BOARD_HEIGHT as usize]; BOARD_WIDTH as usize];

-        for y in 0..BOARD_HEIGHT as usize {
-            let line = raw_board[y];
-
-            for x in 0..BOARD_WIDTH as usize {
-                if x >= line.len() {
-                    break;
-                }
-
-                let i = (y * (BOARD_WIDTH as usize) + x) as usize;
-                let character = line
-                    .chars()
-                    .nth(x as usize)
-                    .unwrap_or_else(|| panic!("Could not get character at {} = ({}, {})", i, x, y));
-
+        for (y, line) in raw_board.iter().enumerate().take(BOARD_HEIGHT as usize) {
+            for (x, character) in line.chars().enumerate().take(BOARD_WIDTH as usize) {
                let tile = match character {
                    '#' => MapTile::Wall,
                    '.' => MapTile::Pellet,
                    'o' => MapTile::PowerPellet,
                    ' ' => MapTile::Empty,
                    'T' => MapTile::Tunnel,
-                    c @ '0' | c @ '1' | c @ '2' | c @ '3' | c @ '4' => {
-                        MapTile::StartingPosition(c.to_digit(10).unwrap() as u8)
-                    }
+                    c @ '0' | c @ '1' | c @ '2' | c @ '3' | c @ '4' => MapTile::StartingPosition(c.to_digit(10).unwrap() as u8),
                    '=' => MapTile::Empty,
-                    _ => panic!("Unknown character in board: {}", character),
+                    _ => panic!("Unknown character in board: {character}"),
                };
-
-                map[x as usize][y as usize] = tile;
+                map[x][y] = tile;
            }
        }

        Map {
            current: map,
-            default: map.clone(),
+            default: map,
        }
    }

    /// Resets the map to its original state.
    pub fn reset(&mut self) {
        // Restore the map to its original state
-        for x in 0..BOARD_WIDTH as usize {
-            for y in 0..BOARD_HEIGHT as usize {
-                self.current[x][y] = self.default[x][y];
+        for (x, col) in self.current.iter_mut().enumerate().take(BOARD_WIDTH as usize) {
+            for (y, cell) in col.iter_mut().enumerate().take(BOARD_HEIGHT as usize) {
+                *cell = self.default[x][y];
            }
        }
    }
@@ -118,9 +64,9 @@ impl Map {
    /// # Arguments
    ///
    /// * `cell` - The cell coordinates, in grid coordinates.
-    pub fn get_tile(&self, cell: (i32, i32)) -> Option<MapTile> {
-        let x = cell.0 as usize;
-        let y = cell.1 as usize;
+    pub fn get_tile(&self, cell: IVec2) -> Option<MapTile> {
+        let x = cell.x as usize;
+        let y = cell.y as usize;

        if x >= BOARD_WIDTH as usize || y >= BOARD_HEIGHT as usize {
            return None;
@@ -135,9 +81,9 @@ impl Map {
    ///
    /// * `cell` - The cell coordinates, in grid coordinates.
    /// * `tile` - The tile to set.
-    pub fn set_tile(&mut self, cell: (i32, i32), tile: MapTile) -> bool {
-        let x = cell.0 as usize;
-        let y = cell.1 as usize;
+    pub fn set_tile(&mut self, cell: IVec2, tile: MapTile) -> bool {
+        let x = cell.x as usize;
+        let y = cell.y as usize;

        if x >= BOARD_WIDTH as usize || y >= BOARD_HEIGHT as usize {
            return false;
@@ -152,30 +98,24 @@ impl Map {
    /// # Arguments
    ///
    /// * `cell` - The cell coordinates, in grid coordinates.
-    pub fn cell_to_pixel(cell: (u32, u32)) -> (i32, i32) {
-        (
-            (cell.0 * CELL_SIZE) as i32,
-            ((cell.1 + BOARD_OFFSET.1) * CELL_SIZE) as i32,
-        )
+    pub fn cell_to_pixel(cell: UVec2) -> IVec2 {
+        IVec2::new((cell.x * CELL_SIZE) as i32, ((cell.y + BOARD_OFFSET.1) * CELL_SIZE) as i32)
    }

    /// Returns a reference to a cached vector of all valid playable positions in the maze.
    /// This is computed once using a flood fill from a random pellet, and then cached.
-    pub fn get_valid_playable_positions(&mut self) -> &Vec<Position> {
+    pub fn get_valid_playable_positions(&mut self) -> &Vec<UVec2> {
        use MapTile::*;
-        static mut CACHE: Option<Vec<Position>> = None;
-        // SAFETY: This is only mutated once, and only in this function.
-        unsafe {
-            if let Some(ref cached) = CACHE {
-                return cached;
-            }
+        static CACHE: OnceCell<Vec<UVec2>> = OnceCell::new();
+        if let Some(cached) = CACHE.get() {
+            return cached;
        }
        // Find a random starting pellet
        let mut pellet_positions = vec![];
-        for x in 0..BOARD_WIDTH as u32 {
-            for y in 0..BOARD_HEIGHT as u32 {
-                match self.current[x as usize][y as usize] {
-                    Pellet | PowerPellet => pellet_positions.push(Position { x, y }),
+        for (x, col) in self.current.iter().enumerate().take(BOARD_WIDTH as usize) {
+            for (y, &cell) in col.iter().enumerate().take(BOARD_HEIGHT as usize) {
+                match cell {
+                    Pellet | PowerPellet => pellet_positions.push(UVec2::new(x as u32, y as u32)),
                    _ => {}
                }
            }
@@ -191,41 +131,27 @@ impl Map {

        queue.push_back(start);
        while let Some(pos) = queue.pop_front() {
-            // Mark visited, skip if already visited
            if !visited.insert(pos) {
                continue;
            }

-            // Check if the current tile is valid
            match self.current[pos.x as usize][pos.y as usize] {
                Empty | Pellet | PowerPellet => {
-                    // Valid, continue flood
-                    for offset in [
-                        SignedPosition { x: -1, y: 0 },
-                        SignedPosition { x: 1, y: 0 },
-                        SignedPosition { x: 0, y: -1 },
-                        SignedPosition { x: 0, y: 1 },
-                    ] {
-                        let neighbor = pos + offset;
-                        if neighbor.x < BOARD_WIDTH as u32 && neighbor.y < BOARD_HEIGHT as u32 {
-                            let neighbor_tile =
-                                self.current[neighbor.x as usize][neighbor.y as usize];
+                    for offset in [IVec2::new(-1, 0), IVec2::new(1, 0), IVec2::new(0, -1), IVec2::new(0, 1)] {
+                        let neighbor = (pos.as_ivec2() + offset).as_uvec2();
+                        if neighbor.x < BOARD_WIDTH && neighbor.y < BOARD_HEIGHT {
+                            let neighbor_tile = self.current[neighbor.x as usize][neighbor.y as usize];
                            if matches!(neighbor_tile, Empty | Pellet | PowerPellet) {
                                queue.push_back(neighbor);
                            }
                        }
                    }
                }
-                StartingPosition(_) | Wall | Tunnel => {
-                    // Not valid, do not continue
-                }
+                StartingPosition(_) | Wall | Tunnel => {}
            }
        }
-        let mut result: Vec<Position> = visited.into_iter().collect();
-        result.sort_unstable();
-        unsafe {
-            CACHE = Some(result);
-            CACHE.as_ref().unwrap()
-        }
+        let mut result: Vec<UVec2> = visited.into_iter().collect();
+        result.sort_unstable_by_key(|v| (v.x, v.y));
+        CACHE.get_or_init(|| result)
    }
 }
--- a/src/pacman.rs
+++ b/src/pacman.rs
@@ -6,7 +6,6 @@ use sdl2::{
    render::{Canvas, Texture},
    video::Window,
 };
-use tracing::event;

 use crate::{
    animation::{AnimatedAtlasTexture, FrameDrawn},
@@ -16,6 +15,8 @@ use crate::{
    modulation::{SimpleTickModulator, TickModulator},
 };

+use glam::{IVec2, UVec2};
+
 /// The Pac-Man entity.
 pub struct Pacman<'a> {
    /// Shared movement and position fields.
@@ -40,7 +41,7 @@ impl<'a> Moving for Pacman<'a> {
    fn update_cell_position(&mut self) {
        self.base.update_cell_position();
    }
-    fn next_cell(&self, direction: Option<Direction>) -> (i32, i32) {
+    fn next_cell(&self, direction: Option<Direction>) -> IVec2 {
        self.base.next_cell(direction)
    }
    fn is_wall_ahead(&self, direction: Option<Direction>) -> bool {
@@ -59,11 +60,7 @@ impl<'a> Moving for Pacman<'a> {

 impl Pacman<'_> {
    /// Creates a new `Pacman` instance.
-    pub fn new<'a>(
-        starting_position: (u32, u32),
-        atlas: Texture<'a>,
-        map: Rc<RefCell<Map>>,
-    ) -> Pacman<'a> {
+    pub fn new<'a>(starting_position: UVec2, atlas: Texture<'a>, map: Rc<RefCell<Map>>) -> Pacman<'a> {
        let pixel_position = Map::cell_to_pixel(starting_position);
        Pacman {
            base: MovableEntity::new(
@@ -95,13 +92,13 @@ impl Pacman<'_> {
    }

    /// Returns the internal position of Pac-Man, rounded down to the nearest even number.
-    fn internal_position_even(&self) -> (u32, u32) {
-        let (x, y) = self.base.internal_position();
-        ((x / 2u32) * 2u32, (y / 2u32) * 2u32)
+    fn internal_position_even(&self) -> UVec2 {
+        let pos = self.base.internal_position();
+        UVec2::new((pos.x / 2) * 2, (pos.y / 2) * 2)
    }

    pub fn tick(&mut self) {
-        let can_change = self.internal_position_even() == (0, 0);
+        let can_change = self.internal_position_even() == UVec2::ZERO;
        if can_change {
            <Pacman as Moving>::update_cell_position(self);
            if !<Pacman as Moving>::handle_tunnel(self) {
@@ -115,7 +112,7 @@ impl Pacman<'_> {
        }
        if !self.stopped && self.base.modulation.next() {
            <Pacman as Moving>::move_forward(self);
-            if self.internal_position_even() == (0, 0) {
+            if self.internal_position_even() == UVec2::ZERO {
                <Pacman as Moving>::update_cell_position(self);
            }
        }
@@ -127,9 +124,9 @@ impl Renderable for Pacman<'_> {
        let pos = self.base.base.pixel_position;
        let dir = self.base.direction;
        if self.stopped {
-            self.sprite.render(canvas, pos, dir, Some(2));
+            self.sprite.render(canvas, (pos.x, pos.y), dir, Some(2));
        } else {
-            self.sprite.render(canvas, pos, dir, None);
+            self.sprite.render(canvas, (pos.x, pos.y), dir, None);
        }
    }
 }
Author	SHA1	Message	Date
Xevion	ec800a88fc	fix: use sdl2 internal methods for loading resources for emscripten asset handling	2025-07-24 01:07:22 -05:00
Xevion	abc37dee4e	ci: fix vcpkg cache keys to use target for platforms with multiple targets, allow restore oldkey	2025-07-24 01:04:21 -05:00
Xevion	1ae7839275	ci: install zlib for linux builds, correct deps/.data filepath	2025-07-24 01:04:21 -05:00
Xevion	d976d1bc59	ci: specify vcpkg triplets for macos targets	2025-07-24 00:49:22 -05:00
Xevion	531a5b5d05	ci: inline build script contents, shorten assembly process, separate build/assemble steps	2025-07-24 00:48:49 -05:00
Xevion	67713fab06	ci: add aarch64-apple-drawin target	2025-07-24 00:46:06 -05:00
Xevion	b572729e9d	feat: reorganize assets/ folder into web/ and game/	2025-07-24 00:46:06 -05:00
Xevion	cdc6979458	ci: add cache vcpkg step, remove ineffective apt pkgs	2025-07-24 00:09:43 -05:00
Xevion	564f88fee5	ci: use proper vcpkg triplet for linux, macos	2025-07-24 00:09:43 -05:00
Xevion	00c99dc05f	ci: remove 'stable' from vcpkg target triplet key	2025-07-23 23:55:15 -05:00
Xevion	1e12940445	docs: remove unused markdown files in root	2025-07-23 23:24:30 -05:00
Xevion	dc3c4a7580	ci: VCPKG_SYSTEM_LIBRARIES off, cache emsdk, raw jq output	2025-07-23 23:23:41 -05:00
Xevion	434b62b036	ci: use cargo metadata with jq for acquiring workspace package version, drop binstall	2025-07-23 23:12:58 -05:00
Xevion	2bd523e58a	ci: add build-essential dependency, apt-get update before	2025-07-23 23:05:06 -05:00
Xevion	7cd6e8005e	ci: add names to workflow jobs, configure binstall to have lower timeout	2025-07-23 22:58:09 -05:00
Xevion	a8a3745ca1	ci: disable fail-fast, ensure linux vcpkg dependencies are installed	2025-07-23 22:46:57 -05:00
Xevion	cfa26bf146	ci: use build matrix for desktop builds	2025-07-23 22:45:56 -05:00
Xevion	bfbbb71752	ci: verbose vcpkg builds on linux	2025-07-23 22:30:11 -05:00
Xevion	979f736f54	ci: drop rust toolchain to 1.86.0	2025-07-23 22:26:08 -05:00
Xevion	5a7f6a4c10	ci: remove archive assembly steps for statically linked builds	2025-07-23 22:22:55 -05:00
Xevion	b66c9ce135	fix: emscripten assets	2025-07-23 22:18:54 -05:00
Xevion	f5363516c3	chore: remove unused sdl2-image vcpkg features	2025-07-23 21:53:55 -05:00
Xevion	320da36b83	feat: use cargo-vcpkg in build workflow	2025-07-23 21:53:03 -05:00
Xevion	b68813cf5b	ci: explicit toolchain version, fix build script path for wasm	2025-07-23 21:53:03 -05:00
Xevion	0806fc744c	chore: remove unused animation pausing methods	2025-07-23 21:34:27 -05:00
Xevion	eead31d7fc	refactor: add 'glam' for better positioning types, drop position types	2025-07-23 21:24:47 -05:00
Xevion	eaa4ab37f9	feat: add audio muting button, mute by default in debug builds	2025-07-23 21:00:52 -05:00
Xevion	076275158e	chore: lower audio tracing to trace level	2025-07-23 20:36:56 -05:00
Xevion	9f9ace0b16	chore: configure rustfmt, switch to LF line endings	2025-07-23 20:15:54 -05:00
Xevion	2cc47d5904	feat: add pre-comit configuration	2025-07-23 20:12:11 -05:00
Xevion	11e89a63d0	refactor: add thiserror/anyhow for asset error handling	2025-07-23 19:47:44 -05:00
Xevion	50afd8c09f	feat: improved emscripten-compatible asset loading api	2025-07-23 18:02:19 -05:00
Xevion	06841fd0d7	refactor: resolve clippy warnings, resolve shared reference with once_cell	2025-07-23 17:38:27 -05:00
Xevion	4365639a1d	chore: lifetimes	2025-07-23 17:31:16 -05:00
Xevion	7744c06046	chore: cargo fix	2025-07-23 17:27:22 -05:00
Xevion	978752f0f3	chore: add index for FruitType sprite	2025-07-23 17:25:39 -05:00
Xevion	f024ce7a54	refactor: fix unnecessary qualified imports	2025-07-23 17:25:28 -05:00
Xevion	0196282a78	fix: reset code borrows	2025-07-23 17:20:12 -05:00