feat: allow instant direction reversal, improve cell position state tracking

docs: minor documentation commentsa cross project
chore: web frontend files
2025-12-06 15:15:48 -06:00 · 2025-07-22 12:12:41 -05:00 · 2025-07-22 12:12:41 -05:00 · 2025-07-22 10:06:30 -05:00 · 2025-07-22 10:06:13 -05:00 · 2025-07-22 10:05:07 -05:00
26 changed files with 808 additions and 183 deletions
--- a/.cargo/config.toml
+++ b/.cargo/config.toml
@@ -1,10 +1,12 @@
-[target.wasm32-unknown-emscripten]
+[target.'cfg(target_os = "emscripten")']
 # TODO: Document what the fuck this is.
 rustflags = [
-    "-O", "-C", "link-args=-O2 --profiling",
+    # "-O", "-C", "link-args=-O2 --profiling",
    #"-C", "link-args=-O3 --closure 1",
    # "-C", "link-args=-g -gsource-map",
    "-C", "link-args=-sASYNCIFY -sALLOW_MEMORY_GROWTH=1",
-    "-C", "link-args=-sUSE_SDL=2 -sUSE_SDL_IMAGE=2 -sSDL2_IMAGE_FORMATS=['png']",
+    # "-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/",
-]
+]
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,7 @@
 /target
 /dist
 .idea
-*.dll
+*.dll
 rust-sdl2-emscripten/
 assets/build.css
 emsdk/
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -89,6 +89,7 @@ name = "pacman"
 version = "0.1.0"
 dependencies = [
 "lazy_static",
 "libc",
 "sdl2",
 "spin_sleep",
 "tracing",
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -13,7 +13,13 @@ tracing-error = "0.2.0"
 tracing-subscriber = {version = "0.3.17", features = ["env-filter"]}
 winapi = { version = "0.3", features = ["consoleapi", "fileapi", "handleapi", "processenv", "winbase", "wincon", "winnt", "winuser", "windef", "minwindef"] }
-[dependencies.sdl2]
+
 [target.'cfg(target_os = "emscripten")'.dependencies.sdl2]
 version = "0.38"
 default-features = false
 features = ["ttf","image","gfx","mixer"]
 [target.'cfg(not(target_os = "emscripten"))'.dependencies.sdl2]
 version = "0.38"
 default-features = false
 features = ["ttf","image","gfx","mixer","static-link","use-vcpkg"]
@@ -24,4 +30,8 @@ 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" }
+x86_64-pc-windows-msvc = { triplet = "x64-windows-static-md" }
 stable-x86_64-unknown-linux-gnu = { triplet = "x86_64-unknown-linux-gnu" }
 [target.'cfg(target_os = "emscripten")'.dependencies]
 libc = "0.2.16"
--- a/assets/TerminalVector.ttf
+++ b/assets/TerminalVector.ttf
--- a/assets/favicon.ico
+++ b/assets/favicon.ico
--- a/assets/index.html
+++ b/assets/index.html
@@ -1,27 +1,65 @@
 <!DOCTYPE html>
 <html>
-<head>
+  <head>
-    <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-</head>
+    <title>Pac-Man Arcade</title>
-<style>
+    <link rel="stylesheet" href="build.css" />
-    body {
+    <style>
-        margin: 0;
+    </style>
-        padding: 0;
+  </head>
-        background: #000;
+  <body class="bg-black text-yellow-400 text-center">
-    }
+    <a
-    canvas {
+      href="https://github.com/Xevion/Pac-Man"
-        display: block;
+      class="absolute top-0 right-0"
-        margin: 0 auto;
+      aria-label="View source on GitHub"
-        background: #000;
+    >
-    }
+      <svg
-</style>
+        width="80"
-<body>
+        height="80"
-    <canvas id="canvas"></canvas>
+        viewBox="0 0 250 250"
-    <script>
+        class="fill-yellow-400 text-black"
-        var Module = {
+        aria-hidden="true"
-            'canvas': document.getElementById('canvas'),
+      >
-        };
+        <path d="M0,0 L115,115 L130,115 L142,142 L250,250 L250,0 Z"></path>
        <path
          d="M128.3,109.0 C113.8,99.7 119.0,89.6 119.0,89.6 C122.0,82.7 120.5,78.6 120.5,78.6 C119.2,72.0 123.4,76.3 123.4,76.3 C127.3,80.9 125.5,87.3 125.5,87.3 C122.9,97.6 130.6,101.9 134.4,103.2"
          class="octo-arm"
        ></path>
        <path
          d="M115.0,115.0 C114.9,115.1 118.7,116.5 119.8,115.4 L133.7,101.6 C136.9,99.2 139.9,98.4 142.2,98.6 C133.8,88.0 127.5,74.4 143.8,58.0 C148.5,53.4 154.0,51.2 159.7,51.0 C160.3,49.4 163.2,43.6 171.4,40.1 C171.4,40.1 176.1,42.5 178.8,56.2 C183.1,58.6 187.2,61.8 190.9,65.4 C194.5,69.0 197.7,73.2 200.1,77.6 C213.8,80.2 216.3,84.9 216.3,84.9 C212.7,93.1 206.9,96.0 205.4,96.6 C205.1,102.4 203.0,107.8 198.3,112.5 C181.9,128.9 168.3,122.5 157.7,114.1 C157.9,116.9 156.7,120.9 152.7,124.9 L141.0,136.5 C139.8,137.7 141.6,141.9 141.8,141.8 Z"
          class="octo-body"
        ></path>
      </svg>
    </a>
    <h1 class="text-4xl mt-10 scaled-text">Pac-Man Arcade</h1>
    <p class="text-lg mt-5 scaled-text">
      Welcome to the Pac-Man Arcade! Use the controls below to play.
    </p>
    <canvas
      id="canvas"
      class="block mx-auto mt-5"
      width="800"
      height="600"
    ></canvas>
    <div class="mt-10">
      <span
        class="inline-block mx-2 px-4 py-2 bg-yellow-400 text-black rounded scaled-text"
        >&larr; &uarr; &rarr; &darr; Move</span
      >
      <span
        class="inline-block mx-2 px-4 py-2 bg-yellow-400 text-black rounded scaled-text"
        >Space Change Sprite</span
      >
      <span
        class="inline-block mx-2 px-4 py-2 bg-yellow-400 text-black rounded scaled-text"
        >Shift + &uarr;&darr; Change Volume</span
      >
    </div>
    <script type="text/javascript">
      var Module = {
        canvas: document.getElementById("canvas"),
      };
    </script>
-    <script src="pacman.js"></script>
+    <script type="text/javascript" src="pacman.js"></script>
-</body>
+  </body>
-</html>
+</html>
--- a/assets/styles.scss
+++ b/assets/styles.scss
@@ -0,0 +1,21 @@
@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;
 }
