feat: enable sdl2 gfx feature, update sdl2, use vcpkg for library builds

.cargo/config.toml

@@ -1,4 +1,10 @@
 [target.wasm32-unknown-emscripten]
+# TODO: Document what the fuck this is.
 rustflags = [
-    "--use-preload-plugins --preload-file assets -s USE_SDL=2 -s USE_SDL_IMAGE=2 -s ASSERTIONS=1",
+    "-O", "-C", "link-args=-O2 --profiling",
+    #"-C", "link-args=-O3 --closure 1",
+    "-C", "link-args=-sASYNCIFY -sALLOW_MEMORY_GROWTH=1",
+    "-C", "link-args=-sUSE_SDL=2 -sUSE_SDL_IMAGE=2 -sSDL2_IMAGE_FORMATS=['png']",
+    # USE_OGG, USE_VORBIS for OGG/VORBIS usage
+    "-C", "link-args=--preload-file assets/",
 ]

.github/workflows/deploy.yaml

@@ -1,4 +1,4 @@
-name: Github Pages
+name: Build
 
 on: [push]
 
@@ -6,23 +6,220 @@ permissions:
   contents: write
 
 jobs:
-  build-github-pages:
+  wasm:
     runs-on: ubuntu-latest
+
+    permissions:
+      pages: write
+      id-token: write
+
     steps:
-      - uses: actions/checkout@v2 # repo checkout
-      - uses: mymindstorm/setup-emsdk@v11 # setup emscripten toolchain
-        # with:
-        #   version: 3.1.35
-      - uses: actions-rs/toolchain@v1 # get rust toolchain for wasm
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Emscripten SDK
+        uses: mymindstorm/setup-emsdk@v14
+        with:
+          version: 3.1.43
+
+      - name: Setup Rust (WASM32 Emscripten)
+        uses: dtolnay/rust-toolchain@stable
         with:
-          toolchain: stable
           target: wasm32-unknown-emscripten
-          override: true
-      - name: Rust Cache # cache the rust build artefacts
-        uses: Swatinem/rust-cache@v1
-      - name: Build # build
-        run: ./build.sh
-      - name: Deploy
-        uses: JamesIves/github-pages-deploy-action@v4
+
+      - name: Rust Cache
+        uses: Swatinem/rust-cache@v2
+
+      - name: Install pnpm
+        uses: pnpm/action-setup@v3
         with:
