fix: clippy inline format args

.config/nextest.toml

@@ -1,5 +1,2 @@
 [profile.default]
 fail-fast = false
-
-[profile.coverage]
-status-level = "none"

.github/dependabot.yml

@@ -1,20 +0,0 @@
-# https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
-
-version: 2
-updates:
-  - package-ecosystem: "cargo"
-    directory: "/"
-    schedule:
-      interval: "monthly"
-    groups:
-      dependencies:
-        patterns:
-          - "*"
-  - package-ecosystem: "github-actions"
-    directory: "/"
-    schedule:
-      interval: "monthly"
-    groups:
-      dependencies:
-        patterns:
-          - "*"

.github/workflows/build.yaml

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

.github/workflows/coverage.yaml

@@ -11,7 +11,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout code
-        uses: actions/checkout@v5
+        uses: actions/checkout@v4
 
       - name: Install Rust toolchain
         uses: dtolnay/rust-toolchain@master
@@ -42,39 +42,15 @@ jobs:
 
       - uses: taiki-e/install-action@cargo-llvm-cov
       - uses: taiki-e/install-action@nextest
-      - uses: taiki-e/install-action@just
 
+      # Note: We manually link zlib. This should be synchronized with the flags set for Linux in .cargo/config.toml.
       - name: Generate coverage report
         run: |
-          just coverage
-
-      - name: Download Coveralls CLI
-        run: |
-          # use GitHub Releases URL instead of coveralls.io because they can't maintain their own files; it 404s
-          curl -L https://github.com/coverallsapp/coverage-reporter/releases/download/v0.6.15/coveralls-linux-x86_64.tar.gz | tar -xz -C /usr/local/bin
+          cargo llvm-cov --no-fail-fast --lcov --output-path lcov.info nextest
 
       - name: Upload coverage to Coveralls
-        env:
-          COVERALLS_REPO_TOKEN: ${{ secrets.COVERALLS_REPO_TOKEN }}
-        run: |
-          if [ ! -f "lcov.info" ]; then
-            echo "Error: lcov.info file not found. Coverage generation may have failed."
-            exit 1
-          fi
-
-          for i in {1..10}; do
-            echo "Attempt $i: Uploading coverage to Coveralls..."
-            if coveralls -n report lcov.info; then
-              echo "Successfully uploaded coverage report."
-              exit 0
-            fi
-
-            if [ $i -lt 10 ]; then
-              delay=$((2**i))
-              echo "Attempt $i failed. Retrying in $delay seconds..."
-              sleep $delay
-            fi
-          done
-
-          echo "Failed to upload coverage report after 10 attempts."
-          exit 1
+        uses: coverallsapp/github-action@v2
+        with:
+          files: ./lcov.info
+          format: lcov
+          allow-empty: false

.github/workflows/tests.yaml

@@ -4,7 +4,7 @@ on: ["push", "pull_request"]
 
 env:
   CARGO_TERM_COLOR: always
-  RUST_TOOLCHAIN: 1.86.0
+  RUST_TOOLCHAIN: 1.88.0
 
 jobs:
   test:
@@ -12,7 +12,7 @@ jobs:
 
     steps:
       - name: Checkout code
-        uses: actions/checkout@v5
+        uses: actions/checkout@v4
 
       - name: Install Rust toolchain
         uses: dtolnay/rust-toolchain@master

.gitignore

@@ -1,17 +1,7 @@
-# IDE, Other files
-.vscode
-.idea
-rust-sdl2-emscripten/
-
-# Build files
 target/
 dist/
 emsdk/
-
-# Site build f iles
-tailwindcss-*
+.idea
+rust-sdl2-emscripten/
 assets/site/build.css
-
-# Coverage reports
-lcov.info
-coverage.html
+tailwindcss-*

Cargo.lock