--- a/assets/wav/1.ogg
+++ b/assets/wav/1.ogg
--- a/assets/wav/2.ogg
+++ b/assets/wav/2.ogg
--- a/assets/wav/3.ogg
+++ b/assets/wav/3.ogg
--- a/assets/wav/4.ogg
+++ b/assets/wav/4.ogg
--- a/scripts/build.sh
+++ b/scripts/build.sh
@@ -38,7 +38,7 @@ fi
 if [ "$skip_emsdk" = 'false' ]; then
    echo "Activating Emscripten"
    # SDL2-TTF requires 3.1.43, fails to build on latest
-    ./../emsdk/emsdk activate 3.1.43
+    ../emsdk/emsdk activate 3.1.43
    source ../emsdk/emsdk_env.sh
 fi
@@ -59,15 +59,15 @@ mkdir -p dist
 output_folder="target/wasm32-unknown-emscripten/$build_type"
 cp assets/index.html dist
-cp assets/*.woff* dist
+# cp assets/*.woff* dist
 cp assets/build.css dist
 cp assets/favicon.ico dist
-cp $output_folder/spiritus.wasm dist
+cp $output_folder/pacman.wasm dist
-cp $output_folder/spiritus.js dist
+cp $output_folder/pacman.js dist
 # only if .data file exists
-cp $output_folder/deps/spiritus.data dist
+cp $output_folder/deps/pacman.data dist
-if [ -f $output_folder/spiritus.wasm.map ]; then
+if [ -f $output_folder/pacman.wasm.map ]; then
-    cp $output_folder/spiritus.wasm.map dist
+    cp $output_folder/pacman.wasm.map dist
 fi
 if [ "$serve" = 'true' ]; then
--- a/build.ts
+++ b/build.ts
@@ -0,0 +1,194 @@
 import { $ } from "bun";
 // This is a bun script, run with `bun run build.ts`
 import * as path from "path";
 import * as fs from "fs/promises";
 async function clean() {
  console.log("Cleaning...");
  await $`cargo clean`;
  await $`rm -rf ./dist/`;
  console.log("Cleaned...");
 }
 async function setupEmscripten() {
  const emsdkDir = "./emsdk";
  const emsdkExists = await fs
    .access(emsdkDir)
    .then(() => true)
    .catch(() => false);
  if (!emsdkExists) {
    console.log("Cloning Emscripten SDK...");
    await $`git clone https://github.com/emscripten-core/emsdk.git`;
  } else {
    console.log("Emscripten SDK already exists, skipping clone.");
  }
  const emscriptenToolchainPath = path.join(emsdkDir, "upstream", "emscripten");
  const toolchainInstalled = await fs
    .access(emscriptenToolchainPath)
    .then(() => true)
    .catch(() => false);
  if (!toolchainInstalled) {
    console.log("Installing Emscripten toolchain...");
    await $`./emsdk/emsdk install 3.1.43`;
  } else {
    console.log(
      "Emscripten toolchain 3.1.43 already installed, skipping install."
    );
  }
  console.log("Activating Emscripten...");
  await $`./emsdk/emsdk activate 3.1.43`;
  console.log("Emscripten activated.");
  // Set EMSDK environment variable for subsequent commands
  process.env.EMSDK = path.resolve(emsdkDir);
  const emsdkPython = path.join(path.resolve(emsdkDir), "python");
  const emsdkNode = path.join(path.resolve(emsdkDir), "node", "16.20.0_64bit"); // Adjust node version if needed
  const emsdkBin = path.join(path.resolve(emsdkDir), "upstream", "emscripten");
  process.env.PATH = `${emsdkPython}:${emsdkNode}:${emsdkBin}:${process.env.PATH}`;
 }
 async function buildWeb(release: boolean) {
  console.log("Building WASM with Emscripten...");
  if (release) {
    await $`cargo build --target=wasm32-unknown-emscripten --release`;
  } else {
    await $`cargo build --target=wasm32-unknown-emscripten`;
  }
  console.log("Generating CSS...");
  await $`pnpx postcss-cli ./assets/styles.scss -o ./assets/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`;
  // Check if .data file exists before copying
  try {
    await fs.access(`${outputFolder}/deps/spiritus.data`);
    await $`cp ${outputFolder}/deps/spiritus.data dist`;
  } catch (e) {
    console.log("No spiritus.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`;
  } catch (e) {
    console.log("No spiritus.wasm.map file found, skipping copy.");
  }
  console.log("WASM files copied.");
 }
 async function serve() {
  console.log("Serving WASM with Emscripten...");
  await $`python3 -m http.server -d ./dist/ 8080`;
 }
 async function main() {
  const args = process.argv.slice(2);
  let release = false;
  let serveFiles = false;
  let skipEmscriptenSetup = false;
  let cleanProject = false;
  let target = "web"; // Default target
  for (const arg of args) {
    switch (arg) {
      case "-r":
        release = true;
        break;
      case "-s":
        serveFiles = true;
        break;
      case "-e":
        skipEmscriptenSetup = true;
        break;
      case "-c":
        cleanProject = true;
        break;
      case "--target=linux":
        target = "linux";
        break;
      case "--target=windows":
        target = "windows";
        break;
      case "--target=web":
        target = "web";
        break;
      case "-h":
      case "--help":
        console.log(`
 Usage: ts-node build.ts [options]
 Options:
  -r              Build in release mode
  -s              Serve the WASM files once built (for web target)
  -e              Skip EMSDK setup (GitHub workflow only)
  -c              Clean the target/dist directory
  --target=[web|linux|windows] Specify target platform (default: web)
  -h, --help      Show this help message
        `);
        return;
    }
  }
  if (cleanProject) {
    await clean();
  }
  if (!skipEmscriptenSetup && target === "web") {
    await setupEmscripten();
  }
  switch (target) {
    case "web":
      await buildWeb(release);
      if (serveFiles) {
        await serve();
      }
      break;
    case "linux":
      console.log("Building for Linux...");
      if (release) {
        await $`cargo build --release`;
      } else {
        await $`cargo build`;
      }
      console.log("Linux build complete.");
      break;
    case "windows":
      console.log("Building for Windows...");
      if (release) {
        await $`cargo build --release --target=x86_64-pc-windows-msvc`; // Assuming MSVC toolchain
      } else {
        await $`cargo build --target=x86_64-pc-windows-msvc`;
      }
      console.log("Windows build complete.");
      break;
    default:
      console.error("Invalid target specified.");
      process.exit(1);
  }
 }
 main().catch((err) => {
  console.error(err);
  process.exit(1);
 });
--- a/src/animation.rs
+++ b/src/animation.rs
@@ -1,3 +1,4 @@
 //! This module provides a simple animation system for textures.
 use sdl2::{
    rect::Rect,
    render::{Canvas, Texture},
@@ -6,18 +7,37 @@ use sdl2::{
 use crate::direction::Direction;
 /// An animated texture, which is a texture that is rendered as a series of
 /// frames.
 pub struct AnimatedTexture<'a> {
    raw_texture: Texture<'a>,
    /// The current tick of the animation.
    ticker: u32,
    /// Whether the animation is currently playing in reverse.
    reversed: bool,
    /// The offset of the texture, in pixels.
    offset: (i32, i32),
    /// The number of ticks per frame.
    ticks_per_frame: u32,
    /// The number of frames in the animation.
    frame_count: u32,
    /// The width of each frame, in pixels.
    frame_width: u32,
    /// The height of each frame, in pixels.
    frame_height: u32,
 }
 impl<'a> AnimatedTexture<'a> {
    /// Creates a new `AnimatedTexture`.
    ///
    /// # Arguments
    ///
    /// * `texture` - The texture to animate.
    /// * `ticks_per_frame` - The number of ticks to display each frame for.
    /// * `frame_count` - The number of frames in the animation.
    /// * `frame_width` - The width of each frame.
    /// * `frame_height` - The height of each frame.
    /// * `offset` - The offset of the texture, in pixels.
    pub fn new(
        texture: Texture<'a>,
        ticks_per_frame: u32,
@@ -38,12 +58,14 @@ impl<'a> AnimatedTexture<'a> {
        }
    }
-    // Get the current frame number
+    /// Returns the current frame number.
    fn current_frame(&self) -> u32 {
        self.ticker / self.ticks_per_frame
    }
-    // Move to the next frame. If we are at the end of the animation, reverse the direction
+    /// Advances the animation by one tick.
    ///
    /// The animation will play forwards, then backwards, then forwards, and so on.
    pub fn tick(&mut self) {
        if self.reversed {
            self.ticker -= 1;
@@ -60,7 +82,7 @@ impl<'a> AnimatedTexture<'a> {
        }
    }
-    // Calculate the frame rect (portion of the texture to render) for the given frame.
+    /// Calculates the source rectangle for the given frame.
    fn get_frame_rect(&self, frame: u32) -> Rect {
        if frame >= self.frame_count {
            panic!("Frame {} is out of bounds for this texture", frame);
@@ -74,6 +96,13 @@ impl<'a> AnimatedTexture<'a> {
        )
    }
    /// Renders the animation to the canvas.
    ///
    /// # Arguments
    ///
    /// * `canvas` - The canvas to render to.
    /// * `position` - The position to render the animation at.
    /// * `direction` - The direction the animation is facing.
    pub fn render(
        &mut self,
        canvas: &mut Canvas<Window>,
@@ -84,7 +113,15 @@ impl<'a> AnimatedTexture<'a> {
        self.tick();
    }
-    // Functions like render, but only ticks the animation until the given frame is reached.
+    /// Renders the animation to the canvas, but only ticks the animation until
    /// the given frame is reached.
    ///
    /// # Arguments
    ///
    /// * `canvas` - The canvas to render to.
    /// * `position` - The position to render the animation at.
    /// * `direction` - The direction the animation is facing.
    /// * `frame` - The frame to render until.
    pub fn render_until(
        &mut self,
        canvas: &mut Canvas<Window>,
@@ -92,7 +129,9 @@ impl<'a> AnimatedTexture<'a> {
        direction: Direction,
        frame: u32,
    ) {
-        // TODO: If the frame we're targeting is in the opposite direction (due to self.reverse), we should pre-emptively reverse.
+        // TODO: If the frame we're targeting is in the opposite direction (due
        // to self.reverse), we should pre-emptively reverse. This would require
        // a more complex ticking mechanism.
        let current = self.current_frame();
        self.render_static(canvas, position, direction, Some(current));
@@ -101,7 +140,14 @@ impl<'a> AnimatedTexture<'a> {
        }
    }
-    // Renders a specific frame of the animation. Defaults to the current frame.
+    /// Renders a specific frame of the animation.
    ///
    /// # Arguments
    ///
    /// * `canvas` - The canvas to render to.
    /// * `position` - The position to render the animation at.
    /// * `direction` - The direction the animation is facing.
    /// * `frame` - The frame to render. If `None`, the current frame is used.
    pub fn render_static(
        &mut self,
        canvas: &mut Canvas<Window>,
--- a/src/audio.rs
+++ b/src/audio.rs
@@ -0,0 +1,82 @@
 //! This module handles the audio playback for the game.
 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];
 /// The audio system for the game.
 ///
 /// This struct is responsible for initializing the audio device, loading sounds,
 /// and playing them.
 pub struct Audio {
    _mixer_context: mixer::Sdl2MixerContext,
    sounds: Vec<Chunk>,
    next_sound_index: usize,
 }
 impl Audio {
    /// Creates a new `Audio` instance.
    pub fn new() -> Self {
        let frequency = 44100;
        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);
        }
        let mixer_context = mixer::init(InitFlag::OGG).expect("Failed to initialize SDL2_mixer");
        let sounds: Vec<Chunk> = SOUND_DATA
            .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
                ))
            })
            .collect();
        Audio {
            _mixer_context: mixer_context,
            sounds,
            next_sound_index: 0,
        }
    }
    /// 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
                    );
                }
                Err(e) => {
                    tracing::warn!("Could not play sound #{}: {}", self.next_sound_index + 1, e);
                }
            }
        }
        self.next_sound_index = (self.next_sound_index + 1) % self.sounds.len();
    }
 }
--- a/src/board.rs
+++ b/src/board.rs
--- a/src/constants.rs
+++ b/src/constants.rs
@@ -1,21 +1,40 @@
 //! This module contains all the constants used in the game.
 /// The width of the game board, in cells.
 pub const BOARD_WIDTH: u32 = 28;
-pub const BOARD_HEIGHT: u32 = 31; // Adjusted to fit map texture?
+/// The height of the game board, in cells.
 pub const BOARD_HEIGHT: u32 = 31;
 /// The size of each cell, in pixels.
 pub const CELL_SIZE: u32 = 24;
-pub const BOARD_OFFSET: (u32, u32) = (0, 3); // Relative cell offset for where map text / grid starts
+/// The offset of the game board from the top-left corner of the window, in
 /// cells.
 pub const BOARD_OFFSET: (u32, u32) = (0, 3);
 /// The width of the window, in pixels.
 pub const WINDOW_WIDTH: u32 = CELL_SIZE * BOARD_WIDTH;
-pub const WINDOW_HEIGHT: u32 = CELL_SIZE * (BOARD_HEIGHT + 6); // Map texture is 6 cells taller (3 above, 3 below) than the grid
+/// The height of the window, in pixels.
 ///
 /// The map texture is 6 cells taller than the grid (3 above, 3 below), so we
 /// add 6 to the board height to get the window height.
 pub const WINDOW_HEIGHT: u32 = CELL_SIZE * (BOARD_HEIGHT + 6);
 /// An enum representing the different types of tiles on the map.
 #[derive(Debug, Copy, Clone, PartialEq)]
 pub enum MapTile {
    /// An empty tile.
    Empty,
    /// A wall tile.
    Wall,
    /// A regular pellet.
    Pellet,
    /// A power pellet.
    PowerPellet,
    /// A starting position for an entity.
    StartingPosition(u8),
 }
 /// The raw layout of the game board, as a 2D array of characters.
 pub const RAW_BOARD: [&str; BOARD_HEIGHT as usize] = [
    "############################",
    "#............##............#",
--- a/src/direction.rs
+++ b/src/direction.rs
@@ -1,5 +1,8 @@
 //! This module defines the `Direction` enum, which is used to represent the
 //! direction of an entity.
 use sdl2::keyboard::Keycode;
 /// An enum representing the direction of an entity.
 #[derive(Debug, Copy, Clone, PartialEq)]
 pub enum Direction {
    Up,
@@ -9,6 +12,7 @@ pub enum Direction {
 }
 impl Direction {
    /// Returns the angle of the direction in degrees.
    pub fn angle(&self) -> f64 {
        match self {
            Direction::Right => 0f64,
@@ -18,6 +22,7 @@ impl Direction {
        }
    }
    /// Returns the offset of the direction as a tuple of (x, y).
    pub fn offset(&self) -> (i32, i32) {
        match self {
            Direction::Right => (1, 0),
@@ -27,16 +32,27 @@ impl Direction {
        }
    }
    /// Returns the opposite direction.
    pub fn opposite(&self) -> Direction {
        match self {
            Direction::Right => Direction::Left,
            Direction::Down => Direction::Up,
            Direction::Left => Direction::Right,
            Direction::Up => Direction::Down,
        }
    }
    /// Creates a `Direction` from a `Keycode`.
    ///
    /// # Arguments
    ///
    /// * `keycode` - The keycode to convert.
    pub fn from_keycode(keycode: Keycode) -> Option<Direction> {
        match keycode {
-            Keycode::D => Some(Direction::Right),
+            Keycode::D | Keycode::Right => Some(Direction::Right),
-            Keycode::Right => Some(Direction::Right),
+            Keycode::A | Keycode::Left => Some(Direction::Left),
-            Keycode::A => Some(Direction::Left),
+            Keycode::W | Keycode::Up => Some(Direction::Up),
-            Keycode::Left => Some(Direction::Left),
+            Keycode::S | Keycode::Down => Some(Direction::Down),
            Keycode::W => Some(Direction::Up),
            Keycode::Up => Some(Direction::Up),
            Keycode::S => Some(Direction::Down),
            Keycode::Down => Some(Direction::Down),
            _ => None,
        }
    }
--- a/src/entity.rs
+++ b/src/entity.rs
@@ -1,11 +1,16 @@
 //! This module defines the `Entity` trait, which is implemented by all game
 //! objects that can be moved and rendered.
 /// A trait for game objects that can be moved and rendered.
 pub trait Entity {
-    // Returns true if the entity is colliding with the other entity
+    /// Returns true if the entity is colliding with the other entity.
    fn is_colliding(&self, other: &dyn Entity) -> bool;
-    // Returns the absolute position of the entity
+    /// Returns the absolute position of the entity, in pixels.
    fn position(&self) -> (i32, i32);
-    // Returns the cell position of the entity (XY position within the grid)
+    /// Returns the cell position of the entity, in grid coordinates.
    fn cell_position(&self) -> (u32, u32);
    /// Returns the position of the entity within its current cell, in pixels.
    fn internal_position(&self) -> (u32, u32);
-    // Tick the entity (move it, perform collision checks, etc)
+    /// Ticks the entity, which updates its state and position.
    fn tick(&mut self);
 }
--- a/src/game.rs
+++ b/src/game.rs
@@ -1,19 +1,33 @@
 //! This module contains the main game logic and state.
 use std::rc::Rc;
 use sdl2::image::LoadTexture;
 use sdl2::keyboard::Keycode;
 use sdl2::render::{Texture, TextureCreator};
-use sdl2::ttf::{Font, FontStyle};
+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::audio::Audio;
 use crate::constants::{MapTile, BOARD_HEIGHT, BOARD_WIDTH, RAW_BOARD};
 use crate::direction::Direction;
 use crate::entity::Entity;
 use crate::map::Map;
 use crate::pacman::Pacman;
 // 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");
 /// The main game state.
 ///
 /// This struct contains all the information necessary to run the game, including
 /// the canvas, textures, fonts, game objects, and the current score.
 pub struct Game<'a> {
    canvas: &'a mut Canvas<Window>,
    map_texture: Texture<'a>,
@@ -24,46 +38,75 @@ pub struct Game<'a> {
    map: Rc<std::cell::RefCell<Map>>,
    debug: bool,
    score: u32,
    audio: Audio,
 }
 impl Game<'_> {
    /// Creates a new `Game` instance.
    ///
    /// # Arguments
    ///
    /// * `canvas` - The SDL canvas to render to.
    /// * `texture_creator` - The SDL texture creator.
    /// * `ttf_context` - The SDL TTF context.
    /// * `_audio_subsystem` - The SDL audio subsystem (currently unused).
    pub fn new<'a>(
        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)));
        // Load Pacman texture from embedded data
        let pacman_atlas = texture_creator
-            .load_texture("assets/32/pacman.png")
+            .load_texture_bytes(PACMAN_TEXTURE_DATA)
-            .expect("Could not load pacman texture");
+            .expect("Could not load pacman texture from embedded data");
        let pacman = Pacman::new((1, 1), pacman_atlas, Rc::clone(&map));
        // Load pellet texture from embedded data
        let pellet_texture = texture_creator
-            .load_texture("assets/24/pellet.png")
+            .load_texture_bytes(PELLET_TEXTURE_DATA)
-            .expect("Could not load pellet texture");
+            .expect("Could not load pellet texture from embedded data");
        let power_pellet_texture = texture_creator
            .load_texture("assets/24/energizer.png")
            .expect("Could not load power pellet texture");
        // Load power pellet texture from embedded data
        let power_pellet_texture = texture_creator
            .load_texture_bytes(POWER_PELLET_TEXTURE_DATA)
            .expect("Could not load power pellet texture from embedded data");
        // 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("assets/font/konami.ttf", 24)
+            .load_font_from_rwops(font_rwops, 24)
-            .expect("Could not load font");
+            .expect("Could not load font from embedded data");
        let audio = Audio::new();
        // Load map texture from embedded data
        let mut map_texture = texture_creator
            .load_texture_bytes(MAP_TEXTURE_DATA)
            .expect("Could not load map texture from embedded data");
        map_texture.set_color_mod(0, 0, 255);
        Game {
            canvas,
            pacman: pacman,
            debug: false,
            map: map,
-            map_texture: texture_creator
+            map_texture,
                .load_texture("assets/map.png")
                .expect("Could not load map texture"),
            pellet_texture,
            power_pellet_texture,
            font,
            score: 0,
            audio,
        }
    }
    /// Handles a keyboard event.
    ///
    /// # Arguments
    ///
    /// * `keycode` - The keycode of the key that was pressed.
    pub fn keyboard_event(&mut self, keycode: Keycode) {
        // Change direction
        let direction = Direction::from_keycode(keycode);
@@ -80,10 +123,16 @@ impl Game<'_> {
        }
    }
    /// Adds points to the score.
    ///
    /// # Arguments
    ///
    /// * `points` - The number of points to add.
    pub fn add_score(&mut self, points: u32) {
        self.score += points;
    }
    /// Resets the game to its initial state.
    pub fn reset(&mut self) {
        // Reset the map to restore all pellets
        {
@@ -101,11 +150,14 @@ impl Game<'_> {
        event!(tracing::Level::INFO, "Game reset - map and score cleared");
    }
    /// Advances the game by one tick.
    pub fn tick(&mut self) {
        self.pacman.tick();
        self.check_pellet_eating();
        self.pacman.tick();
    }
    /// Checks if Pac-Man is currently eating a pellet and updates the game state
    /// accordingly.
    fn check_pellet_eating(&mut self) {
        let cell_pos = self.pacman.cell_position();
@@ -116,40 +168,30 @@ impl Game<'_> {
        };
        if let Some(tile) = tile {
-            match tile {
+            let pellet_value = match tile {
-                MapTile::Pellet => {
+                MapTile::Pellet => Some(10),
-                    // Eat the pellet and add score
+                MapTile::PowerPellet => Some(50),
-                    {
+                _ => None,
-                        let mut map = self.map.borrow_mut();
+            };
-                        map.set_tile((cell_pos.0 as i32, cell_pos.1 as i32), MapTile::Empty);
+
-                    }
+            if let Some(value) = pellet_value {
-                    self.add_score(10);
+                {
-                    event!(
+                    let mut map = self.map.borrow_mut();
-                        tracing::Level::DEBUG,
+                    map.set_tile((cell_pos.0 as i32, cell_pos.1 as i32), MapTile::Empty);
                        "Pellet eaten at ({}, {})",
                        cell_pos.0,
                        cell_pos.1
                    );
                }
-                MapTile::PowerPellet => {
+                self.add_score(value);
-                    // Eat the power pellet and add score
+                self.audio.eat();
-                    {
+                event!(
-                        let mut map = self.map.borrow_mut();
+                    tracing::Level::DEBUG,
-                        map.set_tile((cell_pos.0 as i32, cell_pos.1 as i32), MapTile::Empty);
+                    "Pellet eaten at ({}, {})",
-                    }
+                    cell_pos.0,
-                    self.add_score(50);
+                    cell_pos.1
-                    event!(
+                );
                        tracing::Level::DEBUG,
                        "Power pellet eaten at ({}, {})",
                        cell_pos.0,
                        cell_pos.1
                    );
                }
                _ => {}
            }
        }
    }
    /// Draws the entire game to the canvas.
    pub fn draw(&mut self) {
        // Clear the screen (black)
        self.canvas.set_draw_color(Color::RGB(0, 0, 0));
@@ -161,13 +203,35 @@ impl Game<'_> {
            .expect("Could not render texture on canvas");
        // Render pellets
-        self.render_pellets();
+        for x in 0..BOARD_WIDTH {
            for y in 0..BOARD_HEIGHT {
                let tile = self
                    .map
                    .borrow()
                    .get_tile((x as i32, y as i32))
                    .unwrap_or(MapTile::Empty);
                let texture = match tile {
                    MapTile::Pellet => Some(&self.pellet_texture),
                    MapTile::PowerPellet => Some(&self.power_pellet_texture),
                    _ => None,
                };
                if let Some(texture) = texture {
                    let position = Map::cell_to_pixel((x, y));
                    let dst_rect = sdl2::rect::Rect::new(position.0, position.1, 24, 24);
                    self.canvas
                        .copy(texture, None, Some(dst_rect))
                        .expect("Could not render pellet");
                }
            }
        }
        // Render the pacman
        self.pacman.render(self.canvas);
        // Render score
-        self.render_score();
+        self.render_ui();
        // Draw the debug grid
        if self.debug {
@@ -207,6 +271,12 @@ impl Game<'_> {
        self.canvas.present();
    }
    /// Draws a single cell to the canvas with the given color.
    ///
    /// # Arguments
    ///
    /// * `cell` - The cell to draw, in grid coordinates.
    /// * `color` - The color to draw the cell with.
    fn draw_cell(&mut self, cell: (u32, u32), color: Color) {
        let position = Map::cell_to_pixel(cell);
@@ -221,37 +291,8 @@ impl Game<'_> {
            .expect("Could not draw rectangle");
    }
-    fn render_pellets(&mut self) {
+    /// Renders the user interface, including the score and lives.
-        for x in 0..BOARD_WIDTH {
+    fn render_ui(&mut self) {
            for y in 0..BOARD_HEIGHT {
                let tile = self
                    .map
                    .borrow()
                    .get_tile((x as i32, y as i32))
                    .unwrap_or(MapTile::Empty);
                match tile {
                    MapTile::Pellet => {
                        let position = Map::cell_to_pixel((x, y));
                        let dst_rect = sdl2::rect::Rect::new(position.0, position.1, 24, 24);
                        self.canvas
                            .copy(&self.pellet_texture, None, Some(dst_rect))
                            .expect("Could not render pellet");
                    }
                    MapTile::PowerPellet => {
                        let position = Map::cell_to_pixel((x, y));
                        let dst_rect = sdl2::rect::Rect::new(position.0, position.1, 24, 24);
                        self.canvas
                            .copy(&self.power_pellet_texture, None, Some(dst_rect))
                            .expect("Could not render power pellet");
                    }
                    _ => {}
                }
            }
        }
    }
    fn render_score(&mut self) {
        let lives = 3;
        let score_text = format!("{:02}", self.score);
@@ -261,6 +302,7 @@ impl Game<'_> {
        let score_offset = 7 - (score_text.len() as i32);
        let gap_offset = 6;
        // Render the score and high score
        self.render_text(
            &format!("{}UP   HIGH SCORE   ", lives),
            (24 * lives_offset + x_offset, y_offset),
@@ -273,6 +315,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
@@ -284,11 +327,9 @@ impl Game<'_> {
        let texture = texture_creator
            .create_texture_from_surface(&surface)
            .expect("Could not create texture from surface");
        let query = texture.query();
-        let dst_rect =
+        let dst_rect = sdl2::rect::Rect::new(position.0, position.1, query.width, query.height);
            sdl2::rect::Rect::new(position.0, position.1, query.width + 4, query.height + 4);
        self.canvas
            .copy(&texture, None, Some(dst_rect))
--- a/src/helper.rs
+++ b/src/helper.rs
@@ -1,3 +1,5 @@
 //! This module contains helper functions that are used throughout the game.
 /// Checks if two grid positions are adjacent to each other
 ///
 /// # Arguments
--- a/src/main.rs
+++ b/src/main.rs
@@ -22,6 +22,11 @@ use winapi::{
    },
 };
 /// Attaches the process to the parent console on Windows.
 ///
 /// This allows the application to print to the console when run from a terminal,
 /// which is useful for debugging purposes. If the application is not run from a
 /// terminal, this function does nothing.
 #[cfg(windows)]
 unsafe fn attach_console() {
    if GetConsoleWindow() != std::ptr::null_mut() as HWND {
@@ -58,7 +63,12 @@ mod map;
 mod modulation;
 mod pacman;
 /// The main entry point of the application.
 ///
 /// This function initializes SDL, the window, the game state, and then enters
 /// the main game loop.
 pub fn main() {
    // Attaches the console on Windows for debugging purposes.
    #[cfg(windows)]
    unsafe {
        attach_console();
@@ -94,7 +104,12 @@ pub fn main() {
        .expect("Could not set logical size");
    let texture_creator = canvas.texture_creator();
-    let mut game = Game::new(&mut canvas, &texture_creator, &ttf_context);
+    let mut game = Game::new(
        &mut canvas,
        &texture_creator,
        &ttf_context,
        &audio_subsystem,
    );
    let mut event_pump = sdl_context
        .event_pump()
@@ -104,13 +119,16 @@ pub fn main() {
    game.draw();
    game.tick();
    // The target time for each frame of the game loop (60 FPS).
    let loop_time = Duration::from_secs(1) / 60;
    let mut tick_no = 0u32;
    // The start of a period of time over which we average the frame time.
    let mut last_averaging_time = Instant::now();
    // The total time spent sleeping during the current averaging period.
    let mut sleep_time = Duration::ZERO;
    let mut paused = false;
    // Whether the window is currently shown.
    let mut shown = false;
    event!(
@@ -121,7 +139,9 @@ pub fn main() {
    let mut main_loop = || {
        let start = Instant::now();
-        // TODO: Fix key repeat delay issues by using VecDeque for instant key repeat
+        // TODO: Fix key repeat delay issues by using a queue for keyboard events.
        // This would allow for instant key repeat without being affected by the
        // main loop's tick rate.
        for event in event_pump.poll_iter() {
            match event {
                Event::Window { win_event, .. } => match win_event {
@@ -162,7 +182,8 @@ pub fn main() {
            }
        }
-        // TODO: Proper pausing implementation that does not interfere with statistic gathering
+        // TODO: Implement a proper pausing mechanism that does not interfere with
        // statistic gathering and other background tasks.
        if !paused {
            game.tick();
            game.draw();
@@ -191,6 +212,7 @@ pub fn main() {
        tick_no += 1;
        // Caclulate and display performance statistics every 60 seconds.
        const PERIOD: u32 = 60 * 60;
        let tick_mod = tick_no % PERIOD;
        if tick_mod % PERIOD == 0 {
--- a/src/map.rs
+++ b/src/map.rs
@@ -1,12 +1,24 @@
-use crate::constants::MapTile;
+//! This module defines the game map and provides functions for interacting with it.
-use crate::constants::{BOARD_HEIGHT, BOARD_WIDTH, RAW_BOARD};
+use crate::constants::{MapTile, BOARD_OFFSET, CELL_SIZE};
 use crate::constants::{BOARD_HEIGHT, BOARD_WIDTH};
 /// The game map.
 ///
 /// The map is represented as a 2D array of `MapTile`s. It also stores a copy of
 /// the original map, which can be used to reset the map to its initial state.
 pub struct Map {
    /// The current state of the map.
    current: [[MapTile; BOARD_HEIGHT as usize]; BOARD_WIDTH as usize],
    /// The default state of the map.
    default: [[MapTile; BOARD_HEIGHT as usize]; BOARD_WIDTH as usize],
 }
 impl Map {
    /// Creates a new `Map` instance from a raw board layout.
    ///
    /// # Arguments
    ///
    /// * `raw_board` - A 2D array of characters representing the board layout.
    pub fn new(raw_board: [&str; BOARD_HEIGHT as usize]) -> Map {
        let mut map = [[MapTile::Empty; BOARD_HEIGHT as usize]; BOARD_WIDTH as usize];
@@ -46,6 +58,7 @@ impl 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 {
@@ -55,6 +68,11 @@ impl Map {
        }
    }
    /// Returns the tile at the given cell coordinates.
    ///
    /// # 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;
@@ -66,6 +84,12 @@ impl Map {
        Some(self.current[x][y])
    }
    /// Sets the tile at the given cell coordinates.
    ///
    /// # Arguments
    ///
    /// * `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;
@@ -78,7 +102,15 @@ impl Map {
        true
    }
    /// Converts cell coordinates to pixel coordinates.
    ///
    /// # Arguments
    ///
    /// * `cell` - The cell coordinates, in grid coordinates.
    pub fn cell_to_pixel(cell: (u32, u32)) -> (i32, i32) {
-        ((cell.0 as i32) * 24, ((cell.1 + 3) as i32) * 24)
+        (
            (cell.0 * CELL_SIZE) as i32,
            ((cell.1 + BOARD_OFFSET.1) * CELL_SIZE) as i32,
        )
    }
 }
--- a/src/modulation.rs
+++ b/src/modulation.rs
@@ -1,3 +1,5 @@
 //! This module provides a tick modulator, which can be used to slow down
 //! operations by a percentage.
 /// A tick modulator allows you to slow down operations by a percentage.
 ///
 /// Unfortunately, switching to floating point numbers for entities can induce floating point errors, slow down calculations
@@ -12,17 +14,25 @@
 ///
 /// For example, if we want to slow down the speed by 10%, we would need to skip every 10th tick.
 pub trait TickModulator {
    /// Creates a new tick modulator.
    ///
    /// # Arguments
    ///
    /// * `percent` - The percentage to slow down by, from 0.0 to 1.0.
    fn new(percent: f32) -> Self;
    /// Returns whether or not the operation should be performed on this tick.
    fn next(&mut self) -> bool;
 }
 /// A simple tick modulator that skips every Nth tick.
 pub struct SimpleTickModulator {
    tick_count: u32,
    ticks_left: u32,
 }
-// TODO: Add tests
+// TODO: Add tests for the tick modulator to ensure that it is working correctly.
-// TODO: Look into average precision, binary code modulation strategy
+// TODO: Look into average precision and binary code modulation strategies to see
 // if they would be a better fit for this use case.
 impl TickModulator for SimpleTickModulator {
    fn new(percent: f32) -> Self {
        let ticks_required: u32 = (1f32 / (1f32 - percent)).round() as u32;
@@ -34,15 +44,12 @@ impl TickModulator for SimpleTickModulator {
    }
    fn next(&mut self) -> bool {
        self.ticks_left -= 1;
        // Return whether or not we should skip this tick
        if self.ticks_left == 0 {
            // We've reached the tick to skip, reset the counter
            self.ticks_left = self.tick_count;
-            false
+            return false;
        } else {
            true
        }
        self.ticks_left -= 1;
        true
    }
 }
--- a/src/pacman.rs
+++ b/src/pacman.rs
@@ -1,3 +1,4 @@
 //! This module defines the Pac-Man entity, including its behavior and rendering.
 use std::cell::RefCell;
 use std::rc::Rc;
@@ -17,11 +18,18 @@ use crate::{
    modulation::{SimpleTickModulator, TickModulator},
 };
 /// The Pac-Man entity.
 pub struct Pacman<'a> {
-    // Absolute position on the board (precise)
+    /// The absolute position of Pac-Man on the board, in pixels.
-    pub position: (i32, i32),
+    pub pixel_position: (i32, i32),
    /// The position of Pac-Man on the board, in grid coordinates.
    /// This is only updated at the moment Pac-Man is aligned with the grid.
    pub cell_position: (u32, u32),
    /// The current direction of Pac-Man.
    pub direction: Direction,
    /// The next direction of Pac-Man, which will be applied when Pac-Man is next aligned with the grid.
    pub next_direction: Option<Direction>,
    /// Whether Pac-Man is currently stopped.
    pub stopped: bool,
    map: Rc<RefCell<Map>>,
    speed: u32,
@@ -30,13 +38,21 @@ pub struct Pacman<'a> {
 }
 impl Pacman<'_> {
    /// Creates a new `Pacman` instance.
    ///
    /// # Arguments
    ///
    /// * `starting_position` - The starting position of Pac-Man, in grid coordinates.
    /// * `atlas` - The texture atlas containing the Pac-Man sprites.
    /// * `map` - A reference to the game map.
    pub fn new<'a>(
        starting_position: (u32, u32),
        atlas: Texture<'a>,
        map: Rc<RefCell<Map>>,
    ) -> Pacman<'a> {
        Pacman {
-            position: Map::cell_to_pixel(starting_position),
+            pixel_position: Map::cell_to_pixel(starting_position),
            cell_position: starting_position,
            direction: Direction::Right,
            next_direction: None,
            speed: 3,
@@ -47,43 +63,85 @@ impl Pacman<'_> {
        }
    }
    /// Renders Pac-Man to the canvas.
    ///
    /// # Arguments
    ///
    /// * `canvas` - The SDL canvas to render to.
    pub fn render(&mut self, canvas: &mut Canvas<Window>) {
        // When stopped, render the last frame of the animation
        if self.stopped {
            self.sprite
-                .render_until(canvas, self.position, self.direction, 2);
+                .render_until(canvas, self.pixel_position, self.direction, 2);
        } else {
-            self.sprite.render(canvas, self.position, self.direction);
+            self.sprite
                .render(canvas, self.pixel_position, self.direction);
        }
    }
    /// Calculates the next cell in the given direction.
    ///
    /// # Arguments
    ///
    /// * `direction` - The direction to check. If `None`, the current direction is used.
    pub fn next_cell(&self, direction: Option<Direction>) -> (i32, i32) {
        let (x, y) = direction.unwrap_or(self.direction).offset();
-        let cell = self.cell_position();
+        let cell = self.cell_position;
        (cell.0 as i32 + x, cell.1 as i32 + y)
    }
-    fn handle_requested_direction(&mut self) {
+    /// Handles a requested direction change.
-        if self.next_direction.is_none() {
+    ///
-            return;
+    /// The direction change is only applied if the next tile in the requested
-        }
+    /// direction is not a wall.
-        if self.next_direction.unwrap() == self.direction {
+    fn handle_direction_change(&mut self) -> bool {
-            self.next_direction = None;
+        match self.next_direction {
-            return;
+            // If there is no next direction, do nothing.
            None => return false,
            // If the next direction is the same as the current direction, do nothing.
            Some(next_direction) => {
                if next_direction == self.direction {
                    self.next_direction = None;
                    return false;
                }
            }
        }
        // Get the next cell in the proposed direction.
        let proposed_next_cell = self.next_cell(self.next_direction);
        let proposed_next_tile = self
            .map
            .borrow()
            .get_tile(proposed_next_cell)
            .unwrap_or(MapTile::Empty);
-        if proposed_next_tile != MapTile::Wall {
+
-            self.direction = self.next_direction.unwrap();
+        // If the next tile is a wall, do nothing.
-            self.next_direction = None;
+        if proposed_next_tile == MapTile::Wall {
            return false;
        }
        // If the next tile is not a wall, change direction.
        event!(
            tracing::Level::DEBUG,
            "Direction change: {:?} -> {:?} at position ({}, {}) internal ({}, {})",
            self.direction,
            self.next_direction.unwrap(),
            self.pixel_position.0,
            self.pixel_position.1,
            self.internal_position().0,
            self.internal_position().1
        );
        self.direction = self.next_direction.unwrap();
        self.next_direction = None;
        true
    }
    /// Returns the internal position of Pac-Man, rounded down to the nearest
    /// even number.
    ///
    /// This is used to ensure that Pac-Man is aligned with the grid before
    /// changing direction.
    fn internal_position_even(&self) -> (u32, u32) {
        let (x, y) = self.internal_position();
        ((x / 2u32) * 2u32, (y / 2u32) * 2u32)
@@ -98,15 +156,11 @@ impl Entity for Pacman<'_> {
    }
    fn position(&self) -> (i32, i32) {
-        self.position
+        self.pixel_position
    }
    fn cell_position(&self) -> (u32, u32) {
-        let (x, y) = self.position;
+        self.cell_position
        (
            (x as u32 / CELL_SIZE) - BOARD_OFFSET.0,
            (y as u32 / CELL_SIZE) - BOARD_OFFSET.1,
        )
    }
    fn internal_position(&self) -> (u32, u32) {
@@ -115,13 +169,35 @@ impl Entity for Pacman<'_> {
    }
    fn tick(&mut self) {
        // Pac-Man can only change direction when he is perfectly aligned with the grid.
        let can_change = self.internal_position_even() == (0, 0);
-        if can_change {
+        if let Some(next_direction) = self.next_direction {
-            self.handle_requested_direction();
+            if next_direction == self.direction.opposite() {
                let next_tile_position = self.next_cell(Some(next_direction));
                let next_tile = self
                    .map
                    .borrow()
                    .get_tile(next_tile_position)
                    .unwrap_or(MapTile::Empty);
-            let next = self.next_cell(None);
+                if next_tile != MapTile::Wall {
-            let next_tile = self.map.borrow().get_tile(next).unwrap_or(MapTile::Empty);
+                    self.direction = next_direction;
                    self.next_direction = None;
                }
            }
        }
        if can_change {
            self.handle_direction_change();
            // Check if the next tile in the current direction is a wall.
            let next_tile_position = self.next_cell(None);
            let next_tile = self
                .map
                .borrow()
                .get_tile(next_tile_position)
                .unwrap_or(MapTile::Empty);
            if !self.stopped && next_tile == MapTile::Wall {
                event!(tracing::Level::DEBUG, "Wall collision. Stopping.");
@@ -136,18 +212,26 @@ impl Entity for Pacman<'_> {
            let speed = self.speed as i32;
            match self.direction {
                Direction::Right => {
-                    self.position.0 += speed;
+                    self.pixel_position.0 += speed;
                }
                Direction::Left => {
-                    self.position.0 -= speed;
+                    self.pixel_position.0 -= speed;
                }
                Direction::Up => {
-                    self.position.1 -= speed;
+                    self.pixel_position.1 -= speed;
                }
                Direction::Down => {
-                    self.position.1 += speed;
+                    self.pixel_position.1 += speed;
                }
            }
            // Update the cell position if Pac-Man is aligned with the grid.
            if self.internal_position_even() == (0, 0) {
                self.cell_position = (
                    (self.pixel_position.0 as u32 / CELL_SIZE) - BOARD_OFFSET.0,
                    (self.pixel_position.1 as u32 / CELL_SIZE) - BOARD_OFFSET.1,
                );
            }
        }
    }
 }
Author	SHA1	Message	Date
Xevion	fd7eecf53e	feat: allow instant direction reversal, improve cell position state tracking	2025-07-22 12:12:41 -05:00
Xevion	f540dc5373	docs: minor documentation commentsa cross project	2025-07-22 12:12:41 -05:00
Xevion	f51a3ddeb0	chore: web frontend files	2025-07-22 10:06:30 -05:00
Xevion	9f7c460369	chore: ignore ephemeral submodules, build.css	2025-07-22 10:06:13 -05:00
Xevion	2c0df99dea	fix: emscripten libc, dynamic feature targets for emscripten, vcpkg triplets for linux	2025-07-22 10:05:07 -05:00
Xevion	cf12a04c69	chore: use emscripten linker args direct from demo project	2025-07-22 09:19:46 -05:00
Xevion	fa7e985c0d	feat: embedded data files, audio effects processing	2025-07-21 22:30:40 -05:00