-          folder: dist
+          version: 8
+          run_install: true
+
+      - name: Build
+        run: ./scripts/build.sh -er # release mode, skip emsdk
+
+      - name: Upload Artifact
+        uses: actions/upload-pages-artifact@v3
+        with:
+          path: "./dist/"
+          retention-days: 7
+
+      - name: Deploy
+        uses: actions/deploy-pages@v4
+
+  linux:
+    runs-on: ubuntu-latest
+    env:
+      TARGET: x86_64-unknown-linux-gnu
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Install SDL2 Packages
+        run: sudo apt-get install libsdl2-dev libsdl2-image-dev libsdl2-mixer-dev libsdl2-ttf-dev libsdl2-gfx-dev
+
+      - name: Setup Rust Toolchain (Linux)
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          target: ${{ env.TARGET }}
+
+      - name: Rust Cache
+        uses: Swatinem/rust-cache@v2
+
+      - name: Build
+        run: cargo build --release
+
+      - name: Assemble Archive
+        run: |
+          mkdir /tmp/example/
+          cp ./target/release/pacman /tmp/example/
+          chmod a+x /tmp/example/pacman
+          mkdir /tmp/example/assets
+          cp ./assets/TerminalVector.ttf ./assets/fruit.png /tmp/example/assets
+
+      - name: Install Cargo Binstall
+        uses: cargo-bins/cargo-binstall@main
+
+      - name: Acquire Package Version
+        run: |
+          cargo binstall toml-cli -y
+          PACKAGE_VERSION=$(toml get ./Cargo.toml package.version --raw)
+          echo "PACKAGE_VERSION=${PACKAGE_VERSION}" >> $GITHUB_ENV
+
+      - name: Upload Artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: "pacman-${{ env.PACKAGE_VERSION }}-${{ env.TARGET }}"
+          path: /tmp/example/
+          retention-days: 7
+          if-no-files-found: error
+
+  macos:
+    runs-on: macos-13
+    env:
+      TARGET: x86_64-apple-darwin
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Install SDL2 Packages
+        run: brew install sdl2 sdl2_image sdl2_mixer sdl2_ttf sdl2_gfx
+
+      - name: Setup Rust Toolchain (MacOS)
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          target: ${{ env.TARGET }}
+
+      - name: Rust Cache
+        uses: Swatinem/rust-cache@v2
+
+      - name: Build
+        run: cargo build --release
+
+      - name: Assemble Archive
+        run: |
+          mkdir /tmp/example/
+          cp ./target/release/pacman /tmp/example/
+          mkdir /tmp/example/assets
+          cp ./assets/TerminalVector.ttf ./assets/fruit.png /tmp/example/assets
+
+      - name: Install Cargo Binstall
+        uses: cargo-bins/cargo-binstall@main
+
+      - name: Acquire Package Version
+        run: |
+          cargo binstall toml-cli -y
+          PACKAGE_VERSION=$(toml get ./Cargo.toml package.version --raw)
+          echo "PACKAGE_VERSION=${PACKAGE_VERSION}" >> $GITHUB_ENV
+
+      - name: Upload Artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: "pacman-${{ env.PACKAGE_VERSION }}-${{ env.TARGET }}"
+          path: /tmp/example/
+          retention-days: 7
+          if-no-files-found: error
+
+  windows:
+    env:
+      TARGET: x86_64-pc-windows-gnu
+      SDL2: 2.30.2
+      SDL2_TTF: 2.22.0
+      SDL2_MIXER: 2.8.0
+      SDL2_IMAGE: 2.8.2
+      # SDL2_GFX: 1.0.4
+    runs-on: windows-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Download SDL2 Libraries
+        run: |
+          curl -L "https://github.com/libsdl-org/SDL/releases/download/release-${{ env.SDL2 }}/SDL2-devel-${{ env.SDL2 }}-VC.zip" -o "sdl2_devel.zip"
+          curl -L "https://github.com/libsdl-org/SDL_mixer/releases/download/release-${{ env.SDL2_MIXER }}/SDL2_mixer-devel-${{ env.SDL2_MIXER }}-VC.zip" -o "sdl2_mixer_devel.zip"
+          curl -L "https://github.com/libsdl-org/SDL_ttf/releases/download/release-${{ env.SDL2_TTF }}/SDL2_ttf-devel-${{ env.SDL2_TTF }}-VC.zip" -o "sdl2_ttf_devel.zip"
+          curl -L "https://github.com/libsdl-org/SDL_image/releases/download/release-${{ env.SDL2_IMAGE }}/SDL2_image-devel-${{ env.SDL2_IMAGE }}-VC.zip" -o "sdl2_image_devel.zip"
+
+      - name: Extract SDL2 DLLs
+        run: |
+          7z x ./sdl2_devel.zip -o"./tmp/"
+          mv ./tmp/SDL2-${{ env.SDL2 }}/lib/x64/SDL2.dll ./
+          mv ./tmp/SDL2-${{ env.SDL2 }}/lib/x64/SDL2.lib ./
+
+          7z x ./sdl2_mixer_devel.zip -o"./tmp/"
+          mv ./tmp/SDL2_mixer-${{ env.SDL2_MIXER }}/lib/x64/SDL2_mixer.dll ./
+          mv ./tmp/SDL2_mixer-${{ env.SDL2_MIXER }}/lib/x64/SDL2_mixer.lib ./
+
+          7z x ./sdl2_ttf_devel.zip -o"./tmp/"
+          mv ./tmp/SDL2_ttf-${{ env.SDL2_TTF }}/lib/x64/SDL2_ttf.dll ./
+          mv ./tmp/SDL2_ttf-${{ env.SDL2_TTF }}/lib/x64/SDL2_ttf.lib ./
+
+          7z x ./sdl2_image_devel.zip -o"./tmp/"
+          mv ./tmp/SDL2_image-${{ env.SDL2_IMAGE }}/lib/x64/SDL2_image.dll ./
+          mv ./tmp/SDL2_image-${{ env.SDL2_IMAGE }}/lib/x64/SDL2_image.lib ./
+
+      - name: Install SDL2_gfx
+        run: |
+          C:\vcpkg\vcpkg.exe install sdl2-gfx:x64-windows-release
+          cp C:\vcpkg\packages\sdl2-gfx_x64-windows-release\bin\SDL2_gfx.dll ./
+          cp C:\vcpkg\packages\sdl2-gfx_x64-windows-release\lib\SDL2_gfx.lib ./
+
+      - name: Setup Rust (Windows)
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: ${{ env.TARGET }}
+
+      - name: Rust Cache
+        uses: Swatinem/rust-cache@v2
+
+      - name: Build
+        run: cargo build --release
+
+      - name: Prepare Archive
+        run: |
+          New-Item -Type Directory ./release/
+          Move-Item -Path ./target/release/pacman.exe -Destination ./release/
+          Move-Item -Path ./SDL2.dll, ./SDL2_image.dll, ./SDL2_ttf.dll, ./SDL2_mixer.dll, ./SDL2_gfx.dll -Destination ./release/
+          New-Item -Type Directory ./release/assets/
+          Move-Item -Path ./assets/TerminalVector.ttf, ./assets/fruit.png -Destination ./release/assets/
+
+      - name: Install Cargo Binstall
+        uses: cargo-bins/cargo-binstall@main
+
+      - name: Acquire Package Version
+        run: |
+          cargo binstall toml-cli -y
+          PACKAGE_VERSION=$(toml get ./Cargo.toml package.version --raw)
+          echo "PACKAGE_VERSION=${PACKAGE_VERSION}" >> $env:GITHUB_ENV
+
+      - name: Upload Artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: "pacman-${{ env.PACKAGE_VERSION }}-${{ env.TARGET }}"
+          path: ./release/
+          retention-days: 7
+          if-no-files-found: error

BUILD.md

@@ -0,0 +1,7 @@
+# Building Pac-Man
+
+## GitHub Actions Workflow
+
+1. Build workflow produces executables & WASM files for all platforms
+2. Uploaded as artifacts
+3. Deployment workflow downloads artifacts and uploads to GitHub Pages

Cargo.lock

@@ -17,6 +17,12 @@ version = "1.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
+[[package]]
+name = "c_vec"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fdd7a427adc0135366d99db65b36dae9237130997e560ed61118041fb72be6e8"
+
 [[package]]
 name = "cfg-if"
 version = "1.0.0"
@@ -160,11 +166,12 @@ checksum = "e5ea92a5b6195c6ef2a0295ea818b312502c6fc94dde986c5553242e18fd4ce2"
 
 [[package]]
 name = "sdl2"