@@ -13,9 +13,9 @@ dependencies = [
 
 [[package]]
 name = "anyhow"
-version = "1.0.99"
+version = "1.0.98"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0674a1ddeecb70197781e945de4b3b8ffb61fa939a5597bcf48503737663100"
+checksum = "e16d2d3311acee920a9eb8d33b8cbc1787ce4a264e85f964c2404b969bdcd487"
 
 [[package]]
 name = "autocfg"
@@ -79,9 +79,9 @@ dependencies = [
 
 [[package]]
 name = "glam"
-version = "0.30.5"
+version = "0.30.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2d1aab06663bdce00d6ca5e5ed586ec8d18033a771906c993a1e3755b368d85"
+checksum = "50a99dbe56b72736564cfa4b85bf9a33079f16ae8b74983ab06af3b1a3696b11"
 
 [[package]]
 name = "hashbrown"
@@ -89,12 +89,6 @@ version = "0.15.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5971ac85611da7067dbfcabef3c70ebb5606018acd9e2a3903a0da507521e0d5"
 
-[[package]]
-name = "heck"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
-
 [[package]]
 name = "indexmap"
 version = "2.10.0"
@@ -128,9 +122,9 @@ checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
 
 [[package]]
 name = "libc"
-version = "0.2.175"
+version = "0.2.174"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a82ae493e598baaea5209805c49bbf2ea7de956d50d7da0da1164f9c6d28543"
+checksum = "1171693293099992e19cddea4e8b849964e9846f4acee11b3948bcc337be8776"
 
 [[package]]
 name = "log"
@@ -194,16 +188,13 @@ dependencies = [
  "libc",
  "once_cell",
  "pathfinding",
- "phf",
- "rand 0.9.2",
+ "rand",
  "sdl2",
  "serde",
  "serde_json",
  "smallvec",
  "spin_sleep",
- "strum",
- "strum_macros",
- "thiserror",
+ "thiserror 1.0.69",
  "tracing",
  "tracing-error",
  "tracing-subscriber",
@@ -221,49 +212,7 @@ dependencies = [
  "integer-sqrt",
  "num-traits",
  "rustc-hash",
- "thiserror",
-]
-
-[[package]]
-name = "phf"
-version = "0.11.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1fd6780a80ae0c52cc120a26a1a42c1ae51b247a253e4e06113d23d2c2edd078"
-dependencies = [
- "phf_macros",
- "phf_shared",
-]
-
-[[package]]
-name = "phf_generator"
-version = "0.11.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c80231409c20246a13fddb31776fb942c38553c51e871f8cbd687a4cfb5843d"
-dependencies = [
- "phf_shared",
- "rand 0.8.5",
-]
-
-[[package]]
-name = "phf_macros"
-version = "0.11.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f84ac04429c13a7ff43785d75ad27569f2951ce0ffd30a3321230db2fc727216"
-dependencies = [
- "phf_generator",
- "phf_shared",
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "phf_shared"
-version = "0.11.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "67eabc2ef2a60eb7faa00097bd1ffdb5bd28e62bf39990626a582201b7a754e5"
-dependencies = [
- "siphasher",
+ "thiserror 2.0.12",
 ]
 
 [[package]]
@@ -296,30 +245,15 @@ version = "5.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
 
-[[package]]
-name = "rand"
-version = "0.8.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
-dependencies = [
- "rand_core 0.6.4",
-]
-
 [[package]]
 name = "rand"
 version = "0.9.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"
 dependencies = [
- "rand_core 0.9.3",
+ "rand_core",
 ]
 
-[[package]]
-name = "rand_core"
-version = "0.6.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
-
 [[package]]
 name = "rand_core"
 version = "0.9.3"
@@ -438,9 +372,9 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.142"
+version = "1.0.141"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "030fedb782600dcbd6f02d479bf0d817ac3bb40d644745b769d6a96bc3afc5a7"
+checksum = "30b9eff21ebe718216c6ec64e1d9ac57087aad11efc64e32002bce4a0d4c03d3"
 dependencies = [
  "itoa",
  "memchr",
@@ -457,12 +391,6 @@ dependencies = [
  "lazy_static",
 ]
 
-[[package]]
-name = "siphasher"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56199f7ddabf13fe5074ce809e7d3f42b42ae711800501b5b16ea82ad029c39d"
-
 [[package]]
 name = "smallvec"
 version = "1.15.1"
@@ -478,24 +406,6 @@ dependencies = [
  "windows-sys",
 ]
 
-[[package]]
-name = "strum"
-version = "0.27.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af23d6f6c1a224baef9d3f61e287d2761385a5b88fdab4eb4c6f11aeb54c4bcf"
-
-[[package]]
-name = "strum_macros"
-version = "0.27.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7695ce3845ea4b33927c055a39dc438a45b059f7c1b3d91d38d10355fb8cbca7"
-dependencies = [
- "heck",
- "proc-macro2",
- "quote",
- "syn",
-]
-
 [[package]]
 name = "syn"
 version = "2.0.104"
@@ -507,13 +417,33 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "thiserror"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
+dependencies = [
+ "thiserror-impl 1.0.69",
+]
+
 [[package]]
 name = "thiserror"
 version = "2.0.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "567b8a2dae586314f7be2a752ec7474332959c6460e02bde30d702a66d488708"
 dependencies = [
- "thiserror-impl",
+ "thiserror-impl 2.0.12",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
 ]
 
 [[package]]

Cargo.toml

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

Justfile

@@ -1,33 +0,0 @@
-set shell := ["bash", "-c"]
-set windows-shell := ["powershell.exe", "-NoLogo", "-Command"]
-
-# Regex to exclude files from coverage report, double escapes for Justfile + CLI
-# You can use src\\\\..., but the filename alone is acceptable too
-coverage_exclude_pattern := "src\\\\app.rs|audio.rs|src\\\\error.rs|platform\\\\emscripten.rs"
-
-# !!! --ignore-filename-regex should be used on both reports & coverage testing
-# !!! --remap-path-prefix prevents the absolute path from being used in the generated report
-
-# Generate HTML report (for humans, source line inspection)
-html: coverage
-    cargo llvm-cov report \
-    --remap-path-prefix \
-    --ignore-filename-regex "{{ coverage_exclude_pattern }}" \
-    --html \
-    --open
-
-# Display report (for humans)
-report-coverage: coverage
-    cargo llvm-cov report \
-    --remap-path-prefix \
-    --ignore-filename-regex "{{ coverage_exclude_pattern }}"
-
-# Run & generate report (for CI)
-coverage:
-    cargo llvm-cov \
-    --lcov \
-    --remap-path-prefix \
-    --ignore-filename-regex "{{ coverage_exclude_pattern }}" \
-    --output-path lcov.info \
-    --profile coverage \
-    --no-fail-fast nextest

README.md

@@ -2,14 +2,14 @@
 
 [![Tests Status][badge-test]][test] [![Build Status][badge-build]][build] [![Code Coverage][badge-coverage]][coverage] [![Online Demo][badge-online-demo]][demo] [![Last Commit][badge-last-commit]][commits]
 
-[badge-test]: https://github.com/Xevion/Pac-Man/actions/workflows/tests.yaml/badge.svg
+[badge-test]: https://github.com/Xevion/Pac-Man/actions/workflows/test.yaml/badge.svg
 [badge-build]: https://github.com/Xevion/Pac-Man/actions/workflows/build.yaml/badge.svg
 [badge-coverage]: https://coveralls.io/repos/github/Xevion/Pac-Man/badge.svg?branch=master
 [badge-demo]: https://img.shields.io/github/deployments/Xevion/Pac-Man/github-pages?label=GitHub%20Pages
 [badge-online-demo]: https://img.shields.io/badge/GitHub%20Pages-Demo-brightgreen
 [badge-last-commit]: https://img.shields.io/github/last-commit/Xevion/Pac-Man
 [build]: https://github.com/Xevion/Pac-Man/actions/workflows/build.yaml
-[test]: https://github.com/Xevion/Pac-Man/actions/workflows/tests.yaml
+[test]: https://github.com/Xevion/Pac-Man/actions/workflows/test.yaml
 [coverage]: https://coveralls.io/github/Xevion/Pac-Man?branch=master
 [demo]: https://xevion.github.io/Pac-Man/
 [commits]: https://github.com/Xevion/Pac-Man/commits/master
@@ -72,8 +72,6 @@ I wanted to hit a log of goals and features, making it a 'perfect' project that
 
 Since this project is still in progress, I'm only going to cover non-obvious build details. By reading the code, build scripts, and copying the online build workflows, you should be able to replicate the build process.
 
-- We use rustc 1.86.0 for the build, due to bulk-memory-opt related issues on wasm32-unknown-emscripten.
-  - Technically, we could probably use stable or even nightly on desktop targets, but using different versions for different targets is a pain, mainly because of clippy warnings changing between versions.
 - Install `cargo-vcpkg` with `cargo install cargo-vcpkg`, then run `cargo vcpkg build` to build the requisite dependencies via vcpkg.
 - For the WASM build, you need to have the Emscripten SDK cloned; you can do so with `git clone https://github.com/emscripten-core/emsdk.git`
   - The first time you clone, you'll need to install the appropriate SDK version with `./emsdk install 3.1.43` and then activate it with `./emsdk activate 3.1.43`. On Windows, use `./emsdk/emsdk.ps1` instead.

bacon.toml

@@ -1,86 +0,0 @@
-# This is a configuration file for the bacon tool
-#
-# Complete help on configuration: https://dystroy.org/bacon/config/
-#
-# You may check the current default at
-#   https://github.com/Canop/bacon/blob/main/defaults/default-bacon.toml
-
-default_job = "check"
-env.CARGO_TERM_COLOR = "always"
-
-[jobs.check]
-command = ["cargo", "check"]
-need_stdout = false
-
-[jobs.check-all]
-command = ["cargo", "check", "--all-targets"]
-need_stdout = false
-
-# Run clippy on the default target
-[jobs.clippy]
-command = ["cargo", "clippy"]
-need_stdout = false
-
-# Run clippy on all targets
-[jobs.clippy-all]
-command = ["cargo", "clippy", "--all-targets"]
-need_stdout = false
-
-[jobs.test]
-command = [
-    "cargo", "nextest", "run",
-    "--hide-progress-bar", "--failure-output", "final"
-]
-need_stdout = true
-analyzer = "nextest"
-
-[jobs.coverage]
-command = [
-    "just", "report-coverage"
-]
-need_stdout = true
-ignored_lines = [
-    "info:",
-    "\\s+Compiling",
-    "test result: ok",
-    "^\\s*$",
-    "running \\d+ test",
-    "Nextest run ID",
-    "[─]+",
-    "test.+ok",
-    "PASS|START",
-    "Starting \\d+ test",
-    "\\s*#",
-    "\\s*Finished.+in \\d+",
-    "\\s*Summary\\s+\\[",
-    "\\s*Blocking",
-    "Finished report saved to"
-]
-on_change_strategy = "wait_then_restart"
-
-[jobs.doc]
-command = ["cargo", "doc", "--no-deps"]
-need_stdout = false
-
-# If the doc compiles, then it opens in your browser and bacon switches to the previous job
-[jobs.doc-open]
-command = ["cargo", "doc", "--no-deps", "--open"]
-need_stdout = false
-on_success = "back" # so that we don't open the browser at each change
-
-[jobs.run]
-command = [
-    "cargo", "run",
-]
-need_stdout = true
-allow_warnings = true
-background = false
-on_change_strategy = "kill_then_restart"
-# kill = ["pkill", "-TERM", "-P"]'
-
-[keybindings]
-c = "job:clippy"
-alt-c = "job:check"
-ctrl-alt-c = "job:check-all"
-shift-c = "job:clippy-all"
-f = "job:coverage"

build.rs

@@ -1,50 +0,0 @@
-use std::collections::HashMap;
-use std::env;
-use std::fs::File;
-use std::io::{BufWriter, Write};
-use std::path::Path;
-
-use serde::Deserialize;
-
-#[derive(Debug, Deserialize)]
-struct AtlasMapper {
-    frames: HashMap<String, MapperFrame>,
-}
-
-#[derive(Copy, Clone, Debug, Deserialize)]
-struct MapperFrame {
-    x: u16,
-    y: u16,
-    width: u16,
-    height: u16,
-}
-
-fn main() {
-    let path = Path::new(&env::var("OUT_DIR").unwrap()).join("atlas_data.rs");
-    let mut file = BufWriter::new(File::create(&path).unwrap());
-
-    let atlas_json = include_str!("./assets/game/atlas.json");
-    let atlas_mapper: AtlasMapper = serde_json::from_str(atlas_json).unwrap();
-
-    writeln!(&mut file, "use phf::phf_map;").unwrap();
-
-    writeln!(&mut file, "use crate::texture::sprite::MapperFrame;").unwrap();
-
-    writeln!(
-        &mut file,
-        "pub static ATLAS_FRAMES: phf::Map<&'static str, MapperFrame> = phf_map! {{"
-    )
-    .unwrap();
-
-    for (name, frame) in atlas_mapper.frames {
-        writeln!(
-            &mut file,
-            "    \"{}\" => MapperFrame {{ x: {}, y: {}, width: {}, height: {} }},",
-            name, frame.x, frame.y, frame.width, frame.height
-        )
-        .unwrap();
-    }
-
-    writeln!(&mut file, "}};").unwrap();
-    println!("cargo:rerun-if-changed=assets/game/atlas.json");
-}

rust-toolchain.toml

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

src/app.rs

@@ -1,44 +1,37 @@
 use std::time::{Duration, Instant};
 
+use anyhow::{anyhow, Result};
 use glam::Vec2;
 use sdl2::event::{Event, WindowEvent};
 use sdl2::keyboard::Keycode;
 use sdl2::render::{Canvas, ScaleMode, Texture, TextureCreator};
-use sdl2::ttf::Sdl2TtfContext;
 use sdl2::video::{Window, WindowContext};
-use sdl2::{AudioSubsystem, EventPump, Sdl, VideoSubsystem};
+use sdl2::EventPump;
 use tracing::{error, event};
 
-use crate::error::{GameError, GameResult};
-
 use crate::constants::{CANVAS_SIZE, LOOP_TIME, SCALE};
 use crate::game::Game;
 use crate::platform::get_platform;
 
-pub struct App {
+pub struct App<'a> {
     game: Game,
     canvas: Canvas<Window>,
-    event_pump: &'static mut EventPump,
-    backbuffer: Texture<'static>,
+    event_pump: EventPump,
+    backbuffer: Texture<'a>,
     paused: bool,
     last_tick: Instant,
     cursor_pos: Vec2,
 }
 
-impl App {
-    pub fn new() -> GameResult<Self> {
-        let sdl_context: &'static Sdl = Box::leak(Box::new(sdl2::init().map_err(|e| GameError::Sdl(e.to_string()))?));
-        let video_subsystem: &'static VideoSubsystem =
-            Box::leak(Box::new(sdl_context.video().map_err(|e| GameError::Sdl(e.to_string()))?));
-        let _audio_subsystem: &'static AudioSubsystem =
-            Box::leak(Box::new(sdl_context.audio().map_err(|e| GameError::Sdl(e.to_string()))?));
-        let _ttf_context: &'static Sdl2TtfContext =
-            Box::leak(Box::new(sdl2::ttf::init().map_err(|e| GameError::Sdl(e.to_string()))?));
-        let event_pump: &'static mut EventPump =
-            Box::leak(Box::new(sdl_context.event_pump().map_err(|e| GameError::Sdl(e.to_string()))?));
-
+impl App<'_> {
+    pub fn new() -> Result<Self> {
         // Initialize platform-specific console
-        get_platform().init_console()?;
+        get_platform().init_console().map_err(|e| anyhow!(e))?;
+
+        let sdl_context = sdl2::init().map_err(|e| anyhow!(e))?;
+        let video_subsystem = sdl_context.video().map_err(|e| anyhow!(e))?;
+        let audio_subsystem = sdl_context.audio().map_err(|e| anyhow!(e))?;
+        let ttf_context = sdl2::ttf::init().map_err(|e| anyhow!(e.to_string()))?;
 
         let window = video_subsystem
             .window(
@@ -48,35 +41,24 @@ impl App {
             )
             .resizable()
             .position_centered()
-            .build()
-            .map_err(|e| GameError::Sdl(e.to_string()))?;
+            .build()?;
 
-        let mut canvas = window
-            .into_canvas()
-            .accelerated()
-            .present_vsync()
-            .build()
-            .map_err(|e| GameError::Sdl(e.to_string()))?;
+        let mut canvas = window.into_canvas().build()?;
+        canvas.set_logical_size(CANVAS_SIZE.x, CANVAS_SIZE.y)?;
 
-        canvas
-            .set_logical_size(CANVAS_SIZE.x, CANVAS_SIZE.y)
-            .map_err(|e| GameError::Sdl(e.to_string()))?;
+        let texture_creator_static: &'static TextureCreator<WindowContext> = Box::leak(Box::new(canvas.texture_creator()));
 
-        let texture_creator: &'static TextureCreator<WindowContext> = Box::leak(Box::new(canvas.texture_creator()));
+        let mut game = Game::new(texture_creator_static, &ttf_context, &audio_subsystem);
+        game.audio.set_mute(cfg!(debug_assertions));
 
-        let mut game = Game::new(texture_creator)?;
-        // game.audio.set_mute(cfg!(debug_assertions));
-
-        let mut backbuffer = texture_creator
-            .create_texture_target(None, CANVAS_SIZE.x, CANVAS_SIZE.y)
-            .map_err(|e| GameError::Sdl(e.to_string()))?;
+        let mut backbuffer = texture_creator_static.create_texture_target(None, CANVAS_SIZE.x, CANVAS_SIZE.y)?;
         backbuffer.set_scale_mode(ScaleMode::Nearest);
 
+        let event_pump = sdl_context.event_pump().map_err(|e| anyhow!(e))?;
+
         // Initial draw
-        game.draw(&mut canvas, &mut backbuffer)
-            .map_err(|e| GameError::Sdl(e.to_string()))?;
-        game.present_backbuffer(&mut canvas, &backbuffer, glam::Vec2::ZERO)
-            .map_err(|e| GameError::Sdl(e.to_string()))?;
+        game.draw(&mut canvas, &mut backbuffer)?;
+        game.present_backbuffer(&mut canvas, &backbuffer, glam::Vec2::ZERO)?;
 
         Ok(Self {
             game,
@@ -125,10 +107,10 @@ impl App {
                         keycode: Some(Keycode::Space),
                         ..
                     } => {
-                        self.game.toggle_debug_mode();
+                        self.game.debug_mode = !self.game.debug_mode;
                     }
-                    Event::KeyDown { keycode: Some(key), .. } => {
-                        self.game.keyboard_event(key);
+                    Event::KeyDown { keycode, .. } => {
+                        self.game.keyboard_event(keycode.unwrap());
                     }
                     Event::MouseMotion { x, y, .. } => {
                         // Convert window coordinates to logical coordinates
@@ -144,13 +126,13 @@ impl App {
             if !self.paused {
                 self.game.tick(dt);
                 if let Err(e) = self.game.draw(&mut self.canvas, &mut self.backbuffer) {
-                    error!("Failed to draw game: {}", e);
+                    error!("Failed to draw game: {e}");
                 }
                 if let Err(e) = self
                     .game
                     .present_backbuffer(&mut self.canvas, &self.backbuffer, self.cursor_pos)
                 {
-                    error!("Failed to present backbuffer: {}", e);
+                    error!("Failed to present backbuffer: {e}");
                 }
             }
 

src/asset.rs

@@ -3,15 +3,28 @@
 //! On desktop, assets are embedded using include_bytes!; on Emscripten, assets are loaded from the filesystem.
 
 use std::borrow::Cow;
-use strum_macros::EnumIter;
+use std::io;
+use thiserror::Error;
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, EnumIter)]
+#[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,
     Atlas,
+    AtlasJson,
+    // Add more as needed
 }
 
 impl Asset {
@@ -24,16 +37,15 @@ impl Asset {
             Wav3 => "sound/waka/3.ogg",
             Wav4 => "sound/waka/4.ogg",
             Atlas => "atlas.png",
+            AtlasJson => "atlas.json",
         }
     }
 }
 
 mod imp {
     use super::*;
-    use crate::error::AssetError;
     use crate::platform::get_platform;
 
-    /// Returns the raw bytes of the given asset.
     pub fn get_asset_bytes(asset: Asset) -> Result<Cow<'static, [u8]>, AssetError> {
         get_platform().get_asset_bytes(asset)
     }

src/constants.rs

@@ -18,6 +18,8 @@ pub const SCALE: f32 = 2.6;
 pub const BOARD_CELL_OFFSET: UVec2 = UVec2::new(0, 3);
 /// The offset of the game board from the top-left corner of the window, in pixels.
 pub const BOARD_PIXEL_OFFSET: UVec2 = UVec2::new(BOARD_CELL_OFFSET.x * CELL_SIZE, BOARD_CELL_OFFSET.y * CELL_SIZE);
+/// The size of the game board, in pixels.
+pub const BOARD_PIXEL_SIZE: UVec2 = UVec2::new(BOARD_CELL_SIZE.x * CELL_SIZE, BOARD_CELL_SIZE.y * CELL_SIZE);
 /// The size of the canvas, in pixels.
 pub const CANVAS_SIZE: UVec2 = UVec2::new(
     (BOARD_CELL_SIZE.x + BOARD_CELL_OFFSET.x) * CELL_SIZE,

src/entity/collision.rs

@@ -1,128 +0,0 @@
-use smallvec::SmallVec;
-use std::collections::HashMap;
-
-use crate::entity::{graph::NodeId, traversal::Position};
-
-/// Trait for entities that can participate in collision detection.
-pub trait Collidable {
-    /// Returns the current position of this entity.
-    fn position(&self) -> Position;
-
-    /// Checks if this entity is colliding with another entity.
-    #[allow(dead_code)]
-    fn is_colliding_with(&self, other: &dyn Collidable) -> bool {
-        positions_overlap(&self.position(), &other.position())
-    }
-}
-
-/// System for tracking entities by their positions for efficient collision detection.
-#[derive(Default)]
-pub struct CollisionSystem {
-    /// Maps node IDs to lists of entity IDs that are at that node
-    node_entities: HashMap<NodeId, Vec<EntityId>>,
-    /// Maps entity IDs to their current positions
-    entity_positions: HashMap<EntityId, Position>,
-    /// Next available entity ID
-    next_id: EntityId,
-}
-
-/// Unique identifier for an entity in the collision system
-pub type EntityId = u32;
-
-impl CollisionSystem {
-    /// Registers an entity with the collision system and returns its ID
-    pub fn register_entity(&mut self, position: Position) -> EntityId {
-        let id = self.next_id;
-        self.next_id += 1;
-
-        self.entity_positions.insert(id, position);
-        self.update_node_entities(id, position);
-
-        id
-    }
-
-    /// Updates an entity's position
-    pub fn update_position(&mut self, entity_id: EntityId, new_position: Position) {
-        if let Some(old_position) = self.entity_positions.get(&entity_id) {
-            // Remove from old nodes
-            self.remove_from_nodes(entity_id, *old_position);
-        }
-
-        // Update position and add to new nodes
-        self.entity_positions.insert(entity_id, new_position);
-        self.update_node_entities(entity_id, new_position);
-    }
-
-    /// Removes an entity from the collision system
-    #[allow(dead_code)]
-    pub fn remove_entity(&mut self, entity_id: EntityId) {
-        if let Some(position) = self.entity_positions.remove(&entity_id) {
-            self.remove_from_nodes(entity_id, position);
-        }
-    }
-
-    /// Gets all entity IDs at a specific node
-    pub fn entities_at_node(&self, node: NodeId) -> &[EntityId] {
-        self.node_entities.get(&node).map(|v| v.as_slice()).unwrap_or(&[])
-    }
-
-    /// Gets all entity IDs that could collide with an entity at the given position
-    pub fn potential_collisions(&self, position: &Position) -> Vec<EntityId> {
-        let mut collisions = Vec::new();
-        let nodes = get_nodes(position);
-
-        for node in nodes {
-            collisions.extend(self.entities_at_node(node));
-        }
-
-        // Remove duplicates
-        collisions.sort_unstable();
-        collisions.dedup();
-        collisions
-    }
-
-    /// Updates the node_entities map when an entity's position changes
-    fn update_node_entities(&mut self, entity_id: EntityId, position: Position) {
-        let nodes = get_nodes(&position);
-        for node in nodes {
-            self.node_entities.entry(node).or_default().push(entity_id);
-        }
-    }
-
-    /// Removes an entity from all nodes it was previously at
-    fn remove_from_nodes(&mut self, entity_id: EntityId, position: Position) {
-        let nodes = get_nodes(&position);
-        for node in nodes {
-            if let Some(entities) = self.node_entities.get_mut(&node) {
-                entities.retain(|&id| id != entity_id);
-                if entities.is_empty() {
-                    self.node_entities.remove(&node);
-                }
-            }
-        }
-    }
-}
-
-/// Checks if two positions overlap (entities are at the same location).
-fn positions_overlap(a: &Position, b: &Position) -> bool {
-    let a_nodes = get_nodes(a);
-    let b_nodes = get_nodes(b);
-
-    // Check if any nodes overlap
-    a_nodes.iter().any(|a_node| b_nodes.contains(a_node))
-
-    // TODO: More complex overlap detection, the above is a simple check, but it could become an early filter for more precise calculations later
-}
-
-/// Gets all nodes that an entity is currently at or between.
-fn get_nodes(pos: &Position) -> SmallVec<[NodeId; 2]> {
-    let mut nodes = SmallVec::new();
-    match pos {
-        Position::AtNode(node) => nodes.push(*node),
-        Position::BetweenNodes { from, to, .. } => {
-            nodes.push(*from);
-            nodes.push(*to);
-        }
-    }
-    nodes
-}

src/entity/ghost.rs

@@ -4,23 +4,19 @@
 //! animation, and rendering. Ghosts move through the game graph using
 //! a traverser and display directional animated textures.
 
-use pathfinding::prelude::dijkstra;
+use glam::Vec2;
 use rand::prelude::*;
 use smallvec::SmallVec;
-use tracing::error;
+use tracing::debug;
 
-use crate::entity::{
-    collision::Collidable,
-    direction::Direction,
-    graph::{Edge, EdgePermissions, Graph, NodeId},
-    r#trait::Entity,
-    traversal::Traverser,
-};
+use crate::constants::BOARD_PIXEL_OFFSET;
+use crate::entity::direction::Direction;
+use crate::entity::graph::{Edge, EdgePermissions, Graph, NodeId, Position, Traverser};
+use crate::helpers::centered_with_size;
 use crate::texture::animated::AnimatedTexture;
 use crate::texture::directional::DirectionalAnimatedTexture;
 use crate::texture::sprite::SpriteAtlas;
-
-use crate::error::{EntityError, GameError, GameResult, TextureError};
+use sdl2::render::{Canvas, RenderTarget};
 
 /// Determines if a ghost can traverse a given edge.
 ///
@@ -76,50 +72,12 @@ pub struct Ghost {
     speed: f32,
 }
 
-impl Entity for Ghost {
-    fn traverser(&self) -> &Traverser {
-        &self.traverser
-    }
-
-    fn traverser_mut(&mut self) -> &mut Traverser {
-        &mut self.traverser
-    }
-
-    fn texture(&self) -> &DirectionalAnimatedTexture {
-        &self.texture
-    }
-
-    fn texture_mut(&mut self) -> &mut DirectionalAnimatedTexture {
-        &mut self.texture
-    }
-
-    fn speed(&self) -> f32 {
-        self.speed
-    }
-
-    fn can_traverse(&self, edge: Edge) -> bool {
-        can_ghost_traverse(edge)
-    }
-
-    fn tick(&mut self, dt: f32, graph: &Graph) {
-        // Choose random direction when at a node
-        if self.traverser.position.is_at_node() {
-            self.choose_random_direction(graph);
-        }
-
-        if let Err(e) = self.traverser.advance(graph, dt * 60.0 * self.speed, &can_ghost_traverse) {
-            error!("Ghost movement error: {}", e);
-        }
-        self.texture.tick(dt);
-    }
-}
-
 impl Ghost {
     /// Creates a new ghost instance at the specified starting node.
     ///
     /// Sets up animated textures for all four directions with moving and stopped states.
     /// The moving animation cycles through two sprite variants.
-    pub fn new(graph: &Graph, start_node: NodeId, ghost_type: GhostType, atlas: &SpriteAtlas) -> GameResult<Self> {
+    pub fn new(graph: &Graph, start_node: NodeId, ghost_type: GhostType, atlas: &SpriteAtlas) -> Self {
         let mut textures = [None, None, None, None];
         let mut stopped_textures = [None, None, None, None];
 
@@ -131,49 +89,41 @@ impl Ghost {
                 Direction::Right => "right",
             };
             let moving_tiles = vec![
-                SpriteAtlas::get_tile(atlas, &format!("ghost/{}/{}_{}.png", ghost_type.as_str(), moving_prefix, "a"))
-                    .ok_or_else(|| {
-                        GameError::Texture(TextureError::AtlasTileNotFound(format!(
-                            "ghost/{}/{}_{}.png",
-                            ghost_type.as_str(),
-                            moving_prefix,
-                            "a"
-                        )))
-                    })?,
-                SpriteAtlas::get_tile(atlas, &format!("ghost/{}/{}_{}.png", ghost_type.as_str(), moving_prefix, "b"))
-                    .ok_or_else(|| {
-                        GameError::Texture(TextureError::AtlasTileNotFound(format!(
-                            "ghost/{}/{}_{}.png",
-                            ghost_type.as_str(),
-                            moving_prefix,
-                            "b"
-                        )))
-                    })?,
+                SpriteAtlas::get_tile(atlas, &format!("ghost/{}/{}_{}.png", ghost_type.as_str(), moving_prefix, "a")).unwrap(),
+                SpriteAtlas::get_tile(atlas, &format!("ghost/{}/{}_{}.png", ghost_type.as_str(), moving_prefix, "b")).unwrap(),
             ];
 
             let stopped_tiles =
                 vec![
                     SpriteAtlas::get_tile(atlas, &format!("ghost/{}/{}_{}.png", ghost_type.as_str(), moving_prefix, "a"))
-                        .ok_or_else(|| {
-                            GameError::Texture(TextureError::AtlasTileNotFound(format!(
-                                "ghost/{}/{}_{}.png",
-                                ghost_type.as_str(),
-                                moving_prefix,
-                                "a"
-                            )))
-                        })?,
+                        .unwrap(),
                 ];
 
-            textures[direction.as_usize()] = Some(AnimatedTexture::new(moving_tiles, 0.2)?);
-            stopped_textures[direction.as_usize()] = Some(AnimatedTexture::new(stopped_tiles, 0.1)?);
+            textures[direction.as_usize()] = Some(AnimatedTexture::new(moving_tiles, 0.2).expect("Invalid frame duration"));
+            stopped_textures[direction.as_usize()] =
+                Some(AnimatedTexture::new(stopped_tiles, 0.1).expect("Invalid frame duration"));
         }
 
-        Ok(Self {
+        Self {
             traverser: Traverser::new(graph, start_node, Direction::Left, &can_ghost_traverse),
             ghost_type,
             texture: DirectionalAnimatedTexture::new(textures, stopped_textures),
             speed: ghost_type.base_speed(),
-        })
+        }
+    }
+
+    /// Updates the ghost's position and animation state.
+    ///
+    /// Advances movement through the graph, updates texture animation,
+    /// and chooses random directions at intersections.
+    pub fn tick(&mut self, dt: f32, graph: &Graph) {
+        // Choose random direction when at a node
+        if self.traverser.position.is_at_node() {
+            self.choose_random_direction(graph);
+        }
+
+        self.traverser.advance(graph, dt * 60.0 * self.speed, &can_ghost_traverse);
+        self.texture.tick(dt);
     }
 
     /// Chooses a random available direction at the current intersection.
@@ -190,6 +140,15 @@ impl Ghost {
                 }
             }
         }
+
+        debug!(
+            "Ghost {} at node {}: available directions: {:?}, current direction: {:?}",
+            self.ghost_type.as_str(),
+            current_node,
+            available_directions,
+            self.traverser.direction
+        );
+
         // Choose a random direction (avoid reversing unless necessary)
         if !available_directions.is_empty() {
             let mut rng = SmallRng::from_os_rng();
@@ -201,54 +160,57 @@ impl Ghost {
                 .filter(|&&dir| dir != opposite || available_directions.len() <= 2)
                 .collect();
 
-            if let Some(&random_direction) = filtered_directions.choose(&mut rng) {
-                self.traverser.set_next_direction(*random_direction);
-            }
-        }
-    }
-
-    /// Calculates the shortest path from the ghost's current position to a target node using Dijkstra's algorithm.
-    ///
-    /// Returns a vector of NodeIds representing the path, or an error if pathfinding fails.
-    /// The path includes the current node and the target node.
-    pub fn calculate_path_to_target(&self, graph: &Graph, target: NodeId) -> GameResult<Vec<NodeId>> {
-        let start_node = self.traverser.position.from_node_id();
-
-        // Use Dijkstra's algorithm to find the shortest path
-        let result = dijkstra(
-            &start_node,
-            |&node_id| {
-                // Get all edges from the current node
-                graph.adjacency_list[node_id]
-                    .edges()
-                    .filter(|edge| can_ghost_traverse(*edge))
-                    .map(|edge| (edge.target, (edge.distance * 100.0) as u32))
-                    .collect::<Vec<_>>()
-            },
-            |&node_id| node_id == target,
+            debug!(
+                "Ghost {}: filtered directions: {:?}, opposite: {:?}",
+                self.ghost_type.as_str(),
+                filtered_directions,
+                opposite
             );
 
-        result.map(|(path, _cost)| path).ok_or_else(|| {
-            GameError::Entity(EntityError::PathfindingFailed(format!(
-                "No path found from node {} to target {}",
-                start_node, target
-            )))
-        })
-    }
-
-    /// Returns the ghost's color for debug rendering.
-    pub fn debug_color(&self) -> sdl2::pixels::Color {
-        match self.ghost_type {
-            GhostType::Blinky => sdl2::pixels::Color::RGB(255, 0, 0),    // Red
-            GhostType::Pinky => sdl2::pixels::Color::RGB(255, 182, 255), // Pink
-            GhostType::Inky => sdl2::pixels::Color::RGB(0, 255, 255),    // Cyan
-            GhostType::Clyde => sdl2::pixels::Color::RGB(255, 182, 85),  // Orange
+            if let Some(&random_direction) = filtered_directions.choose(&mut rng) {
+                self.traverser.set_next_direction(*random_direction);
+                debug!("Ghost {} chose direction: {:?}", self.ghost_type.as_str(), random_direction);
             }
         }
     }
 
-impl Collidable for Ghost {
-    fn position(&self) -> crate::entity::traversal::Position {
-        self.traverser.position
+    /// Calculates the current pixel position in the game world.
+    ///
+    /// Converts the graph position to screen coordinates, accounting for
+    /// the board offset and centering the sprite.
+    fn get_pixel_pos(&self, graph: &Graph) -> Vec2 {
+        let pos = match self.traverser.position {
+            Position::AtNode(node_id) => graph.get_node(node_id).unwrap().position,
+            Position::BetweenNodes { from, to, traversed } => {
+                let from_pos = graph.get_node(from).unwrap().position;
+                let to_pos = graph.get_node(to).unwrap().position;
+                let edge = graph.find_edge(from, to).unwrap();
+                from_pos + (to_pos - from_pos) * (traversed / edge.distance)
+            }
+        };
+
+        Vec2::new(pos.x + BOARD_PIXEL_OFFSET.x as f32, pos.y + BOARD_PIXEL_OFFSET.y as f32)
+    }
+
+    /// Renders the ghost at its current position.
+    ///
+    /// Draws the appropriate directional sprite based on the ghost's
+    /// current movement state and direction.
+    pub fn render<T: RenderTarget>(&self, canvas: &mut Canvas<T>, atlas: &mut SpriteAtlas, graph: &Graph) {
+        let pixel_pos = self.get_pixel_pos(graph);
+        let dest = centered_with_size(
+            glam::IVec2::new(pixel_pos.x as i32, pixel_pos.y as i32),
+            glam::UVec2::new(16, 16),
+        );
+
+        if self.traverser.position.is_stopped() {
+            self.texture
+                .render_stopped(canvas, atlas, dest, self.traverser.direction)
+                .expect("Failed to render ghost");
+        } else {
+            self.texture
+                .render(canvas, atlas, dest, self.traverser.direction)
+                .expect("Failed to render ghost");
+        }
     }
 }