-version = "0.35.2"
+version = "0.38.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f7959277b623f1fb9e04aea73686c3ca52f01b2145f8ea16f4ff30d8b7623b1a"
+checksum = "2d42407afc6a8ab67e36f92e80b8ba34cbdc55aaeed05249efe9a2e8d0e9feef"
 dependencies = [
  "bitflags",
+ "c_vec",
  "lazy_static",
  "libc",
  "sdl2-sys",
@@ -172,12 +179,13 @@ dependencies = [
 
 [[package]]
 name = "sdl2-sys"
-version = "0.35.2"
+version = "0.38.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e3586be2cf6c0a8099a79a12b4084357aa9b3e0b0d7980e3b67aaf7a9d55f9f0"
+checksum = "3ff61407fc75d4b0bbc93dc7e4d6c196439965fbef8e4a4f003a36095823eac0"
 dependencies = [
  "cfg-if",
  "libc",
+ "vcpkg",
  "version-compare",
 ]
 
@@ -311,6 +319,12 @@ version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "830b7e5d4d90034032940e4ace0d9a9a057e7a45cd94e6c007832e39edb82f6d"
 
+[[package]]
+name = "vcpkg"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
+
 [[package]]
 name = "version-compare"
 version = "0.1.1"

Cargo.toml

@@ -7,8 +7,20 @@ edition = "2021"
 
 [dependencies]
 lazy_static = "1.4.0"
-sdl2 = { version = "0.35", features = ["image", "ttf", "mixer"] }
 spin_sleep = "1.1.1"
 tracing = { version = "0.1.37", features = ["max_level_debug", "release_max_level_warn"]}
 tracing-error = "0.2.0"
 tracing-subscriber = {version = "0.3.17", features = ["env-filter"]}
+
+[dependencies.sdl2]
+version = "0.38"
+default-features = false
+features = ["ttf","image","gfx","mixer","static-link","use-vcpkg"]
+
+[package.metadata.vcpkg]
+dependencies = ["sdl2", "sdl2-image[libjpeg-turbo,tiff,libwebp]", "sdl2-ttf", "sdl2-gfx", "sdl2-mixer"]
+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" }

README.md

@@ -23,6 +23,9 @@ at.
 - More than 4 ghosts
 - Custom Level Generation
     - Multi-map tunnelling
+- Online Scoreboard
+    - WebAssembly build contains a special API key for communicating with server.
+    - To prevent abuse, the server will only accept scores from the WebAssembly build.
 
 ## Installation
 

STORY.md

@@ -0,0 +1,333 @@
+# Story
+
+This is living document that describes the story of the project, from inspiration to solution.
+When a website is available, this document will help curate it's content.
+
+## Inspiration
+
+I initially got the idea for this project after finding a video about another Pac-Man clone on YouTube.
+
+[![Code Review Thumbnail][code-review-thumbnail]][code-review-video]
+
+This implementation was written in C++, used SDL2 for graphics, and was kinda weird - but it worked.
+
+- I think it was weird because the way it linked files together is extremely non-standard.
+  Essentially, it was a single file that included all the other files. This is not how C++ projects are typically structured.
+- This implementation was also extremely dependent on OOP; Rust has no real counterpart for OOP code, so writing my own implementation would be a challenge.
+
+## Lifetimes
+
+Rust's SDL2 implementation is a wrapper around the C library, so it's not as nice as the C++ implementation.
+Additionally, lifetimes in this library are a bit weird, making them quite difficult to deal with.
+
+I found a whole blog post complaining about this ([1][fighting-lifetimes-1], [2][fighting-lifetimes-2], [3][fighting-lifetimes-3]), so I'm not alone in this.
+
+## Emscripten & RuggRogue
+
+One of the targets for this project is to build a web-accessible version of the game. If you were watching at all during
+the Rust hype, one of it's primary selling points was a growing community of Rust-based web applications, thanks to
+WebAssembly.
+
+The problem is that much of this work was done for pure-Rust applications - and SDL is C++.
+This requires a C++ WebAssembly compiler such as Emscripten; and it's a pain to get working.
+
+Luckily though, someone else has done this before, and they fully documented it - [RuggRouge][ruggrouge].
+- Built with Rust
+- Uses SDL2
+- Compiling for WebAssembly with Emscripten
+- Also compiles for Windows & Linux
+
+This repository has been massively helpful in getting my WebAssembly builds working.
+
+## Key Capturing Extensions in WASM Build
+
+Some extensions I had installed were capturing keys.
+The issue presented with some keys never being sent to the application.
+To confirm, enter safe mode or switch to a different browser without said extensions.
+If the issue disappears, it's because of an extension in your browser stealing keys in a way that is incompatible with the batshit insanity of Emscripten.
+
+
+## A Long Break
+
+After hitting a wall with an issue with Emscripten where the tab would freeze after switching tabs (making it into a background tab), I decided to take a break from the project. A couple months went by without anything going on.
+
+## Revisiting
+
+I decided to revisit the project because I didn't want to see this project die. It's actually a lot of fun, and has a very interesting stack, with a simple premise, and a lot of potential for expansion.
+
+Unfortunately, the issue above still lingered. I did a lot of testing, and concluded that I needed to create a simple example with as much stripped away as possible. All I learned from this was that the freeze occurred the moment that the 'Hidden' event (for the Window) was fired. After that, the rendered would take 0 nanoseconds to render, and some script for Asyncify would keep spinning in the background.
+
+I tried to ask around but didn't get anywhere, but one reply on my post gave me the idea to back away from Emscripten 1.39.20 (several years old at this point).
+
+## Emscripten Callback Main Loop
+
+I looked into as many examples online (not that many), and came across an Emscripten callback loop exposed in C. Some were basic and all over the place, some were advanced, but also imbibed extremely annoying static lifetime requirements.
+
+- I tried my best to satisfy and work with these lifetimes, but it was a nightmare.
+- Instead, I tried to simplify and move away from this annoying Emscripten callback loop, but simpler ones had issues, crashing with `invalid renderer` errors.
+  - This guy named Greg Buchholz apparently was the creator of this special Emscripten bindings with the static lifetimes, and it was done to solve this issue with `invalid renderer`.
+  - [GitHub](https://github.com/gregbuchholz), [Repository](https://github.com/gregbuchholz/RuSDLem), [StackOverflow](https://stackoverflow.com/questions/69748049/rust-sdl2-emscripten-and-invalid-renderer-panic), [Forum Post](https://users.rust-lang.org/t/sdl2-emscripten-asmjs-and-invalid-renderer-panic/66567/2)
+
+With this in mind, it seemed like I was at a dead end AGAIN; either I had to deal with the static lifetimes (I am not that good at Rust), or I had to deal with Asyncify.
+
+But this did help me narrow my search even more for a good example. I needed to find a repository with Rust, SDL2, Emscripten, and `TextureCreator`.
+
+`TextureCreator` was key, as the static lifetimes issue was most encumbering when dealing with borrows and lifetimes of `TextureCreator` inside the `main` loop closure.
+
+## Return to Asyncify
+
+I found [one such repository](https://github.com/KyleMiles/Rust-SDL-Emscripten-Template/), and interestingly, it used `latest` Emscripten (not a specific target like 1.39.20), and was new enough (2 years old, but still new enough) to be relevant.
+
+Even more interesting, it didn't use the `main` loop closure, but instead used Emscripten's *Asyncify* feature to handle the main loop.
+
+But, unlike my original project which called `std::thread::sleep` directly, it used bindings into Emscripten's functions like `emscripten_sleep`.
+
+Even better, it had an example of script execution (JavaScript) bindings, which I could use to handle all sorts of things. I tested it out, and it worked.
+
+## Instant::now() 32-bit Byte Cutoff
+
+Unfortunately while trying to get basic FPS timings working, I got divide by zero errors when trying to calculate the time difference between two `Instant` times.
+
+This was weird, and honestly, I'm confused as to why the 2-year old sample code 'worked' at the time, but not now.
+
+After a bit of time, I noted that the `Instant` times were printing with only the whole seconds changing, and the nanoseconds were always 0.
+
+```
+Instant { tv_sec: 0, tv_nsec: 0 }
+Instant { tv_sec: 1, tv_nsec: 0 }
+Instant { tv_sec: 2, tv_nsec: 0 }
+Instant { tv_sec: 3, tv_nsec: 0 }
+Instant { tv_sec: 4, tv_nsec: 0 }
+...
+```
+
+This was super weird, but I stumbled upon [an issue on GitHub](https://github.com/rust-lang/rust/issues/113852) that mentioned the exact situation I was in, as well as providing a patch solution (`emscripten_get_now`).
+
+## VSync Gotcha
+
+After getting the timing working, I noticed that the rendering was extremely slow. I was getting 60 FPS, but I wasn't sleeping at all.
+
+Normally when rendering occurs, you want to sleep for the remaining time so that your game calculations can occur at a consistent rate (60 FPS for example).
+
+If your rendering time is less than the sleep time, you can just sleep for the remaining time. But if your rendering time is greater than the sleep time, you encounter lag, the FPS starts to drop.
+
+This was a confusing issue as I knew it couldn't be a coincidence that the rendering time was exactly ~16ms (60 FPS) every time.
+
+After a little bit though, I found the `present_vsync` function in the SDL2 render initialization. This was causing the rendering to try and time the canvas present() to the monitor's refresh rate (60 FPS).
+
+Maybe I could have skipped my custom timing and just used this, but I don't know if it would be platform-independent, what would happen on 120 FPS displays, etc.
+
+## Emscripten v.s. SDL2-TTF
+
+While working on the next extension of SDL2 for my test repository, SDL2-TTF had some pretty annoying issues. It would build fine, but it would raise a runtime error: `indirect call to null`.
+
+Luckily, I had a recently updated repository to copy off of, and the working fix was to lower the EMSDK version to `3.1.43`.
+
+[Source](https://github.com/aelred/tetris/blob/0ad88153db1ca7962b42277504c0f7f9f3c675a9/tetris-sdl/src/main.rs#L34)
+```rust
+static FONT_DATA: &[u8] = include_bytes!("../assets/TerminalVector.ttf");
+
+#[cfg(not(target_os = "emscripten"))]
+fn ttf_context() -> ttf::Sdl2TtfContext {
+    ttf::init().unwrap()
+}
+
+#[cfg(target_os = "emscripten")]
+fn ttf_context() -> &'static ttf::Sdl2TtfContext {
+    // Deliberately leak so we get a static lifetime
+    Box::leak(Box::new(ttf::init().unwrap()))
+}
+
+const FONT_MULTIPLE: u16 = 9;
+
+// Funny division is done here to round to nearest multiple of FONT_MULTIPLE
+const FONT_SIZE: u16 = (WINDOW_HEIGHT / 32) as u16 / FONT_MULTIPLE * FONT_MULTIPLE;
+
+fn main() {
+  ...
+
+  let font_data = RWops::from_bytes(FONT_DATA).unwrap();
+  let font_size = max(FONT_SIZE, FONT_MULTIPLE);
+  let font = ttf_context
+      .load_font_from_rwops(font_data, font_size)
+      .unwrap();
+}
+```
+
+I don't particularly understand why loading from memory is used, but it's a neat trick. I tested normal font loading afterwards, and it seems to be totally fine.
+
+On to the Mixer extension, then.
+
+## Mixer and GFX
+
+Mixer was relatively easy, I don't remember anything special about it.
+
+As it happens, neither was SDL GFX, except for me finding that getting it compiling on Windows would soon be difficult; `SDL2_gfx` is not currently being updated, nor is it managed by the SDL team. This meant that no releases of development libraries including DLLs or LIB files were going to be available.
+
+When I added in GFX, I wanted to add some mouse interaction since that currently wasn't being done anywhere in the demo, but I also wanted the ability for the mouse to be hidden until used.
+
+Detecting whether the mouse was focusing the window or not wasn't super easy, and I'm still not sure that it's working perfectly, but at the very least Emscripten seems to support what I'm trying to do. I should look into asynchronous Javascript callbacks, see what Emscripten supports.
+
+## Styling with PostCSS + Tailwind
+
+I'm big on using Tailwind, and while this project probably could have done without it, I didn't want to forego my favorite tool.
+
+But I also didn't want to include some big framework on this, like Astro, so I looked for the smallest way to include Tailwind.
+
+After fiddling and failing to find Hugo suitable, I stuck to plain HTML & the PostCSS method, which worked great. It's definitely not that fast for rapid development, but it works well enough.
+
+The only thing I'm unsatisfied with is why `postcss-cli` wasn't working when executed from `pnpm`. It works just fine from `pnpx`, but it has to download and setup the whole package on *every single invocation*, which is super slow. And probably expensive, in the long run.
+
+## Cross-platform Builds
+
+With the next step of the demo project, I needed to get builds for every OS running, that's one down out of the four targets I'm gunning for.
+
+Linux was the easiest, as usual, with `apt` providing access to all the development libraries of SDL & the associated extensions, including `SDL2_gfx`.
+
+There's also no requirement for providing sidecar DLLs like Windows needs, so that worked well.
+The hardest part was figuring out the most satisfying way to zip and load all the assets together, but luckily the artifact uploader provides it's own zip implementation; albeit I may need to modify it to add further system hinting (`.tar.gz` for Linux, `.dmg` for MacOS, `.zip` for Windows).
+
+## SDL2 on Windows
+
+SDL2 on Windows has to be one of the least fun development cycles; setting up the environment is pretty painful as there's almost no guides for Rust users to figure out each requirement. You'll learn fast, and this knowledge is hands on experience that will probably be applicable later on in C++ development, but I'm sure a fair number of Rust users like myself have no idea why a DLL or LIB file is necessary at all.
+
+To be honest, I still don't.
+
+Regardless, SDL2 needs a LIB file for compliation to be available in the root directory, and each extension has there own.
+
+Once the EXE is compiled, the working directory needs to contain a DLL file for execution, too. Each extension has it's own as well.
+
+This sounds easy, but acquiring these DLLs and LIB files is not easy. At the very least, the SDL-supported extensions have releases available containing
+
+![SDL2 Mixer GitHub Release Files](https://i.xevion.dev/ShareX/2024/04/firefox_6zAmbsD97n.png)
+
+So I got to creating a build step involving the download of each of these libraries. I'm no expert with `curl`, but I had it figured out eventually.
+
+```yaml
+- name: Download SDL2 Libraries
+  run: |
+    curl -L "https://github.com/libsdl-org/SDL/releases/download/release-${{ env.SDL2 }}/SDL2-devel-${{ env.SDL2 }}-VC.zip" -o "sdl2_devel.zip"
+    curl -L "https://github.com/libsdl-org/SDL_mixer/releases/download/release-${{ env.SDL2_MIXER }}/SDL2_mixer-devel-${{ env.SDL2_MIXER }}-VC.zip" -o "sdl2_mixer_devel.zip"
+    curl -L "https://github.com/libsdl-org/SDL_ttf/releases/download/release-${{ env.SDL2_TTF }}/SDL2_ttf-devel-${{ env.SDL2_TTF }}-VC.zip" -o "sdl2_ttf_devel.zip"
+    curl -L "https://github.com/libsdl-org/SDL_image/releases/download/release-${{ env.SDL2_IMAGE }}/SDL2_image-devel-${{ env.SDL2_IMAGE }}-VC.zip" -o "sdl2_image_devel.zip"
+```
+
+I did take a lot of care in making sure that versions were specified externally in different variables, which took a couple tries while I learned how interpolation works with GitHub Actions.
+
+Additionally, I realized that `LIB` files were required for compliation after this, so I had to painfully fix all the files to use the `-devel-` version. Speifically the one with `-VC` appended.
+
+I still do not know what VC means here. Perhaps it is related to `vcpkg` somehow.
+
+The next step was to extract the files I needed from the `.zip`s, but that proved quite hard. I'm a lover of precision and using tools to the best of my knowledge, so I wanted to finely take just the DLL and ZIP I needed from these archives, and nothing else.
+
+While I was able to get working commands to do this on Linux, finely finding the exact DLL and placing it in `pwd`, I was not able to replicate it on the Windows-imaged GitHub Runner;
+
+When specifying the `-o` flag meaning 'output directory here' like `-o./tmp` (yes, there is no space in between), it would always error with `Too short switch: -o`. I was unable to find meaningful discussions on Google.
+
+My Linux machine did not complain, and I wasn't yet ready to switch OSes for an error like this, so I just extracted everything and then `mv`'d the items into `pwd`.
+
+I knew what lay ahead with `SDL2_gfx`, so I tested whether the compilation error changed, and luckily, it was only erroring on the missing `SDL2_gfx.lib` at this point.
+
+While reading discussions online, I came across [a reddit post](https://www.reddit.com/r/rust_gamedev/comments/am84q9/using_sdl2_gfx_on_windows/efk6uwq/) talking about `vcpkg`. I'd heard of it, but never used the program before. It seemed like it could provide `SDL2_gfx` for me without hassle.
+
+And that was partly true.
+
+The primary 'boon' of `vcpkg` here was that it setup and compiled `SDL2_gfx` without the hassle of messing with the compiler, options, or most importantly: dependencies.
+
+I didn't know it at the time, but `SDL2_gfx` depended on `SDL2` directly, and so I'd have to setup and compile both projects, if I was hoping to do this 'manually'.
+
+## VCPKG for SDL2_GFX
+
+I tried to use the GitHub-provided environment variables relating to VCPKG's installation location, but nothing really worked here. I was on the correcti mage (`windows-latest` for Windows 2022 Enterprise on GitHub's Runner Images), but nothing seemed to work.
+
+[This comment](https://github.com/actions/runner-images/issues/6376#issuecomment-1781269302) seemed to describe the exact same experience I was happening, several months ago.
+
+Alas, I simply tried `C:\vcpkg\` and it worked, providing me the ability to install `SDL2_gfx`.
+
+As it were though, the hard part wasn't going to be compiling, but locating the DLLs and LIB files for movement. No matter where I looked online or in the logs, nothing was obvious about the location of my files.
+
+In retrospect, a recursive `Get-ChildItem` looking for `DLL` or `LIB` files probably would've worked well, but.. yeah...
+
+After a couple attempts with various test commits, I couldn't find it, and just switched to Windows to install and compile it myself, so I could locate the file manually.
+
+> Note: VCPKG is annoying to install, the executable provided by Visual Studio Community does not permit classic-mode usage, so you'll still need to clone and bootstrap VCPKG (instructions in the repository README).
+
+As it happens, they were placed in
+- `$VCPKG_ROOT\packages\sdl2-gfx_x64-windows-release\bin\SDL2_gfx.dll` and
+- `$VCPKG_ROOT\packages\sdl2-gfx_x64-windows-release\lib\SDL2_gfx.lib` respectively.
+
+This brings me to one issue, and one fix; while compiling you're required to specify that the build is for 64 bit systems manually, on each invocation of VCPKG (while in classic mode, which I am).
+
+On top of that, they'll be built in debug mode (with extra symbols and such) by default, which I am not interested in.
+
+To get the x64 Release build of a package, append `:x64-windows-release` to it, as in `sdl2-gfx:x64-windows-release` for `sdl2-gfx`.
+
+After getting this sorted, I struggled a little bit in using the `mv` (`Move-Item`) command in Powershell, as I battled with the comma delimited files when moving multiple files to a given destination. Dumb.
+
+This is also the point at which I renamed the executable from `pacman` to `spiritus` to differentiate the two projects. The name is just my play on the word 'sprite'.
+
+## Console Window Hiding
+
+When launching the demo app, I saw a console window pop up, even though I launched it from the File Explorer; this is not the behavior I was interested in.
+
+I believe that apps launched from File Explorer shouldn't have a console window available unless...
+
+- It's a CLI app by nature, and it uses the Console Window.
+- It has a specific debugging flag passed into it, perhaps by a Shortcut file.
+- The console window is required for the nature of the app, or it is the preferred method of log inspection.
+- It's a debug build.
+
+But if it's launched from the console, then it should either
+
+- Detach and relinquish control of the console back to the user.
+- Use the console actively in it's logging.
+
+Most programs I know and use follow this general consensus. Naturally, mine must too.
+
+But, when searching for a solution online, it seemed what I want doesn't really exist; I implemented the closest approximation.
+
+If `stdout` is detected to be a `tty` (an active console), the console window won't be hidden. Otherwise, it will be hidden.
+
+Unfortunately, this results in the millisecond flash of a black console window appearing.
+
+## Updating Deprecated Actions
+
+As it were, most of the actions I were using were deprecated in some way. It didn't feel like I was using super old actions, but I guess I was. Luckily, most of them were simply just updating the version (`2` or `3` to `4` or `5`).
+
+`actions-rs@toolchain` was different though, and was officially deprecated, the GitHub repository archived. Couldn't find a good reason why, but the repository was untouched in 4 years, so maybe that's why...
+
+I found `dtolnay@rust-toolchain` and switched, it more or less was perfect with no differences. I think it's sorta neat that the Rust version is specified using the version of the action. I'd be worried though of a changing feature set across different action versions...
+
+I guess a well designed GitHub Action shouldn't change much, including a Rust toolchain action.
+
+## Artifact Naming
+
+Perhaps it's super unnecessary and won't be appreciated, but I wanted the artifact files produced by my script to have semantic meaning in it's version and target.
+
+For each OS, I extracted the targets (`x86_64-unknown-linux-gnu`, `x86_64-apple-darwin`...) into an environment variable scoped at the job level (love that).
+
+I looked into ways to get the package version, but nothing obvious jumped out at me. I did come across `toml-cli` though, a Rust-based CLI program analogous to `jq` (for JSON).
+
+It worked great, but it was sorta slow; compiling `toml-cli` added an extra 20-60 seconds for each job. I'd heard of a Rust project to speed up builds by providing prebuilt executables though; it's called `binstall`.
+
+Even cooler, it was had an action available to easily add it to my build script, and so I had `toml-cli` installing and available 10x faster!
+
+![GitHub Actions output showing 2 cargo binstall process taking 4 seconds total](https://i.xevion.dev/ShareX/2024/04/firefox_5sOEDM7zkc.png)
+
+Perhaps I could use some special bash commands to acquire the package version, but it'd be a lot of work and maintenance to get it working in both bash and Powershell, maintaining it across four jobs.
+
+This is both cool, fast, and easy!
+
+![GitHub Artifacts with Sizes Listed](https://i.xevion.dev/ShareX/2024/04/firefox_jDI8MDwWRc.png)
+
+I was thinking of a github-pages artifact name that aligns with the others, but I think that'd be stupid AND overkill.
+
+Perhaps at the least I'll look into a 32-bit build for Windows, just for demonstration purposes.
+
+
+[code-review-video]: https://www.youtube.com/watch?v=OKs_JewEeOo
+[code-review-thumbnail]: https://img.youtube.com/vi/OKs_JewEeOo/hqdefault.jpg
+[fighting-lifetimes-1]: https://devcry.heiho.net/html/2022/20220709-rust-and-sdl2-fighting-with-lifetimes.html
+[fighting-lifetimes-2]: https://devcry.heiho.net/html/2022/20220716-rust-and-sdl2-fighting-with-lifetimes-2.html
+[fighting-lifetimes-3]: https://devcry.heiho.net/html/2022/20220724-rust-and-sdl2-fighting-with-lifetimes-3.html
+[ruggrogue]: https://tung.github.io/ruggrogue/

assets/index.html

@@ -0,0 +1,27 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
+</head>
+<style>
+    body {
+        margin: 0;
+        padding: 0;
+        background: #000;
+    }
+    canvas {
+        display: block;
+        margin: 0 auto;
+        background: #000;
+    }
+</style>
+<body>
+    <canvas id="canvas"></canvas>
+    <script>
+        var Module = {
+            'canvas': document.getElementById('canvas'),
+        };
+    </script>
+    <script src="pacman.js"></script>
+</body>
+</html>

build.ps1

@@ -1,7 +0,0 @@
-& cargo build --target=wasm32-unknown-emscripten --release
-
-mkdir -p dist -Force
-
-cp ./target/wasm32-unknown-emscripten/release/Pac_Man.wasm ./dist
-cp ./target/wasm32-unknown-emscripten/release/Pac-Man.js ./dist
-cp index.html dist

build.sh

@@ -1,10 +0,0 @@
-#!/bin/sh
-set -eux
-
-cargo build --target=wasm32-unknown-emscripten --release
-
-mkdir -p dist
-
-cp target/wasm32-unknown-emscripten/release/Pac_Man.wasm dist
-cp target/wasm32-unknown-emscripten/release/Pac-Man.js dist
-cp index.html dist

index.html

@@ -1,21 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-    <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
-</head>
-<body>
-    <canvas id="canvas"></canvas>
-    <script type="text/javascript">
-        let Module = {
-            canvas: (function () {
-                // this is how we provide a canvas to our sdl2
-                return document.getElementById("canvas");
-            })(),
-            preRun: [function () {
-                ENV.RUST_LOG = "info,wgpu=warn"
-            }]
-        };
-    </script>
-    <script src="Pac-Man.js"></script>
-</body>
-</html>

scripts/build.sh

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

serve.ps1

@@ -1,3 +0,0 @@
-& ./build.ps1
-cd ./dist
-python -m http.server

src/animation.rs

@@ -92,6 +92,7 @@ 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.
         let current = self.current_frame();
         self.render_static(canvas, position, direction, Some(current));
 

src/emscripten.rs

@@ -1,49 +0,0 @@
-// taken from https://github.com/Gigoteur/PX8/blob/master/src/px8/emscripten.rs
-#[cfg(target_os = "emscripten")]
-pub mod emscripten {
-    use std::cell::RefCell;
-    use std::ffi::{CStr, CString};
-    use std::os::raw::{c_char, c_float, c_int, c_void};
-    use std::ptr::null_mut;
-
-    #[allow(non_camel_case_types)]
-    type em_callback_func = unsafe extern "C" fn();
-
-    extern "C" {
-        // void emscripten_set_main_loop(em_callback_func func, int fps, int simulate_infinite_loop)
-        pub fn emscripten_set_main_loop(
-            func: em_callback_func,
-            fps: c_int,
-            simulate_infinite_loop: c_int,
-        );
-
-        pub fn emscripten_cancel_main_loop();
-        pub fn emscripten_pause_main_loop();
-        pub fn emscripten_get_now() -> c_float;
-    }
-
-    thread_local!(static MAIN_LOOP_CALLBACK: RefCell<*mut c_void> = RefCell::new(null_mut()));
-
-    pub fn set_main_loop_callback<F>(callback: F)
-    where
-        F: FnMut(),
-    {
-        MAIN_LOOP_CALLBACK.with(|log| {
-            *log.borrow_mut() = &callback as *const _ as *mut c_void;
-        });
-
-        unsafe {
-            emscripten_set_main_loop(wrapper::<F>, -1, 1);
-        }
-
-        unsafe extern "C" fn wrapper<F>()
-        where
-            F: FnMut(),
-        {
-            MAIN_LOOP_CALLBACK.with(|z| {
-                let closure = *z.borrow_mut() as *mut F;
-                (*closure)();
-            });
-        }
-    }
-}

src/game.rs

@@ -5,7 +5,6 @@ use sdl2::keyboard::Keycode;
 use sdl2::render::{Texture, TextureCreator};
 use sdl2::video::WindowContext;
 use sdl2::{pixels::Color, render::Canvas, video::Window};
-use tracing::event;
 
 use crate::constants::{MapTile, BOARD_HEIGHT, BOARD_WIDTH, RAW_BOARD};
 use crate::direction::Direction;
@@ -63,6 +62,8 @@ impl Game<'_> {
         self.canvas.set_draw_color(Color::RGB(0, 0, 0));
         self.canvas.clear();
 
+
+        // Render the map   
         self.canvas
             .copy(&self.map_texture, None, None)
             .expect("Could not render texture on canvas");
@@ -103,6 +104,7 @@ impl Game<'_> {
             self.draw_cell((next_cell.0 as u32, next_cell.1 as u32), Color::YELLOW);
         }
 
+        // Present the canvas
         self.canvas.present();
     }
 

src/helper.rs

@@ -1,15 +1,110 @@
+/// Checks if two grid positions are adjacent to each other
+///
+/// # Arguments
+/// * `a` - First position as (x, y) coordinates
+/// * `b` - Second position as (x, y) coordinates  
+/// * `diagonal` - Whether to consider diagonal adjacency (true) or only orthogonal (false)
+///
+/// # Returns
+/// * `true` if positions are adjacent according to the diagonal parameter
+/// * `false` otherwise
 pub fn is_adjacent(a: (u32, u32), b: (u32, u32), diagonal: bool) -> bool {
     let (ax, ay) = a;
     let (bx, by) = b;
+
+    // Calculate absolute differences between coordinates
+    let dx = if ax > bx { ax - bx } else { bx - ax };
+    let dy = if ay > by { ay - by } else { by - ay };
+
     if diagonal {
-        (ax == bx && (ay == by + 1 || ay == by - 1))
-            || (ay == by && (ax == bx + 1 || ax == bx - 1))
-            || (ax == bx + 1 && ay == by + 1)
-            || (ax == bx + 1 && ay == by - 1)
-            || (ax == bx - 1 && ay == by + 1)
-            || (ax == bx - 1 && ay == by - 1)
+        // For diagonal adjacency: both differences must be ≤ 1 and at least one > 0
+        dx <= 1 && dy <= 1 && (dx + dy) > 0
     } else {
-        (ax == bx && (ay == by + 1 || ay == by - 1))
-            || (ay == by && (ax == bx + 1 || ax == bx - 1))
+        // For orthogonal adjacency: exactly one difference must be 1, the other 0
+        (dx == 1 && dy == 0) || (dx == 0 && dy == 1)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_orthogonal_adjacency() {
+        // Test orthogonal adjacency (diagonal = false)
+
+        // Same position should not be adjacent
+        assert!(!is_adjacent((0, 0), (0, 0), false));
+
+        // Adjacent positions should be true
+        assert!(is_adjacent((0, 0), (1, 0), false)); // Right
+        assert!(is_adjacent((0, 0), (0, 1), false)); // Down
+        assert!(is_adjacent((1, 1), (0, 1), false)); // Left
+        assert!(is_adjacent((1, 1), (1, 0), false)); // Up
+
+        // Diagonal positions should be false
+        assert!(!is_adjacent((0, 0), (1, 1), false));
+        assert!(!is_adjacent((0, 1), (1, 0), false));
+
+        // Positions more than 1 step away should be false
+        assert!(!is_adjacent((0, 0), (2, 0), false));
+        assert!(!is_adjacent((0, 0), (0, 2), false));
+        assert!(!is_adjacent((0, 0), (2, 2), false));
+    }
+
+    #[test]
+    fn test_diagonal_adjacency() {
+        // Test diagonal adjacency (diagonal = true)
+
+        // Same position should not be adjacent
+        assert!(!is_adjacent((0, 0), (0, 0), true));
+
+        // Orthogonal adjacent positions should be true
+        assert!(is_adjacent((0, 0), (1, 0), true)); // Right
+        assert!(is_adjacent((0, 0), (0, 1), true)); // Down
+        assert!(is_adjacent((1, 1), (0, 1), true)); // Left
+        assert!(is_adjacent((1, 1), (1, 0), true)); // Up
+
+        // Diagonal adjacent positions should be true
+        assert!(is_adjacent((0, 0), (1, 1), true)); // Down-right
+        assert!(is_adjacent((1, 0), (0, 1), true)); // Down-left
+        assert!(is_adjacent((0, 1), (1, 0), true)); // Up-right
+        assert!(is_adjacent((1, 1), (0, 0), true)); // Up-left
+
+        // Positions more than 1 step away should be false
+        assert!(!is_adjacent((0, 0), (2, 0), true));
+        assert!(!is_adjacent((0, 0), (0, 2), true));
+        assert!(!is_adjacent((0, 0), (2, 2), true));
+        assert!(!is_adjacent((0, 0), (1, 2), true));
+    }
+
+    #[test]
+    fn test_edge_cases() {
+        // Test with larger coordinates
+        assert!(is_adjacent((100, 100), (101, 100), false));
+        assert!(is_adjacent((100, 100), (100, 101), false));
+        assert!(!is_adjacent((100, 100), (102, 100), false));
+
+        assert!(is_adjacent((100, 100), (101, 101), true));
+        assert!(!is_adjacent((100, 100), (102, 102), true));
+
+        // Test with zero coordinates
+        assert!(is_adjacent((0, 0), (1, 0), false));
+        assert!(is_adjacent((0, 0), (0, 1), false));
+        assert!(is_adjacent((0, 0), (1, 1), true));
+    }
+
+    #[test]
+    fn test_commutative_property() {
+        // The function should work the same regardless of parameter order
+        assert_eq!(
+            is_adjacent((1, 2), (2, 2), false),
+            is_adjacent((2, 2), (1, 2), false)
+        );
+
+        assert_eq!(
+            is_adjacent((1, 2), (2, 3), true),
+            is_adjacent((2, 3), (1, 2), true)
+        );
     }
 }

src/main.rs

@@ -1,34 +1,29 @@
 use crate::constants::{WINDOW_HEIGHT, WINDOW_WIDTH};
 use crate::game::Game;
-use sdl2::event::Event;
+use sdl2::event::{Event, WindowEvent};
 use sdl2::keyboard::Keycode;
-use spin_sleep::sleep;
 use std::time::{Duration, Instant};
 use tracing::event;
 use tracing_error::ErrorLayer;
 use tracing_subscriber::layer::SubscriberExt;
 
-#[cfg(target_os = "emscripten")]
-pub mod emscripten;
-
 mod animation;
 mod constants;
 mod direction;
 mod entity;
 mod game;
+mod helper;
 mod map;
 mod modulation;
 mod pacman;
 
-#[cfg(target_os = "emscripten")]
-mod emscripten;
-
 pub fn main() {
     let sdl_context = sdl2::init().unwrap();
     let video_subsystem = sdl_context.video().unwrap();
 
     // Setup tracing
     let subscriber = tracing_subscriber::fmt()
+        .with_ansi(cfg!(not(target_os = "emscripten")))
         .with_max_level(tracing::Level::DEBUG)
         .finish()
         .with(ErrorLayer::default());
@@ -43,7 +38,6 @@ pub fn main() {
 
     let mut canvas = window
         .into_canvas()
-        .accelerated()
         .build()
         .expect("Could not build canvas");
 
@@ -69,6 +63,7 @@ pub fn main() {
     let mut last_averaging_time = Instant::now();
     let mut sleep_time = Duration::ZERO;
     let mut paused = false;
+    let mut shown = false;
 
     event!(
         tracing::Level::INFO,
@@ -81,6 +76,17 @@ pub fn main() {
         // TODO: Fix key repeat delay issues by using VecDeque for instant key repeat
         for event in event_pump.poll_iter() {
             match event {
+                Event::Window { win_event, .. } => match win_event {
+                    WindowEvent::Hidden => {
+                        event!(tracing::Level::DEBUG, "Window hidden");
+                        shown = false;
+                    }
+                    WindowEvent::Shown => {
+                        event!(tracing::Level::DEBUG, "Window shown");
+                        shown = true;
+                    }
+                    _ => {}
+                },
                 // Handle quitting keys or window close
                 Event::Quit { .. }
                 | Event::KeyDown {
@@ -115,8 +121,17 @@ pub fn main() {
         }
 
         if start.elapsed() < loop_time {
-            let time = loop_time - start.elapsed();
-            sleep(time);
+            let time = loop_time.saturating_sub(start.elapsed());
+            if time != Duration::ZERO {
+                #[cfg(not(target_os = "emscripten"))]
+                {
+                    spin_sleep::sleep(time);
+                }
+                #[cfg(target_os = "emscripten")]
+                {
+                    std::thread::sleep(time);
+                }
+            }
             sleep_time += time;
         } else {
             event!(
@@ -128,9 +143,9 @@ pub fn main() {
 
         tick_no += 1;
 
-        const PERIOD: u32 = 60 * 2;
+        const PERIOD: u32 = 60 * 60;
         let tick_mod = tick_no % PERIOD;
-        if tick_mod % PERIOD == 0 || tick_no == PERIOD {
+        if tick_mod % PERIOD == 0 {
             let average_fps = PERIOD as f32 / last_averaging_time.elapsed().as_secs_f32();
             let average_sleep = sleep_time / PERIOD;
             let average_process = loop_time - average_sleep;
@@ -150,13 +165,6 @@ pub fn main() {
         true
     };
 
-    #[cfg(target_os = "emscripten")]
-    use emscripten::emscripten;
-
-    #[cfg(target_os = "emscripten")]
-    emscripten::set_main_loop_callback(main_loop);
-
-    #[cfg(not(target_os = "emscripten"))]
     loop {
         if !main_loop() {
             break;

src/pacman.rs

@@ -34,11 +34,11 @@ impl Pacman<'_> {
             position: Map::cell_to_pixel(starting_position),
             direction: Direction::Right,
             next_direction: None,
-            speed: 2,
+            speed: 3,
             map,
             stopped: false,
-            modulation: SimpleTickModulator::new(0.9333),
-            sprite: AnimatedTexture::new(atlas, 4, 3, 32, 32, Some((-4, -4))),
+            modulation: SimpleTickModulator::new(1.0),
+            sprite: AnimatedTexture::new(atlas, 2, 3, 32, 32, Some((-4, -4))),
         }
     }
 
@@ -77,6 +77,11 @@ impl Pacman<'_> {
             self.next_direction = None;
         }
     }
+
+    fn internal_position_even(&self) -> (u32, u32) {
+        let (x, y ) = self.internal_position();
+        ((x / 2u32) * 2u32, (y / 2u32) * 2u32)
+    }
 }
 
 impl Entity for Pacman<'_> {
@@ -104,7 +109,7 @@ impl Entity for Pacman<'_> {
     }
 
     fn tick(&mut self) {
-        let can_change = self.internal_position() == (0, 0);
+        let can_change = self.internal_position_even() == (0, 0);
 
         if can_change {
             self.handle_requested_direction();