mirror of
https://github.com/Xevion/Pac-Man.git
synced 2025-12-18 12:12:39 -06:00
Compare commits
2 Commits
v0.34.5
...
f80c89fdc1
| Author | SHA1 | Date | |
|---|---|---|---|
| f80c89fdc1 | |||
| 00c27273c1 |
@@ -1,5 +1,2 @@
|
||||
[profile.default]
|
||||
fail-fast = false
|
||||
|
||||
[profile.coverage]
|
||||
status-level = "none"
|
||||
|
||||
20
.github/dependabot.yml
vendored
20
.github/dependabot.yml
vendored
@@ -1,20 +0,0 @@
|
||||
# https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
|
||||
|
||||
version: 2
|
||||
updates:
|
||||
- package-ecosystem: "cargo"
|
||||
directory: "/"
|
||||
schedule:
|
||||
interval: "monthly"
|
||||
groups:
|
||||
dependencies:
|
||||
patterns:
|
||||
- "*"
|
||||
- package-ecosystem: "github-actions"
|
||||
directory: "/"
|
||||
schedule:
|
||||
interval: "monthly"
|
||||
groups:
|
||||
dependencies:
|
||||
patterns:
|
||||
- "*"
|
||||
26
.github/workflows/build.yaml
vendored
26
.github/workflows/build.yaml
vendored
@@ -14,23 +14,23 @@ jobs:
|
||||
- os: ubuntu-latest
|
||||
target: x86_64-unknown-linux-gnu
|
||||
artifact_name: pacman
|
||||
toolchain: 1.86.0
|
||||
toolchain: 1.88.0
|
||||
- os: macos-13
|
||||
target: x86_64-apple-darwin
|
||||
artifact_name: pacman
|
||||
toolchain: 1.86.0
|
||||
toolchain: 1.88.0
|
||||
- os: macos-latest
|
||||
target: aarch64-apple-darwin
|
||||
artifact_name: pacman
|
||||
toolchain: 1.86.0
|
||||
toolchain: 1.88.0
|
||||
- os: windows-latest
|
||||
target: x86_64-pc-windows-gnu
|
||||
artifact_name: pacman.exe
|
||||
toolchain: 1.86.0
|
||||
toolchain: 1.88.0
|
||||
runs-on: ${{ matrix.os }}
|
||||
steps:
|
||||
- name: Checkout
|
||||
uses: actions/checkout@v5
|
||||
uses: actions/checkout@v4
|
||||
|
||||
- name: Setup Rust Toolchain
|
||||
uses: dtolnay/rust-toolchain@master
|
||||
@@ -64,16 +64,15 @@ jobs:
|
||||
run: cargo build --release
|
||||
|
||||
- name: Acquire Package Version
|
||||
id: get_version
|
||||
shell: bash # required to prevent Windows runners from failing
|
||||
shell: bash
|
||||
run: |
|
||||
set -euo pipefail # exit on error
|
||||
echo "version=$(cargo metadata --format-version 1 --no-deps | jq '.packages[0].version' -r)" >> $GITHUB_OUTPUT
|
||||
PACKAGE_VERSION=$(cargo metadata --format-version 1 --no-deps | jq '.packages[0].version' -r)
|
||||
echo "PACKAGE_VERSION=${PACKAGE_VERSION}" >> $GITHUB_ENV
|
||||
|
||||
- name: Upload Artifact
|
||||
uses: actions/upload-artifact@v4
|
||||
with:
|
||||
name: "pacman-${{ steps.get_version.outputs.version }}-${{ matrix.target }}"
|
||||
name: "pacman-${{ env.PACKAGE_VERSION }}-${{ matrix.target }}"
|
||||
path: ./target/release/${{ matrix.artifact_name }}
|
||||
retention-days: 7
|
||||
if-no-files-found: error
|
||||
@@ -84,13 +83,10 @@ jobs:
|
||||
permissions:
|
||||
pages: write
|
||||
id-token: write
|
||||
# concurrency group is used to prevent multiple page deployments from being attempted at the same time
|
||||
concurrency:
|
||||
group: ${{ github.workflow }}-wasm
|
||||
|
||||
steps:
|
||||
- name: Checkout
|
||||
uses: actions/checkout@v5
|
||||
uses: actions/checkout@v4
|
||||
|
||||
- name: Setup Emscripten SDK
|
||||
uses: pyodide/setup-emsdk@v15
|
||||
@@ -102,7 +98,7 @@ jobs:
|
||||
uses: dtolnay/rust-toolchain@master
|
||||
with:
|
||||
target: wasm32-unknown-emscripten
|
||||
toolchain: 1.86.0
|
||||
toolchain: 1.86.0 # we are unfortunately pinned to 1.86.0 for some reason, bulk-memory-opt related issues
|
||||
|
||||
- name: Rust Cache
|
||||
uses: Swatinem/rust-cache@v2
|
||||
|
||||
2
.github/workflows/coverage.yaml
vendored
2
.github/workflows/coverage.yaml
vendored
@@ -11,7 +11,7 @@ jobs:
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- name: Checkout code
|
||||
uses: actions/checkout@v5
|
||||
uses: actions/checkout@v4
|
||||
|
||||
- name: Install Rust toolchain
|
||||
uses: dtolnay/rust-toolchain@master
|
||||
|
||||
4
.github/workflows/tests.yaml
vendored
4
.github/workflows/tests.yaml
vendored
@@ -4,7 +4,7 @@ on: ["push", "pull_request"]
|
||||
|
||||
env:
|
||||
CARGO_TERM_COLOR: always
|
||||
RUST_TOOLCHAIN: 1.86.0
|
||||
RUST_TOOLCHAIN: 1.88.0
|
||||
|
||||
jobs:
|
||||
test:
|
||||
@@ -12,7 +12,7 @@ jobs:
|
||||
|
||||
steps:
|
||||
- name: Checkout code
|
||||
uses: actions/checkout@v5
|
||||
uses: actions/checkout@v4
|
||||
|
||||
- name: Install Rust toolchain
|
||||
uses: dtolnay/rust-toolchain@master
|
||||
|
||||
1
.gitignore
vendored
1
.gitignore
vendored
@@ -5,4 +5,3 @@ emsdk/
|
||||
rust-sdl2-emscripten/
|
||||
assets/site/build.css
|
||||
tailwindcss-*
|
||||
lcov.info
|
||||
|
||||
68
Cargo.lock
generated
68
Cargo.lock
generated
@@ -13,9 +13,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "anyhow"
|
||||
version = "1.0.99"
|
||||
version = "1.0.98"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b0674a1ddeecb70197781e945de4b3b8ffb61fa939a5597bcf48503737663100"
|
||||
checksum = "e16d2d3311acee920a9eb8d33b8cbc1787ce4a264e85f964c2404b969bdcd487"
|
||||
|
||||
[[package]]
|
||||
name = "autocfg"
|
||||
@@ -79,9 +79,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "glam"
|
||||
version = "0.30.5"
|
||||
version = "0.30.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f2d1aab06663bdce00d6ca5e5ed586ec8d18033a771906c993a1e3755b368d85"
|
||||
checksum = "50a99dbe56b72736564cfa4b85bf9a33079f16ae8b74983ab06af3b1a3696b11"
|
||||
|
||||
[[package]]
|
||||
name = "hashbrown"
|
||||
@@ -89,12 +89,6 @@ version = "0.15.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "5971ac85611da7067dbfcabef3c70ebb5606018acd9e2a3903a0da507521e0d5"
|
||||
|
||||
[[package]]
|
||||
name = "heck"
|
||||
version = "0.5.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
|
||||
|
||||
[[package]]
|
||||
name = "indexmap"
|
||||
version = "2.10.0"
|
||||
@@ -128,9 +122,9 @@ checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
|
||||
|
||||
[[package]]
|
||||
name = "libc"
|
||||
version = "0.2.175"
|
||||
version = "0.2.174"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "6a82ae493e598baaea5209805c49bbf2ea7de956d50d7da0da1164f9c6d28543"
|
||||
checksum = "1171693293099992e19cddea4e8b849964e9846f4acee11b3948bcc337be8776"
|
||||
|
||||
[[package]]
|
||||
name = "log"
|
||||
@@ -200,9 +194,7 @@ dependencies = [
|
||||
"serde_json",
|
||||
"smallvec",
|
||||
"spin_sleep",
|
||||
"strum",
|
||||
"strum_macros",
|
||||
"thiserror",
|
||||
"thiserror 1.0.69",
|
||||
"tracing",
|
||||
"tracing-error",
|
||||
"tracing-subscriber",
|
||||
@@ -220,7 +212,7 @@ dependencies = [
|
||||
"integer-sqrt",
|
||||
"num-traits",
|
||||
"rustc-hash",
|
||||
"thiserror",
|
||||
"thiserror 2.0.12",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -380,9 +372,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "serde_json"
|
||||
version = "1.0.142"
|
||||
version = "1.0.141"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "030fedb782600dcbd6f02d479bf0d817ac3bb40d644745b769d6a96bc3afc5a7"
|
||||
checksum = "30b9eff21ebe718216c6ec64e1d9ac57087aad11efc64e32002bce4a0d4c03d3"
|
||||
dependencies = [
|
||||
"itoa",
|
||||
"memchr",
|
||||
@@ -414,24 +406,6 @@ dependencies = [
|
||||
"windows-sys",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "strum"
|
||||
version = "0.27.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "af23d6f6c1a224baef9d3f61e287d2761385a5b88fdab4eb4c6f11aeb54c4bcf"
|
||||
|
||||
[[package]]
|
||||
name = "strum_macros"
|
||||
version = "0.27.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "7695ce3845ea4b33927c055a39dc438a45b059f7c1b3d91d38d10355fb8cbca7"
|
||||
dependencies = [
|
||||
"heck",
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "syn"
|
||||
version = "2.0.104"
|
||||
@@ -443,13 +417,33 @@ dependencies = [
|
||||
"unicode-ident",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "thiserror"
|
||||
version = "1.0.69"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
|
||||
dependencies = [
|
||||
"thiserror-impl 1.0.69",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "thiserror"
|
||||
version = "2.0.12"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "567b8a2dae586314f7be2a752ec7474332959c6460e02bde30d702a66d488708"
|
||||
dependencies = [
|
||||
"thiserror-impl",
|
||||
"thiserror-impl 2.0.12",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "thiserror-impl"
|
||||
version = "1.0.69"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
|
||||
10
Cargo.toml
10
Cargo.toml
@@ -15,14 +15,12 @@ spin_sleep = "1.3.2"
|
||||
rand = { version = "0.9.2", default-features = false, features = ["small_rng", "os_rng"] }
|
||||
pathfinding = "4.14"
|
||||
once_cell = "1.21.3"
|
||||
thiserror = "2.0"
|
||||
thiserror = "1.0"
|
||||
anyhow = "1.0"
|
||||
glam = { version = "0.30.5", features = [] }
|
||||
glam = { version = "0.30.4", features = [] }
|
||||
serde = { version = "1.0.219", features = ["derive"] }
|
||||
serde_json = "1.0.142"
|
||||
serde_json = "1.0.141"
|
||||
smallvec = "1.15.1"
|
||||
strum = "0.27.2"
|
||||
strum_macros = "0.27.2"
|
||||
|
||||
[profile.release]
|
||||
lto = true
|
||||
@@ -56,4 +54,4 @@ x86_64-apple-darwin = { triplet = "x64-osx" }
|
||||
aarch64-apple-darwin = { triplet = "arm64-osx" }
|
||||
|
||||
[target.'cfg(target_os = "emscripten")'.dependencies]
|
||||
libc = "0.2.175"
|
||||
libc = "0.2.16"
|
||||
|
||||
@@ -2,14 +2,14 @@
|
||||
|
||||
[![Tests Status][badge-test]][test] [![Build Status][badge-build]][build] [![Code Coverage][badge-coverage]][coverage] [![Online Demo][badge-online-demo]][demo] [![Last Commit][badge-last-commit]][commits]
|
||||
|
||||
[badge-test]: https://github.com/Xevion/Pac-Man/actions/workflows/tests.yaml/badge.svg
|
||||
[badge-test]: https://github.com/Xevion/Pac-Man/actions/workflows/test.yaml/badge.svg
|
||||
[badge-build]: https://github.com/Xevion/Pac-Man/actions/workflows/build.yaml/badge.svg
|
||||
[badge-coverage]: https://coveralls.io/repos/github/Xevion/Pac-Man/badge.svg?branch=master
|
||||
[badge-demo]: https://img.shields.io/github/deployments/Xevion/Pac-Man/github-pages?label=GitHub%20Pages
|
||||
[badge-online-demo]: https://img.shields.io/badge/GitHub%20Pages-Demo-brightgreen
|
||||
[badge-last-commit]: https://img.shields.io/github/last-commit/Xevion/Pac-Man
|
||||
[build]: https://github.com/Xevion/Pac-Man/actions/workflows/build.yaml
|
||||
[test]: https://github.com/Xevion/Pac-Man/actions/workflows/tests.yaml
|
||||
[test]: https://github.com/Xevion/Pac-Man/actions/workflows/test.yaml
|
||||
[coverage]: https://coveralls.io/github/Xevion/Pac-Man?branch=master
|
||||
[demo]: https://xevion.github.io/Pac-Man/
|
||||
[commits]: https://github.com/Xevion/Pac-Man/commits/master
|
||||
@@ -72,8 +72,6 @@ I wanted to hit a log of goals and features, making it a 'perfect' project that
|
||||
|
||||
Since this project is still in progress, I'm only going to cover non-obvious build details. By reading the code, build scripts, and copying the online build workflows, you should be able to replicate the build process.
|
||||
|
||||
- We use rustc 1.86.0 for the build, due to bulk-memory-opt related issues on wasm32-unknown-emscripten.
|
||||
- Technically, we could probably use stable or even nightly on desktop targets, but using different versions for different targets is a pain, mainly because of clippy warnings changing between versions.
|
||||
- Install `cargo-vcpkg` with `cargo install cargo-vcpkg`, then run `cargo vcpkg build` to build the requisite dependencies via vcpkg.
|
||||
- For the WASM build, you need to have the Emscripten SDK cloned; you can do so with `git clone https://github.com/emscripten-core/emsdk.git`
|
||||
- The first time you clone, you'll need to install the appropriate SDK version with `./emsdk install 3.1.43` and then activate it with `./emsdk activate 3.1.43`. On Windows, use `./emsdk/emsdk.ps1` instead.
|
||||
|
||||
80
bacon.toml
80
bacon.toml
@@ -1,80 +0,0 @@
|
||||
# This is a configuration file for the bacon tool
|
||||
#
|
||||
# Complete help on configuration: https://dystroy.org/bacon/config/
|
||||
#
|
||||
# You may check the current default at
|
||||
# https://github.com/Canop/bacon/blob/main/defaults/default-bacon.toml
|
||||
|
||||
default_job = "check"
|
||||
env.CARGO_TERM_COLOR = "always"
|
||||
|
||||
[jobs.check]
|
||||
command = ["cargo", "check"]
|
||||
need_stdout = false
|
||||
|
||||
[jobs.check-all]
|
||||
command = ["cargo", "check", "--all-targets"]
|
||||
need_stdout = false
|
||||
|
||||
# Run clippy on the default target
|
||||
[jobs.clippy]
|
||||
command = ["cargo", "clippy"]
|
||||
need_stdout = false
|
||||
|
||||
# Run clippy on all targets
|
||||
[jobs.clippy-all]
|
||||
command = ["cargo", "clippy", "--all-targets"]
|
||||
need_stdout = false
|
||||
|
||||
[jobs.test]
|
||||
command = [
|
||||
"cargo", "nextest", "run",
|
||||
"--hide-progress-bar", "--failure-output", "final"
|
||||
]
|
||||
need_stdout = true
|
||||
analyzer = "nextest"
|
||||
|
||||
[jobs.coverage]
|
||||
command = [
|
||||
"cargo", "llvm-cov", "--profile", "coverage", "--color", "always", "--no-fail-fast", "nextest", "--no-capture", "--summary-only", "--"
|
||||
]
|
||||
need_stdout = true
|
||||
ignored_lines = [
|
||||
"info:",
|
||||
"\\s+Compiling",
|
||||
"test result: ok",
|
||||
"^\\s*$",
|
||||
"running \\d+ test",
|
||||
"Nextest run ID",
|
||||
"[─]+",
|
||||
"test.+ok",
|
||||
"PASS|START",
|
||||
"Starting \\d+ test"
|
||||
]
|
||||
|
||||
[jobs.doc]
|
||||
command = ["cargo", "doc", "--no-deps"]
|
||||
need_stdout = false
|
||||
|
||||
# If the doc compiles, then it opens in your browser and bacon switches to the previous job
|
||||
[jobs.doc-open]
|
||||
command = ["cargo", "doc", "--no-deps", "--open"]
|
||||
need_stdout = false
|
||||
on_success = "back" # so that we don't open the browser at each change
|
||||
|
||||
[jobs.run]
|
||||
command = [
|
||||
"cargo", "run",
|
||||
]
|
||||
need_stdout = true
|
||||
allow_warnings = true
|
||||
background = false
|
||||
on_change_strategy = "kill_then_restart"
|
||||
# kill = ["pkill", "-TERM", "-P"]'
|
||||
|
||||
[keybindings]
|
||||
c = "job:clippy"
|
||||
alt-c = "job:check"
|
||||
ctrl-alt-c = "job:check-all"
|
||||
shift-c = "job:clippy-all"
|
||||
f = "job:coverage"
|
||||
@@ -1,4 +0,0 @@
|
||||
[toolchain]
|
||||
# we are unfortunately pinned to 1.86.0 for some reason, bulk-memory-opt related issues on wasm32-unknown-emscripten
|
||||
channel = "1.86.0"
|
||||
components = ["rustfmt", "llvm-tools-preview", "clippy"]
|
||||
70
src/app.rs
70
src/app.rs
@@ -1,44 +1,37 @@
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
use anyhow::{anyhow, Result};
|
||||
use glam::Vec2;
|
||||
use sdl2::event::{Event, WindowEvent};
|
||||
use sdl2::keyboard::Keycode;
|
||||
use sdl2::render::{Canvas, ScaleMode, Texture, TextureCreator};
|
||||
use sdl2::ttf::Sdl2TtfContext;
|
||||
use sdl2::video::{Window, WindowContext};
|
||||
use sdl2::{AudioSubsystem, EventPump, Sdl, VideoSubsystem};
|
||||
use sdl2::EventPump;
|
||||
use tracing::{error, event};
|
||||
|
||||
use crate::error::{GameError, GameResult};
|
||||
|
||||
use crate::constants::{CANVAS_SIZE, LOOP_TIME, SCALE};
|
||||
use crate::game::Game;
|
||||
use crate::platform::get_platform;
|
||||
|
||||
pub struct App {
|
||||
pub struct App<'a> {
|
||||
game: Game,
|
||||
canvas: Canvas<Window>,
|
||||
event_pump: &'static mut EventPump,
|
||||
backbuffer: Texture<'static>,
|
||||
event_pump: EventPump,
|
||||
backbuffer: Texture<'a>,
|
||||
paused: bool,
|
||||
last_tick: Instant,
|
||||
cursor_pos: Vec2,
|
||||
}
|
||||
|
||||
impl App {
|
||||
pub fn new() -> GameResult<Self> {
|
||||
let sdl_context: &'static Sdl = Box::leak(Box::new(sdl2::init().map_err(|e| GameError::Sdl(e.to_string()))?));
|
||||
let video_subsystem: &'static VideoSubsystem =
|
||||
Box::leak(Box::new(sdl_context.video().map_err(|e| GameError::Sdl(e.to_string()))?));
|
||||
let _audio_subsystem: &'static AudioSubsystem =
|
||||
Box::leak(Box::new(sdl_context.audio().map_err(|e| GameError::Sdl(e.to_string()))?));
|
||||
let _ttf_context: &'static Sdl2TtfContext =
|
||||
Box::leak(Box::new(sdl2::ttf::init().map_err(|e| GameError::Sdl(e.to_string()))?));
|
||||
let event_pump: &'static mut EventPump =
|
||||
Box::leak(Box::new(sdl_context.event_pump().map_err(|e| GameError::Sdl(e.to_string()))?));
|
||||
|
||||
impl App<'_> {
|
||||
pub fn new() -> Result<Self> {
|
||||
// Initialize platform-specific console
|
||||
get_platform().init_console()?;
|
||||
get_platform().init_console().map_err(|e| anyhow!(e))?;
|
||||
|
||||
let sdl_context = sdl2::init().map_err(|e| anyhow!(e))?;
|
||||
let video_subsystem = sdl_context.video().map_err(|e| anyhow!(e))?;
|
||||
let audio_subsystem = sdl_context.audio().map_err(|e| anyhow!(e))?;
|
||||
let ttf_context = sdl2::ttf::init().map_err(|e| anyhow!(e.to_string()))?;
|
||||
|
||||
let window = video_subsystem
|
||||
.window(
|
||||
@@ -48,29 +41,24 @@ impl App {
|
||||
)
|
||||
.resizable()
|
||||
.position_centered()
|
||||
.build()
|
||||
.map_err(|e| GameError::Sdl(e.to_string()))?;
|
||||
.build()?;
|
||||
|
||||
let mut canvas = window.into_canvas().build().map_err(|e| GameError::Sdl(e.to_string()))?;
|
||||
canvas
|
||||
.set_logical_size(CANVAS_SIZE.x, CANVAS_SIZE.y)
|
||||
.map_err(|e| GameError::Sdl(e.to_string()))?;
|
||||
let mut canvas = window.into_canvas().build()?;
|
||||
canvas.set_logical_size(CANVAS_SIZE.x, CANVAS_SIZE.y)?;
|
||||
|
||||
let texture_creator: &'static TextureCreator<WindowContext> = Box::leak(Box::new(canvas.texture_creator()));
|
||||
let texture_creator_static: &'static TextureCreator<WindowContext> = Box::leak(Box::new(canvas.texture_creator()));
|
||||
|
||||
let mut game = Game::new(texture_creator)?;
|
||||
// game.audio.set_mute(cfg!(debug_assertions));
|
||||
let mut game = Game::new(texture_creator_static, &ttf_context, &audio_subsystem);
|
||||
game.audio.set_mute(cfg!(debug_assertions));
|
||||
|
||||
let mut backbuffer = texture_creator
|
||||
.create_texture_target(None, CANVAS_SIZE.x, CANVAS_SIZE.y)
|
||||
.map_err(|e| GameError::Sdl(e.to_string()))?;
|
||||
let mut backbuffer = texture_creator_static.create_texture_target(None, CANVAS_SIZE.x, CANVAS_SIZE.y)?;
|
||||
backbuffer.set_scale_mode(ScaleMode::Nearest);
|
||||
|
||||
let event_pump = sdl_context.event_pump().map_err(|e| anyhow!(e))?;
|
||||
|
||||
// Initial draw
|
||||
game.draw(&mut canvas, &mut backbuffer)
|
||||
.map_err(|e| GameError::Sdl(e.to_string()))?;
|
||||
game.present_backbuffer(&mut canvas, &backbuffer, glam::Vec2::ZERO)
|
||||
.map_err(|e| GameError::Sdl(e.to_string()))?;
|
||||
game.draw(&mut canvas, &mut backbuffer)?;
|
||||
game.present_backbuffer(&mut canvas, &backbuffer, glam::Vec2::ZERO)?;
|
||||
|
||||
Ok(Self {
|
||||
game,
|
||||
@@ -119,10 +107,10 @@ impl App {
|
||||
keycode: Some(Keycode::Space),
|
||||
..
|
||||
} => {
|
||||
self.game.toggle_debug_mode();
|
||||
self.game.debug_mode = !self.game.debug_mode;
|
||||
}
|
||||
Event::KeyDown { keycode: Some(key), .. } => {
|
||||
self.game.keyboard_event(key);
|
||||
Event::KeyDown { keycode, .. } => {
|
||||
self.game.keyboard_event(keycode.unwrap());
|
||||
}
|
||||
Event::MouseMotion { x, y, .. } => {
|
||||
// Convert window coordinates to logical coordinates
|
||||
@@ -138,13 +126,13 @@ impl App {
|
||||
if !self.paused {
|
||||
self.game.tick(dt);
|
||||
if let Err(e) = self.game.draw(&mut self.canvas, &mut self.backbuffer) {
|
||||
error!("Failed to draw game: {}", e);
|
||||
error!("Failed to draw game: {e}");
|
||||
}
|
||||
if let Err(e) = self
|
||||
.game
|
||||
.present_backbuffer(&mut self.canvas, &self.backbuffer, self.cursor_pos)
|
||||
{
|
||||
error!("Failed to present backbuffer: {}", e);
|
||||
error!("Failed to present backbuffer: {e}");
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
13
src/asset.rs
13
src/asset.rs
@@ -3,6 +3,18 @@
|
||||
//! On desktop, assets are embedded using include_bytes!; on Emscripten, assets are loaded from the filesystem.
|
||||
|
||||
use std::borrow::Cow;
|
||||
use std::io;
|
||||
use thiserror::Error;
|
||||
|
||||
#[derive(Error, Debug)]
|
||||
pub enum AssetError {
|
||||
#[error("IO error: {0}")]
|
||||
Io(#[from] io::Error),
|
||||
#[error("Asset not found: {0}")]
|
||||
NotFound(String),
|
||||
#[error("Invalid asset format: {0}")]
|
||||
InvalidFormat(String),
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
|
||||
pub enum Asset {
|
||||
@@ -32,7 +44,6 @@ impl Asset {
|
||||
|
||||
mod imp {
|
||||
use super::*;
|
||||
use crate::error::AssetError;
|
||||
use crate::platform::get_platform;
|
||||
|
||||
pub fn get_asset_bytes(asset: Asset) -> Result<Cow<'static, [u8]>, AssetError> {
|
||||
|
||||
@@ -1,128 +0,0 @@
|
||||
use smallvec::SmallVec;
|
||||
use std::collections::HashMap;
|
||||
|
||||
use crate::entity::traversal::Position;
|
||||
|
||||
/// Trait for entities that can participate in collision detection.
|
||||
pub trait Collidable {
|
||||
/// Returns the current position of this entity.
|
||||
fn position(&self) -> Position;
|
||||
|
||||
/// Checks if this entity is colliding with another entity.
|
||||
#[allow(dead_code)]
|
||||
fn is_colliding_with(&self, other: &dyn Collidable) -> bool {
|
||||
positions_overlap(&self.position(), &other.position())
|
||||
}
|
||||
}
|
||||
|
||||
/// System for tracking entities by their positions for efficient collision detection.
|
||||
#[derive(Default)]
|
||||
pub struct CollisionSystem {
|
||||
/// Maps node IDs to lists of entity IDs that are at that node
|
||||
node_entities: HashMap<usize, Vec<EntityId>>,
|
||||
/// Maps entity IDs to their current positions
|
||||
entity_positions: HashMap<EntityId, Position>,
|
||||
/// Next available entity ID
|
||||
next_id: EntityId,
|
||||
}
|
||||
|
||||
/// Unique identifier for an entity in the collision system
|
||||
pub type EntityId = u32;
|
||||
|
||||
impl CollisionSystem {
|
||||
/// Registers an entity with the collision system and returns its ID
|
||||
pub fn register_entity(&mut self, position: Position) -> EntityId {
|
||||
let id = self.next_id;
|
||||
self.next_id += 1;
|
||||
|
||||
self.entity_positions.insert(id, position);
|
||||
self.update_node_entities(id, position);
|
||||
|
||||
id
|
||||
}
|
||||
|
||||
/// Updates an entity's position
|
||||
pub fn update_position(&mut self, entity_id: EntityId, new_position: Position) {
|
||||
if let Some(old_position) = self.entity_positions.get(&entity_id) {
|
||||
// Remove from old nodes
|
||||
self.remove_from_nodes(entity_id, *old_position);
|
||||
}
|
||||
|
||||
// Update position and add to new nodes
|
||||
self.entity_positions.insert(entity_id, new_position);
|
||||
self.update_node_entities(entity_id, new_position);
|
||||
}
|
||||
|
||||
/// Removes an entity from the collision system
|
||||
#[allow(dead_code)]
|
||||
pub fn remove_entity(&mut self, entity_id: EntityId) {
|
||||
if let Some(position) = self.entity_positions.remove(&entity_id) {
|
||||
self.remove_from_nodes(entity_id, position);
|
||||
}
|
||||
}
|
||||
|
||||
/// Gets all entity IDs at a specific node
|
||||
pub fn entities_at_node(&self, node: usize) -> &[EntityId] {
|
||||
self.node_entities.get(&node).map(|v| v.as_slice()).unwrap_or(&[])
|
||||
}
|
||||
|
||||
/// Gets all entity IDs that could collide with an entity at the given position
|
||||
pub fn potential_collisions(&self, position: &Position) -> Vec<EntityId> {
|
||||
let mut collisions = Vec::new();
|
||||
let nodes = get_nodes(position);
|
||||
|
||||
for node in nodes {
|
||||
collisions.extend(self.entities_at_node(node));
|
||||
}
|
||||
|
||||
// Remove duplicates
|
||||
collisions.sort_unstable();
|
||||
collisions.dedup();
|
||||
collisions
|
||||
}
|
||||
|
||||
/// Updates the node_entities map when an entity's position changes
|
||||
fn update_node_entities(&mut self, entity_id: EntityId, position: Position) {
|
||||
let nodes = get_nodes(&position);
|
||||
for node in nodes {
|
||||
self.node_entities.entry(node).or_default().push(entity_id);
|
||||
}
|
||||
}
|
||||
|
||||
/// Removes an entity from all nodes it was previously at
|
||||
fn remove_from_nodes(&mut self, entity_id: EntityId, position: Position) {
|
||||
let nodes = get_nodes(&position);
|
||||
for node in nodes {
|
||||
if let Some(entities) = self.node_entities.get_mut(&node) {
|
||||
entities.retain(|&id| id != entity_id);
|
||||
if entities.is_empty() {
|
||||
self.node_entities.remove(&node);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Checks if two positions overlap (entities are at the same location).
|
||||
fn positions_overlap(a: &Position, b: &Position) -> bool {
|
||||
let a_nodes = get_nodes(a);
|
||||
let b_nodes = get_nodes(b);
|
||||
|
||||
// Check if any nodes overlap
|
||||
a_nodes.iter().any(|a_node| b_nodes.contains(a_node))
|
||||
|
||||
// TODO: More complex overlap detection, the above is a simple check, but it could become an early filter for more precise calculations later
|
||||
}
|
||||
|
||||
/// Gets all nodes that an entity is currently at or between.
|
||||
fn get_nodes(pos: &Position) -> SmallVec<[usize; 2]> {
|
||||
let mut nodes = SmallVec::new();
|
||||
match pos {
|
||||
Position::AtNode(node) => nodes.push(*node),
|
||||
Position::BetweenNodes { from, to, .. } => {
|
||||
nodes.push(*from);
|
||||
nodes.push(*to);
|
||||
}
|
||||
}
|
||||
nodes
|
||||
}
|
||||
@@ -4,23 +4,19 @@
|
||||
//! animation, and rendering. Ghosts move through the game graph using
|
||||
//! a traverser and display directional animated textures.
|
||||
|
||||
use pathfinding::prelude::dijkstra;
|
||||
use glam::Vec2;
|
||||
use rand::prelude::*;
|
||||
use smallvec::SmallVec;
|
||||
use tracing::error;
|
||||
use tracing::debug;
|
||||
|
||||
use crate::entity::{
|
||||
collision::Collidable,
|
||||
direction::Direction,
|
||||
graph::{Edge, EdgePermissions, Graph, NodeId},
|
||||
r#trait::Entity,
|
||||
traversal::Traverser,
|
||||
};
|
||||
use crate::constants::BOARD_PIXEL_OFFSET;
|
||||
use crate::entity::direction::Direction;
|
||||
use crate::entity::graph::{Edge, EdgePermissions, Graph, NodeId, Position, Traverser};
|
||||
use crate::helpers::centered_with_size;
|
||||
use crate::texture::animated::AnimatedTexture;
|
||||
use crate::texture::directional::DirectionalAnimatedTexture;
|
||||
use crate::texture::sprite::SpriteAtlas;
|
||||
|
||||
use crate::error::{EntityError, GameError, GameResult, TextureError};
|
||||
use sdl2::render::{Canvas, RenderTarget};
|
||||
|
||||
/// Determines if a ghost can traverse a given edge.
|
||||
///
|
||||
@@ -76,50 +72,12 @@ pub struct Ghost {
|
||||
speed: f32,
|
||||
}
|
||||
|
||||
impl Entity for Ghost {
|
||||
fn traverser(&self) -> &Traverser {
|
||||
&self.traverser
|
||||
}
|
||||
|
||||
fn traverser_mut(&mut self) -> &mut Traverser {
|
||||
&mut self.traverser
|
||||
}
|
||||
|
||||
fn texture(&self) -> &DirectionalAnimatedTexture {
|
||||
&self.texture
|
||||
}
|
||||
|
||||
fn texture_mut(&mut self) -> &mut DirectionalAnimatedTexture {
|
||||
&mut self.texture
|
||||
}
|
||||
|
||||
fn speed(&self) -> f32 {
|
||||
self.speed
|
||||
}
|
||||
|
||||
fn can_traverse(&self, edge: Edge) -> bool {
|
||||
can_ghost_traverse(edge)
|
||||
}
|
||||
|
||||
fn tick(&mut self, dt: f32, graph: &Graph) {
|
||||
// Choose random direction when at a node
|
||||
if self.traverser.position.is_at_node() {
|
||||
self.choose_random_direction(graph);
|
||||
}
|
||||
|
||||
if let Err(e) = self.traverser.advance(graph, dt * 60.0 * self.speed, &can_ghost_traverse) {
|
||||
error!("Ghost movement error: {}", e);
|
||||
}
|
||||
self.texture.tick(dt);
|
||||
}
|
||||
}
|
||||
|
||||
impl Ghost {
|
||||
/// Creates a new ghost instance at the specified starting node.
|
||||
///
|
||||
/// Sets up animated textures for all four directions with moving and stopped states.
|
||||
/// The moving animation cycles through two sprite variants.
|
||||
pub fn new(graph: &Graph, start_node: NodeId, ghost_type: GhostType, atlas: &SpriteAtlas) -> GameResult<Self> {
|
||||
pub fn new(graph: &Graph, start_node: NodeId, ghost_type: GhostType, atlas: &SpriteAtlas) -> Self {
|
||||
let mut textures = [None, None, None, None];
|
||||
let mut stopped_textures = [None, None, None, None];
|
||||
|
||||
@@ -131,49 +89,41 @@ impl Ghost {
|
||||
Direction::Right => "right",
|
||||
};
|
||||
let moving_tiles = vec![
|
||||
SpriteAtlas::get_tile(atlas, &format!("ghost/{}/{}_{}.png", ghost_type.as_str(), moving_prefix, "a"))
|
||||
.ok_or_else(|| {
|
||||
GameError::Texture(TextureError::AtlasTileNotFound(format!(
|
||||
"ghost/{}/{}_{}.png",
|
||||
ghost_type.as_str(),
|
||||
moving_prefix,
|
||||
"a"
|
||||
)))
|
||||
})?,
|
||||
SpriteAtlas::get_tile(atlas, &format!("ghost/{}/{}_{}.png", ghost_type.as_str(), moving_prefix, "b"))
|
||||
.ok_or_else(|| {
|
||||
GameError::Texture(TextureError::AtlasTileNotFound(format!(
|
||||
"ghost/{}/{}_{}.png",
|
||||
ghost_type.as_str(),
|
||||
moving_prefix,
|
||||
"b"
|
||||
)))
|
||||
})?,
|
||||
SpriteAtlas::get_tile(atlas, &format!("ghost/{}/{}_{}.png", ghost_type.as_str(), moving_prefix, "a")).unwrap(),
|
||||
SpriteAtlas::get_tile(atlas, &format!("ghost/{}/{}_{}.png", ghost_type.as_str(), moving_prefix, "b")).unwrap(),
|
||||
];
|
||||
|
||||
let stopped_tiles =
|
||||
vec![
|
||||
SpriteAtlas::get_tile(atlas, &format!("ghost/{}/{}_{}.png", ghost_type.as_str(), moving_prefix, "a"))
|
||||
.ok_or_else(|| {
|
||||
GameError::Texture(TextureError::AtlasTileNotFound(format!(
|
||||
"ghost/{}/{}_{}.png",
|
||||
ghost_type.as_str(),
|
||||
moving_prefix,
|
||||
"a"
|
||||
)))
|
||||
})?,
|
||||
.unwrap(),
|
||||
];
|
||||
|
||||
textures[direction.as_usize()] = Some(AnimatedTexture::new(moving_tiles, 0.2)?);
|
||||
stopped_textures[direction.as_usize()] = Some(AnimatedTexture::new(stopped_tiles, 0.1)?);
|
||||
textures[direction.as_usize()] = Some(AnimatedTexture::new(moving_tiles, 0.2).expect("Invalid frame duration"));
|
||||
stopped_textures[direction.as_usize()] =
|
||||
Some(AnimatedTexture::new(stopped_tiles, 0.1).expect("Invalid frame duration"));
|
||||
}
|
||||
|
||||
Ok(Self {
|
||||
Self {
|
||||
traverser: Traverser::new(graph, start_node, Direction::Left, &can_ghost_traverse),
|
||||
ghost_type,
|
||||
texture: DirectionalAnimatedTexture::new(textures, stopped_textures),
|
||||
speed: ghost_type.base_speed(),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// Updates the ghost's position and animation state.
|
||||
///
|
||||
/// Advances movement through the graph, updates texture animation,
|
||||
/// and chooses random directions at intersections.
|
||||
pub fn tick(&mut self, dt: f32, graph: &Graph) {
|
||||
// Choose random direction when at a node
|
||||
if self.traverser.position.is_at_node() {
|
||||
self.choose_random_direction(graph);
|
||||
}
|
||||
|
||||
self.traverser.advance(graph, dt * 60.0 * self.speed, &can_ghost_traverse);
|
||||
self.texture.tick(dt);
|
||||
}
|
||||
|
||||
/// Chooses a random available direction at the current intersection.
|
||||
@@ -190,6 +140,15 @@ impl Ghost {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
debug!(
|
||||
"Ghost {} at node {}: available directions: {:?}, current direction: {:?}",
|
||||
self.ghost_type.as_str(),
|
||||
current_node,
|
||||
available_directions,
|
||||
self.traverser.direction
|
||||
);
|
||||
|
||||
// Choose a random direction (avoid reversing unless necessary)
|
||||
if !available_directions.is_empty() {
|
||||
let mut rng = SmallRng::from_os_rng();
|
||||
@@ -201,54 +160,57 @@ impl Ghost {
|
||||
.filter(|&&dir| dir != opposite || available_directions.len() <= 2)
|
||||
.collect();
|
||||
|
||||
if let Some(&random_direction) = filtered_directions.choose(&mut rng) {
|
||||
self.traverser.set_next_direction(*random_direction);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Calculates the shortest path from the ghost's current position to a target node using Dijkstra's algorithm.
|
||||
///
|
||||
/// Returns a vector of NodeIds representing the path, or an error if pathfinding fails.
|
||||
/// The path includes the current node and the target node.
|
||||
pub fn calculate_path_to_target(&self, graph: &Graph, target: NodeId) -> GameResult<Vec<NodeId>> {
|
||||
let start_node = self.traverser.position.from_node_id();
|
||||
|
||||
// Use Dijkstra's algorithm to find the shortest path
|
||||
let result = dijkstra(
|
||||
&start_node,
|
||||
|&node_id| {
|
||||
// Get all edges from the current node
|
||||
graph.adjacency_list[node_id]
|
||||
.edges()
|
||||
.filter(|edge| can_ghost_traverse(*edge))
|
||||
.map(|edge| (edge.target, (edge.distance * 100.0) as u32))
|
||||
.collect::<Vec<_>>()
|
||||
},
|
||||
|&node_id| node_id == target,
|
||||
debug!(
|
||||
"Ghost {}: filtered directions: {:?}, opposite: {:?}",
|
||||
self.ghost_type.as_str(),
|
||||
filtered_directions,
|
||||
opposite
|
||||
);
|
||||
|
||||
result.map(|(path, _cost)| path).ok_or_else(|| {
|
||||
GameError::Entity(EntityError::PathfindingFailed(format!(
|
||||
"No path found from node {} to target {}",
|
||||
start_node, target
|
||||
)))
|
||||
})
|
||||
}
|
||||
|
||||
/// Returns the ghost's color for debug rendering.
|
||||
pub fn debug_color(&self) -> sdl2::pixels::Color {
|
||||
match self.ghost_type {
|
||||
GhostType::Blinky => sdl2::pixels::Color::RGB(255, 0, 0), // Red
|
||||
GhostType::Pinky => sdl2::pixels::Color::RGB(255, 182, 255), // Pink
|
||||
GhostType::Inky => sdl2::pixels::Color::RGB(0, 255, 255), // Cyan
|
||||
GhostType::Clyde => sdl2::pixels::Color::RGB(255, 182, 85), // Orange
|
||||
if let Some(&random_direction) = filtered_directions.choose(&mut rng) {
|
||||
self.traverser.set_next_direction(*random_direction);
|
||||
debug!("Ghost {} chose direction: {:?}", self.ghost_type.as_str(), random_direction);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Collidable for Ghost {
|
||||
fn position(&self) -> crate::entity::traversal::Position {
|
||||
self.traverser.position
|
||||
/// Calculates the current pixel position in the game world.
|
||||
///
|
||||
/// Converts the graph position to screen coordinates, accounting for
|
||||
/// the board offset and centering the sprite.
|
||||
fn get_pixel_pos(&self, graph: &Graph) -> Vec2 {
|
||||
let pos = match self.traverser.position {
|
||||
Position::AtNode(node_id) => graph.get_node(node_id).unwrap().position,
|
||||
Position::BetweenNodes { from, to, traversed } => {
|
||||
let from_pos = graph.get_node(from).unwrap().position;
|
||||
let to_pos = graph.get_node(to).unwrap().position;
|
||||
let edge = graph.find_edge(from, to).unwrap();
|
||||
from_pos + (to_pos - from_pos) * (traversed / edge.distance)
|
||||
}
|
||||
};
|
||||
|
||||
Vec2::new(pos.x + BOARD_PIXEL_OFFSET.x as f32, pos.y + BOARD_PIXEL_OFFSET.y as f32)
|
||||
}
|
||||
|
||||
/// Renders the ghost at its current position.
|
||||
///
|
||||
/// Draws the appropriate directional sprite based on the ghost's
|
||||
/// current movement state and direction.
|
||||
pub fn render<T: RenderTarget>(&self, canvas: &mut Canvas<T>, atlas: &mut SpriteAtlas, graph: &Graph) {
|
||||
let pixel_pos = self.get_pixel_pos(graph);
|
||||
let dest = centered_with_size(
|
||||
glam::IVec2::new(pixel_pos.x as i32, pixel_pos.y as i32),
|
||||
glam::UVec2::new(16, 16),
|
||||
);
|
||||
|
||||
if self.traverser.position.is_stopped() {
|
||||
self.texture
|
||||
.render_stopped(canvas, atlas, dest, self.traverser.direction)
|
||||
.expect("Failed to render ghost");
|
||||
} else {
|
||||
self.texture
|
||||
.render(canvas, atlas, dest, self.traverser.direction)
|
||||
.expect("Failed to render ghost");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -111,7 +111,7 @@ impl Graph {
|
||||
}
|
||||
|
||||
/// Connects a new node to the graph and adds an edge between the existing node and the new node.
|
||||
pub fn add_connected(&mut self, from: NodeId, direction: Direction, new_node: Node) -> Result<NodeId, &'static str> {
|
||||
pub fn connect_node(&mut self, from: NodeId, direction: Direction, new_node: Node) -> Result<NodeId, &'static str> {
|
||||
let to = self.add_node(new_node);
|
||||
self.connect(from, to, false, None, direction)?;
|
||||
Ok(to)
|
||||
@@ -236,3 +236,208 @@ impl Default for Graph {
|
||||
Self::new()
|
||||
}
|
||||
}
|
||||
|
||||
// --- Traversal State and Logic ---
|
||||
|
||||
/// Represents the current position of an entity traversing the graph.
|
||||
///
|
||||
/// This enum allows for precise tracking of whether an entity is exactly at a node
|
||||
/// or moving along an edge between two nodes.
|
||||
#[derive(Debug, PartialEq, Clone, Copy)]
|
||||
pub enum Position {
|
||||
/// The traverser is located exactly at a node.
|
||||
AtNode(NodeId),
|
||||
/// The traverser is on an edge between two nodes.
|
||||
BetweenNodes {
|
||||
from: NodeId,
|
||||
to: NodeId,
|
||||
/// The floating-point distance traversed along the edge from the `from` node.
|
||||
traversed: f32,
|
||||
},
|
||||
}
|
||||
|
||||
#[allow(dead_code)]
|
||||
impl Position {
|
||||
/// Returns `true` if the position is exactly at a node.
|
||||
pub fn is_at_node(&self) -> bool {
|
||||
matches!(self, Position::AtNode(_))
|
||||
}
|
||||
|
||||
/// Returns the `NodeId` of the current or most recently departed node.
|
||||
#[allow(clippy::wrong_self_convention)]
|
||||
pub fn from_node_id(&self) -> NodeId {
|
||||
match self {
|
||||
Position::AtNode(id) => *id,
|
||||
Position::BetweenNodes { from, .. } => *from,
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns the `NodeId` of the destination node, if currently on an edge.
|
||||
#[allow(clippy::wrong_self_convention)]
|
||||
pub fn to_node_id(&self) -> Option<NodeId> {
|
||||
match self {
|
||||
Position::AtNode(_) => None,
|
||||
Position::BetweenNodes { to, .. } => Some(*to),
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns `true` if the traverser is stopped at a node.
|
||||
pub fn is_stopped(&self) -> bool {
|
||||
matches!(self, Position::AtNode(_))
|
||||
}
|
||||
}
|
||||
|
||||
/// Manages an entity's movement through the graph.
|
||||
///
|
||||
/// A `Traverser` encapsulates the state of an entity's position and direction,
|
||||
/// providing a way to advance along the graph's paths based on a given distance.
|
||||
/// It also handles direction changes, buffering the next intended direction.
|
||||
pub struct Traverser {
|
||||
/// The current position of the traverser in the graph.
|
||||
pub position: Position,
|
||||
/// The current direction of movement.
|
||||
pub direction: Direction,
|
||||
/// Buffered direction change with remaining frame count for timing.
|
||||
///
|
||||
/// The `u8` value represents the number of frames remaining before
|
||||
/// the buffered direction expires. This allows for responsive controls
|
||||
/// by storing direction changes for a limited time.
|
||||
pub next_direction: Option<(Direction, u8)>,
|
||||
}
|
||||
|
||||
impl Traverser {
|
||||
/// Creates a new traverser starting at the given node ID.
|
||||
///
|
||||
/// The traverser will immediately attempt to start moving in the initial direction.
|
||||
pub fn new<F>(graph: &Graph, start_node: NodeId, initial_direction: Direction, can_traverse: &F) -> Self
|
||||
where
|
||||
F: Fn(Edge) -> bool,
|
||||
{
|
||||
let mut traverser = Traverser {
|
||||
position: Position::AtNode(start_node),
|
||||
direction: initial_direction,
|
||||
next_direction: Some((initial_direction, 1)),
|
||||
};
|
||||
|
||||
// This will kickstart the traverser into motion
|
||||
traverser.advance(graph, 0.0, can_traverse);
|
||||
|
||||
traverser
|
||||
}
|
||||
|
||||
/// Sets the next direction for the traverser to take.
|
||||
///
|
||||
/// The direction is buffered and will be applied at the next opportunity,
|
||||
/// typically when the traverser reaches a new node. This allows for responsive
|
||||
/// controls, as the new direction is stored for a limited time.
|
||||
pub fn set_next_direction(&mut self, new_direction: Direction) {
|
||||
if self.direction != new_direction {
|
||||
self.next_direction = Some((new_direction, 30));
|
||||
}
|
||||
}
|
||||
|
||||
/// Advances the traverser along the graph by a specified distance.
|
||||
///
|
||||
/// This method updates the traverser's position based on its current state
|
||||
/// and the distance to travel.
|
||||
///
|
||||
/// - If at a node, it checks for a buffered direction to start moving.
|
||||
/// - If between nodes, it moves along the current edge.
|
||||
/// - If it reaches a node, it attempts to transition to a new edge based on
|
||||
/// the buffered direction or by continuing straight.
|
||||
/// - If no valid move is possible, it stops at the node.
|
||||
pub fn advance<F>(&mut self, graph: &Graph, distance: f32, can_traverse: &F)
|
||||
where
|
||||
F: Fn(Edge) -> bool,
|
||||
{
|
||||
// Decrement the remaining frames for the next direction
|
||||
if let Some((direction, remaining)) = self.next_direction {
|
||||
if remaining > 0 {
|
||||
self.next_direction = Some((direction, remaining - 1));
|
||||
} else {
|
||||
self.next_direction = None;
|
||||
}
|
||||
}
|
||||
|
||||
match self.position {
|
||||
Position::AtNode(node_id) => {
|
||||
// We're not moving, but a buffered direction is available.
|
||||
if let Some((next_direction, _)) = self.next_direction {
|
||||
if let Some(edge) = graph.find_edge_in_direction(node_id, next_direction) {
|
||||
if can_traverse(edge) {
|
||||
// Start moving in that direction
|
||||
self.position = Position::BetweenNodes {
|
||||
from: node_id,
|
||||
to: edge.target,
|
||||
traversed: distance.max(0.0),
|
||||
};
|
||||
self.direction = next_direction;
|
||||
}
|
||||
}
|
||||
|
||||
self.next_direction = None; // Consume the buffered direction regardless of whether we started moving with it
|
||||
}
|
||||
}
|
||||
Position::BetweenNodes { from, to, traversed } => {
|
||||
// There is no point in any of the next logic if we don't travel at all
|
||||
if distance <= 0.0 {
|
||||
return;
|
||||
}
|
||||
|
||||
let edge = graph
|
||||
.find_edge(from, to)
|
||||
.expect("Inconsistent state: Traverser is on a non-existent edge.");
|
||||
|
||||
let new_traversed = traversed + distance;
|
||||
|
||||
if new_traversed < edge.distance {
|
||||
// Still on the same edge, just update the distance.
|
||||
self.position = Position::BetweenNodes {
|
||||
from,
|
||||
to,
|
||||
traversed: new_traversed,
|
||||
};
|
||||
} else {
|
||||
let overflow = new_traversed - edge.distance;
|
||||
let mut moved = false;
|
||||
|
||||
// If we buffered a direction, try to find an edge in that direction
|
||||
if let Some((next_dir, _)) = self.next_direction {
|
||||
if let Some(edge) = graph.find_edge_in_direction(to, next_dir) {
|
||||
if can_traverse(edge) {
|
||||
self.position = Position::BetweenNodes {
|
||||
from: to,
|
||||
to: edge.target,
|
||||
traversed: overflow,
|
||||
};
|
||||
|
||||
self.direction = next_dir; // Remember our new direction
|
||||
self.next_direction = None; // Consume the buffered direction
|
||||
moved = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// If we didn't move, try to continue in the current direction
|
||||
if !moved {
|
||||
if let Some(edge) = graph.find_edge_in_direction(to, self.direction) {
|
||||
if can_traverse(edge) {
|
||||
self.position = Position::BetweenNodes {
|
||||
from: to,
|
||||
to: edge.target,
|
||||
traversed: overflow,
|
||||
};
|
||||
} else {
|
||||
self.position = Position::AtNode(to);
|
||||
self.next_direction = None;
|
||||
}
|
||||
} else {
|
||||
self.position = Position::AtNode(to);
|
||||
self.next_direction = None;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,117 +0,0 @@
|
||||
use crate::{
|
||||
constants,
|
||||
entity::{collision::Collidable, graph::Graph},
|
||||
error::{EntityError, GameResult},
|
||||
texture::sprite::{Sprite, SpriteAtlas},
|
||||
};
|
||||
use sdl2::render::{Canvas, RenderTarget};
|
||||
use strum_macros::{EnumCount, EnumIter};
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub enum ItemType {
|
||||
Pellet,
|
||||
Energizer,
|
||||
#[allow(dead_code)]
|
||||
Fruit {
|
||||
kind: FruitKind,
|
||||
},
|
||||
}
|
||||
|
||||
impl ItemType {
|
||||
pub fn get_score(self) -> u32 {
|
||||
match self {
|
||||
ItemType::Pellet => 10,
|
||||
ItemType::Energizer => 50,
|
||||
ItemType::Fruit { kind } => kind.get_score(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, EnumIter, EnumCount)]
|
||||
#[allow(dead_code)]
|
||||
pub enum FruitKind {
|
||||
Apple,
|
||||
Strawberry,
|
||||
Orange,
|
||||
Melon,
|
||||
Bell,
|
||||
Key,
|
||||
Galaxian,
|
||||
}
|
||||
|
||||
impl FruitKind {
|
||||
#[allow(dead_code)]
|
||||
pub fn index(self) -> u8 {
|
||||
match self {
|
||||
FruitKind::Apple => 0,
|
||||
FruitKind::Strawberry => 1,
|
||||
FruitKind::Orange => 2,
|
||||
FruitKind::Melon => 3,
|
||||
FruitKind::Bell => 4,
|
||||
FruitKind::Key => 5,
|
||||
FruitKind::Galaxian => 6,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn get_score(self) -> u32 {
|
||||
match self {
|
||||
FruitKind::Apple => 100,
|
||||
FruitKind::Strawberry => 300,
|
||||
FruitKind::Orange => 500,
|
||||
FruitKind::Melon => 700,
|
||||
FruitKind::Bell => 1000,
|
||||
FruitKind::Key => 2000,
|
||||
FruitKind::Galaxian => 3000,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub struct Item {
|
||||
pub node_index: usize,
|
||||
pub item_type: ItemType,
|
||||
pub sprite: Sprite,
|
||||
pub collected: bool,
|
||||
}
|
||||
|
||||
impl Item {
|
||||
pub fn new(node_index: usize, item_type: ItemType, sprite: Sprite) -> Self {
|
||||
Self {
|
||||
node_index,
|
||||
item_type,
|
||||
sprite,
|
||||
collected: false,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn is_collected(&self) -> bool {
|
||||
self.collected
|
||||
}
|
||||
|
||||
pub fn collect(&mut self) {
|
||||
self.collected = true;
|
||||
}
|
||||
|
||||
pub fn get_score(&self) -> u32 {
|
||||
self.item_type.get_score()
|
||||
}
|
||||
|
||||
pub fn render<T: RenderTarget>(&self, canvas: &mut Canvas<T>, atlas: &mut SpriteAtlas, graph: &Graph) -> GameResult<()> {
|
||||
if self.collected {
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
let node = graph
|
||||
.get_node(self.node_index)
|
||||
.ok_or(EntityError::NodeNotFound(self.node_index))?;
|
||||
let position = node.position + constants::BOARD_PIXEL_OFFSET.as_vec2();
|
||||
|
||||
self.sprite.render(canvas, atlas, position)?;
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl Collidable for Item {
|
||||
fn position(&self) -> crate::entity::traversal::Position {
|
||||
crate::entity::traversal::Position::AtNode(self.node_index)
|
||||
}
|
||||
}
|
||||
@@ -1,8 +1,4 @@
|
||||
pub mod collision;
|
||||
pub mod direction;
|
||||
pub mod ghost;
|
||||
pub mod graph;
|
||||
pub mod item;
|
||||
pub mod pacman;
|
||||
pub mod r#trait;
|
||||
pub mod traversal;
|
||||
|
||||
@@ -4,20 +4,17 @@
|
||||
//! animation, and rendering. Pac-Man moves through the game graph using
|
||||
//! a traverser and displays directional animated textures.
|
||||
|
||||
use crate::entity::{
|
||||
collision::Collidable,
|
||||
direction::Direction,
|
||||
graph::{Edge, EdgePermissions, Graph, NodeId},
|
||||
r#trait::Entity,
|
||||
traversal::Traverser,
|
||||
};
|
||||
use glam::{UVec2, Vec2};
|
||||
|
||||
use crate::constants::BOARD_PIXEL_OFFSET;
|
||||
use crate::entity::direction::Direction;
|
||||
use crate::entity::graph::{Edge, EdgePermissions, Graph, NodeId, Position, Traverser};
|
||||
use crate::helpers::centered_with_size;
|
||||
use crate::texture::animated::AnimatedTexture;
|
||||
use crate::texture::directional::DirectionalAnimatedTexture;
|
||||
use crate::texture::sprite::SpriteAtlas;
|
||||
use sdl2::keyboard::Keycode;
|
||||
use tracing::error;
|
||||
|
||||
use crate::error::{GameError, GameResult, TextureError};
|
||||
use sdl2::render::{Canvas, RenderTarget};
|
||||
|
||||
/// Determines if Pac-Man can traverse a given edge.
|
||||
///
|
||||
@@ -37,45 +34,12 @@ pub struct Pacman {
|
||||
texture: DirectionalAnimatedTexture,
|
||||
}
|
||||
|
||||
impl Entity for Pacman {
|
||||
fn traverser(&self) -> &Traverser {
|
||||
&self.traverser
|
||||
}
|
||||
|
||||
fn traverser_mut(&mut self) -> &mut Traverser {
|
||||
&mut self.traverser
|
||||
}
|
||||
|
||||
fn texture(&self) -> &DirectionalAnimatedTexture {
|
||||
&self.texture
|
||||
}
|
||||
|
||||
fn texture_mut(&mut self) -> &mut DirectionalAnimatedTexture {
|
||||
&mut self.texture
|
||||
}
|
||||
|
||||
fn speed(&self) -> f32 {
|
||||
1.125
|
||||
}
|
||||
|
||||
fn can_traverse(&self, edge: Edge) -> bool {
|
||||
can_pacman_traverse(edge)
|
||||
}
|
||||
|
||||
fn tick(&mut self, dt: f32, graph: &Graph) {
|
||||
if let Err(e) = self.traverser.advance(graph, dt * 60.0 * 1.125, &can_pacman_traverse) {
|
||||
error!("Pac-Man movement error: {}", e);
|
||||
}
|
||||
self.texture.tick(dt);
|
||||
}
|
||||
}
|
||||
|
||||
impl Pacman {
|
||||
/// Creates a new Pac-Man instance at the specified starting node.
|
||||
///
|
||||
/// Sets up animated textures for all four directions with moving and stopped states.
|
||||
/// The moving animation cycles through open mouth, closed mouth, and full sprites.
|
||||
pub fn new(graph: &Graph, start_node: NodeId, atlas: &SpriteAtlas) -> GameResult<Self> {
|
||||
pub fn new(graph: &Graph, start_node: NodeId, atlas: &SpriteAtlas) -> Self {
|
||||
let mut textures = [None, None, None, None];
|
||||
let mut stopped_textures = [None, None, None, None];
|
||||
|
||||
@@ -87,25 +51,31 @@ impl Pacman {
|
||||
Direction::Right => "pacman/right",
|
||||
};
|
||||
let moving_tiles = vec![
|
||||
SpriteAtlas::get_tile(atlas, &format!("{moving_prefix}_a.png"))
|
||||
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound(format!("{moving_prefix}_a.png"))))?,
|
||||
SpriteAtlas::get_tile(atlas, &format!("{moving_prefix}_b.png"))
|
||||
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound(format!("{moving_prefix}_b.png"))))?,
|
||||
SpriteAtlas::get_tile(atlas, "pacman/full.png")
|
||||
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/full.png".to_string())))?,
|
||||
SpriteAtlas::get_tile(atlas, &format!("{moving_prefix}_a.png")).unwrap(),
|
||||
SpriteAtlas::get_tile(atlas, &format!("{moving_prefix}_b.png")).unwrap(),
|
||||
SpriteAtlas::get_tile(atlas, "pacman/full.png").unwrap(),
|
||||
];
|
||||
|
||||
let stopped_tiles = vec![SpriteAtlas::get_tile(atlas, &format!("{moving_prefix}_b.png"))
|
||||
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound(format!("{moving_prefix}_b.png"))))?];
|
||||
let stopped_tiles = vec![SpriteAtlas::get_tile(atlas, &format!("{moving_prefix}_b.png")).unwrap()];
|
||||
|
||||
textures[direction.as_usize()] = Some(AnimatedTexture::new(moving_tiles, 0.08)?);
|
||||
stopped_textures[direction.as_usize()] = Some(AnimatedTexture::new(stopped_tiles, 0.1)?);
|
||||
textures[direction.as_usize()] = Some(AnimatedTexture::new(moving_tiles, 0.08).expect("Invalid frame duration"));
|
||||
stopped_textures[direction.as_usize()] =
|
||||
Some(AnimatedTexture::new(stopped_tiles, 0.1).expect("Invalid frame duration"));
|
||||
}
|
||||
|
||||
Ok(Self {
|
||||
Self {
|
||||
traverser: Traverser::new(graph, start_node, Direction::Left, &can_pacman_traverse),
|
||||
texture: DirectionalAnimatedTexture::new(textures, stopped_textures),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// Updates Pac-Man's position and animation state.
|
||||
///
|
||||
/// Advances movement through the graph and updates texture animation.
|
||||
/// Movement speed is scaled by 60 FPS and a 1.125 multiplier.
|
||||
pub fn tick(&mut self, dt: f32, graph: &Graph) {
|
||||
self.traverser.advance(graph, dt * 60.0 * 1.125, &can_pacman_traverse);
|
||||
self.texture.tick(dt);
|
||||
}
|
||||
|
||||
/// Handles keyboard input to change Pac-Man's direction.
|
||||
@@ -125,10 +95,36 @@ impl Pacman {
|
||||
self.traverser.set_next_direction(direction);
|
||||
}
|
||||
}
|
||||
|
||||
/// Calculates the current pixel position in the game world.
|
||||
///
|
||||
/// Interpolates between nodes when moving between them.
|
||||
fn get_pixel_pos(&self, graph: &Graph) -> Vec2 {
|
||||
match self.traverser.position {
|
||||
Position::AtNode(node_id) => graph.get_node(node_id).unwrap().position,
|
||||
Position::BetweenNodes { from, to, traversed } => {
|
||||
let from_pos = graph.get_node(from).unwrap().position;
|
||||
let to_pos = graph.get_node(to).unwrap().position;
|
||||
from_pos.lerp(to_pos, traversed / from_pos.distance(to_pos))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Collidable for Pacman {
|
||||
fn position(&self) -> crate::entity::traversal::Position {
|
||||
self.traverser.position
|
||||
/// Renders Pac-Man to the canvas.
|
||||
///
|
||||
/// Calculates screen position, determines if Pac-Man is stopped,
|
||||
/// and renders the appropriate directional texture.
|
||||
pub fn render<T: RenderTarget>(&self, canvas: &mut Canvas<T>, atlas: &mut SpriteAtlas, graph: &Graph) {
|
||||
let pixel_pos = self.get_pixel_pos(graph).round().as_ivec2() + BOARD_PIXEL_OFFSET.as_ivec2();
|
||||
let dest = centered_with_size(pixel_pos, UVec2::new(16, 16));
|
||||
let is_stopped = self.traverser.position.is_stopped();
|
||||
|
||||
if is_stopped {
|
||||
self.texture
|
||||
.render_stopped(canvas, atlas, dest, self.traverser.direction)
|
||||
.unwrap();
|
||||
} else {
|
||||
self.texture.render(canvas, atlas, dest, self.traverser.direction).unwrap();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,114 +0,0 @@
|
||||
//! Entity trait for common movement and rendering functionality.
|
||||
//!
|
||||
//! This module defines a trait that captures the shared behavior between
|
||||
//! different game entities like Ghosts and Pac-Man, including movement,
|
||||
//! rendering, and position calculations.
|
||||
|
||||
use glam::Vec2;
|
||||
use sdl2::render::{Canvas, RenderTarget};
|
||||
|
||||
use crate::entity::direction::Direction;
|
||||
use crate::entity::graph::{Edge, Graph, NodeId};
|
||||
use crate::entity::traversal::{Position, Traverser};
|
||||
use crate::error::{EntityError, GameError, GameResult, TextureError};
|
||||
use crate::texture::directional::DirectionalAnimatedTexture;
|
||||
use crate::texture::sprite::SpriteAtlas;
|
||||
|
||||
/// Trait defining common functionality for game entities that move through the graph.
|
||||
///
|
||||
/// This trait provides a unified interface for entities that:
|
||||
/// - Move through the game graph using a traverser
|
||||
/// - Render using directional animated textures
|
||||
/// - Have position calculations and movement speed
|
||||
#[allow(dead_code)]
|
||||
pub trait Entity {
|
||||
/// Returns a reference to the entity's traverser for movement control.
|
||||
fn traverser(&self) -> &Traverser;
|
||||
|
||||
/// Returns a mutable reference to the entity's traverser for movement control.
|
||||
fn traverser_mut(&mut self) -> &mut Traverser;
|
||||
|
||||
/// Returns a reference to the entity's directional animated texture.
|
||||
fn texture(&self) -> &DirectionalAnimatedTexture;
|
||||
|
||||
/// Returns a mutable reference to the entity's directional animated texture.
|
||||
fn texture_mut(&mut self) -> &mut DirectionalAnimatedTexture;
|
||||
|
||||
/// Returns the movement speed multiplier for this entity.
|
||||
fn speed(&self) -> f32;
|
||||
|
||||
/// Determines if this entity can traverse a given edge.
|
||||
fn can_traverse(&self, edge: Edge) -> bool;
|
||||
|
||||
/// Updates the entity's position and animation state.
|
||||
///
|
||||
/// This method advances movement through the graph and updates texture animation.
|
||||
fn tick(&mut self, dt: f32, graph: &Graph);
|
||||
|
||||
/// Calculates the current pixel position in the game world.
|
||||
///
|
||||
/// Converts the graph position to screen coordinates, accounting for
|
||||
/// the board offset and centering the sprite.
|
||||
fn get_pixel_pos(&self, graph: &Graph) -> GameResult<Vec2> {
|
||||
let pos = match self.traverser().position {
|
||||
Position::AtNode(node_id) => {
|
||||
let node = graph.get_node(node_id).ok_or(EntityError::NodeNotFound(node_id))?;
|
||||
node.position
|
||||
}
|
||||
Position::BetweenNodes { from, to, traversed } => {
|
||||
let from_node = graph.get_node(from).ok_or(EntityError::NodeNotFound(from))?;
|
||||
let to_node = graph.get_node(to).ok_or(EntityError::NodeNotFound(to))?;
|
||||
let edge = graph.find_edge(from, to).ok_or(EntityError::EdgeNotFound { from, to })?;
|
||||
from_node.position + (to_node.position - from_node.position) * (traversed / edge.distance)
|
||||
}
|
||||
};
|
||||
|
||||
Ok(Vec2::new(
|
||||
pos.x + crate::constants::BOARD_PIXEL_OFFSET.x as f32,
|
||||
pos.y + crate::constants::BOARD_PIXEL_OFFSET.y as f32,
|
||||
))
|
||||
}
|
||||
|
||||
/// Returns the current node ID that the entity is at or moving towards.
|
||||
///
|
||||
/// If the entity is at a node, returns that node ID.
|
||||
/// If the entity is between nodes, returns the node it's moving towards.
|
||||
fn current_node_id(&self) -> NodeId {
|
||||
match self.traverser().position {
|
||||
Position::AtNode(node_id) => node_id,
|
||||
Position::BetweenNodes { to, .. } => to,
|
||||
}
|
||||
}
|
||||
|
||||
/// Sets the next direction for the entity to take.
|
||||
///
|
||||
/// The direction is buffered and will be applied at the next opportunity,
|
||||
/// typically when the entity reaches a new node.
|
||||
fn set_next_direction(&mut self, direction: Direction) {
|
||||
self.traverser_mut().set_next_direction(direction);
|
||||
}
|
||||
|
||||
/// Renders the entity at its current position.
|
||||
///
|
||||
/// Draws the appropriate directional sprite based on the entity's
|
||||
/// current movement state and direction.
|
||||
fn render<T: RenderTarget>(&self, canvas: &mut Canvas<T>, atlas: &mut SpriteAtlas, graph: &Graph) -> GameResult<()> {
|
||||
let pixel_pos = self.get_pixel_pos(graph)?;
|
||||
let dest = crate::helpers::centered_with_size(
|
||||
glam::IVec2::new(pixel_pos.x as i32, pixel_pos.y as i32),
|
||||
glam::UVec2::new(16, 16),
|
||||
);
|
||||
|
||||
if self.traverser().position.is_stopped() {
|
||||
self.texture()
|
||||
.render_stopped(canvas, atlas, dest, self.traverser().direction)
|
||||
.map_err(|e| GameError::Texture(TextureError::RenderFailed(e.to_string())))?;
|
||||
} else {
|
||||
self.texture()
|
||||
.render(canvas, atlas, dest, self.traverser().direction)
|
||||
.map_err(|e| GameError::Texture(TextureError::RenderFailed(e.to_string())))?;
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
@@ -1,229 +0,0 @@
|
||||
use tracing::error;
|
||||
|
||||
use crate::error::GameResult;
|
||||
|
||||
use super::direction::Direction;
|
||||
use super::graph::{Edge, Graph, NodeId};
|
||||
|
||||
/// Represents the current position of an entity traversing the graph.
|
||||
///
|
||||
/// This enum allows for precise tracking of whether an entity is exactly at a node
|
||||
/// or moving along an edge between two nodes.
|
||||
#[derive(Debug, PartialEq, Clone, Copy)]
|
||||
pub enum Position {
|
||||
/// The traverser is located exactly at a node.
|
||||
AtNode(NodeId),
|
||||
/// The traverser is on an edge between two nodes.
|
||||
BetweenNodes {
|
||||
from: NodeId,
|
||||
to: NodeId,
|
||||
/// The floating-point distance traversed along the edge from the `from` node.
|
||||
traversed: f32,
|
||||
},
|
||||
}
|
||||
|
||||
#[allow(dead_code)]
|
||||
impl Position {
|
||||
/// Returns `true` if the position is exactly at a node.
|
||||
pub fn is_at_node(&self) -> bool {
|
||||
matches!(self, Position::AtNode(_))
|
||||
}
|
||||
|
||||
/// Returns the `NodeId` of the current or most recently departed node.
|
||||
#[allow(clippy::wrong_self_convention)]
|
||||
pub fn from_node_id(&self) -> NodeId {
|
||||
match self {
|
||||
Position::AtNode(id) => *id,
|
||||
Position::BetweenNodes { from, .. } => *from,
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns the `NodeId` of the destination node, if currently on an edge.
|
||||
#[allow(clippy::wrong_self_convention)]
|
||||
pub fn to_node_id(&self) -> Option<NodeId> {
|
||||
match self {
|
||||
Position::AtNode(_) => None,
|
||||
Position::BetweenNodes { to, .. } => Some(*to),
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns `true` if the traverser is stopped at a node.
|
||||
pub fn is_stopped(&self) -> bool {
|
||||
matches!(self, Position::AtNode(_))
|
||||
}
|
||||
}
|
||||
|
||||
/// Manages an entity's movement through the graph.
|
||||
///
|
||||
/// A `Traverser` encapsulates the state of an entity's position and direction,
|
||||
/// providing a way to advance along the graph's paths based on a given distance.
|
||||
/// It also handles direction changes, buffering the next intended direction.
|
||||
pub struct Traverser {
|
||||
/// The current position of the traverser in the graph.
|
||||
pub position: Position,
|
||||
/// The current direction of movement.
|
||||
pub direction: Direction,
|
||||
/// Buffered direction change with remaining frame count for timing.
|
||||
///
|
||||
/// The `u8` value represents the number of frames remaining before
|
||||
/// the buffered direction expires. This allows for responsive controls
|
||||
/// by storing direction changes for a limited time.
|
||||
pub next_direction: Option<(Direction, u8)>,
|
||||
}
|
||||
|
||||
impl Traverser {
|
||||
/// Creates a new traverser starting at the given node ID.
|
||||
///
|
||||
/// The traverser will immediately attempt to start moving in the initial direction.
|
||||
pub fn new<F>(graph: &Graph, start_node: NodeId, initial_direction: Direction, can_traverse: &F) -> Self
|
||||
where
|
||||
F: Fn(Edge) -> bool,
|
||||
{
|
||||
let mut traverser = Traverser {
|
||||
position: Position::AtNode(start_node),
|
||||
direction: initial_direction,
|
||||
next_direction: Some((initial_direction, 1)),
|
||||
};
|
||||
|
||||
// This will kickstart the traverser into motion
|
||||
if let Err(e) = traverser.advance(graph, 0.0, can_traverse) {
|
||||
error!("Traverser initialization error: {}", e);
|
||||
}
|
||||
|
||||
traverser
|
||||
}
|
||||
|
||||
/// Sets the next direction for the traverser to take.
|
||||
///
|
||||
/// The direction is buffered and will be applied at the next opportunity,
|
||||
/// typically when the traverser reaches a new node. This allows for responsive
|
||||
/// controls, as the new direction is stored for a limited time.
|
||||
pub fn set_next_direction(&mut self, new_direction: Direction) {
|
||||
if self.direction != new_direction {
|
||||
self.next_direction = Some((new_direction, 30));
|
||||
}
|
||||
}
|
||||
|
||||
/// Advances the traverser along the graph by a specified distance.
|
||||
///
|
||||
/// This method updates the traverser's position based on its current state
|
||||
/// and the distance to travel.
|
||||
///
|
||||
/// - If at a node, it checks for a buffered direction to start moving.
|
||||
/// - If between nodes, it moves along the current edge.
|
||||
/// - If it reaches a node, it attempts to transition to a new edge based on
|
||||
/// the buffered direction or by continuing straight.
|
||||
/// - If no valid move is possible, it stops at the node.
|
||||
///
|
||||
/// Returns an error if the movement is invalid (e.g., trying to move in an impossible direction).
|
||||
pub fn advance<F>(&mut self, graph: &Graph, distance: f32, can_traverse: &F) -> GameResult<()>
|
||||
where
|
||||
F: Fn(Edge) -> bool,
|
||||
{
|
||||
// Decrement the remaining frames for the next direction
|
||||
if let Some((direction, remaining)) = self.next_direction {
|
||||
if remaining > 0 {
|
||||
self.next_direction = Some((direction, remaining - 1));
|
||||
} else {
|
||||
self.next_direction = None;
|
||||
}
|
||||
}
|
||||
|
||||
match self.position {
|
||||
Position::AtNode(node_id) => {
|
||||
// We're not moving, but a buffered direction is available.
|
||||
if let Some((next_direction, _)) = self.next_direction {
|
||||
if let Some(edge) = graph.find_edge_in_direction(node_id, next_direction) {
|
||||
if can_traverse(edge) {
|
||||
// Start moving in that direction
|
||||
self.position = Position::BetweenNodes {
|
||||
from: node_id,
|
||||
to: edge.target,
|
||||
traversed: distance.max(0.0),
|
||||
};
|
||||
self.direction = next_direction;
|
||||
} else {
|
||||
return Err(crate::error::GameError::Entity(crate::error::EntityError::InvalidMovement(
|
||||
format!(
|
||||
"Cannot traverse edge from {} to {} in direction {:?}",
|
||||
node_id, edge.target, next_direction
|
||||
),
|
||||
)));
|
||||
}
|
||||
} else {
|
||||
return Err(crate::error::GameError::Entity(crate::error::EntityError::InvalidMovement(
|
||||
format!("No edge found in direction {:?} from node {}", next_direction, node_id),
|
||||
)));
|
||||
}
|
||||
|
||||
self.next_direction = None; // Consume the buffered direction regardless of whether we started moving with it
|
||||
}
|
||||
}
|
||||
Position::BetweenNodes { from, to, traversed } => {
|
||||
// There is no point in any of the next logic if we don't travel at all
|
||||
if distance <= 0.0 {
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
let edge = graph.find_edge(from, to).ok_or_else(|| {
|
||||
crate::error::GameError::Entity(crate::error::EntityError::InvalidMovement(format!(
|
||||
"Inconsistent state: Traverser is on a non-existent edge from {} to {}.",
|
||||
from, to
|
||||
)))
|
||||
})?;
|
||||
|
||||
let new_traversed = traversed + distance;
|
||||
|
||||
if new_traversed < edge.distance {
|
||||
// Still on the same edge, just update the distance.
|
||||
self.position = Position::BetweenNodes {
|
||||
from,
|
||||
to,
|
||||
traversed: new_traversed,
|
||||
};
|
||||
} else {
|
||||
let overflow = new_traversed - edge.distance;
|
||||
let mut moved = false;
|
||||
|
||||
// If we buffered a direction, try to find an edge in that direction
|
||||
if let Some((next_dir, _)) = self.next_direction {
|
||||
if let Some(edge) = graph.find_edge_in_direction(to, next_dir) {
|
||||
if can_traverse(edge) {
|
||||
self.position = Position::BetweenNodes {
|
||||
from: to,
|
||||
to: edge.target,
|
||||
traversed: overflow,
|
||||
};
|
||||
|
||||
self.direction = next_dir; // Remember our new direction
|
||||
self.next_direction = None; // Consume the buffered direction
|
||||
moved = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// If we didn't move, try to continue in the current direction
|
||||
if !moved {
|
||||
if let Some(edge) = graph.find_edge_in_direction(to, self.direction) {
|
||||
if can_traverse(edge) {
|
||||
self.position = Position::BetweenNodes {
|
||||
from: to,
|
||||
to: edge.target,
|
||||
traversed: overflow,
|
||||
};
|
||||
} else {
|
||||
self.position = Position::AtNode(to);
|
||||
self.next_direction = None;
|
||||
}
|
||||
} else {
|
||||
self.position = Position::AtNode(to);
|
||||
self.next_direction = None;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
185
src/error.rs
185
src/error.rs
@@ -1,185 +0,0 @@
|
||||
//! Centralized error types for the Pac-Man game.
|
||||
//!
|
||||
//! This module defines all error types used throughout the application,
|
||||
//! providing a consistent error handling approach.
|
||||
|
||||
use std::io;
|
||||
|
||||
/// Main error type for the Pac-Man game.
|
||||
///
|
||||
/// This is the primary error type that should be used in public APIs.
|
||||
/// It can represent any error that can occur during game operation.
|
||||
#[derive(thiserror::Error, Debug)]
|
||||
pub enum GameError {
|
||||
#[error("Asset error: {0}")]
|
||||
Asset(#[from] AssetError),
|
||||
|
||||
#[error("Platform error: {0}")]
|
||||
Platform(#[from] PlatformError),
|
||||
|
||||
#[error("Map parsing error: {0}")]
|
||||
MapParse(#[from] ParseError),
|
||||
|
||||
#[error("Map error: {0}")]
|
||||
Map(#[from] MapError),
|
||||
|
||||
#[error("Texture error: {0}")]
|
||||
Texture(#[from] TextureError),
|
||||
|
||||
#[error("Entity error: {0}")]
|
||||
Entity(#[from] EntityError),
|
||||
|
||||
#[error("Game state error: {0}")]
|
||||
GameState(#[from] GameStateError),
|
||||
|
||||
#[error("SDL error: {0}")]
|
||||
Sdl(String),
|
||||
|
||||
#[error("IO error: {0}")]
|
||||
Io(#[from] io::Error),
|
||||
|
||||
#[error("Serialization error: {0}")]
|
||||
Serialization(#[from] serde_json::Error),
|
||||
|
||||
#[error("Invalid state: {0}")]
|
||||
InvalidState(String),
|
||||
}
|
||||
|
||||
#[derive(thiserror::Error, Debug)]
|
||||
pub enum AssetError {
|
||||
#[error("IO error: {0}")]
|
||||
Io(#[from] io::Error),
|
||||
#[error("Asset not found: {0}")]
|
||||
NotFound(String),
|
||||
}
|
||||
|
||||
/// Platform-specific errors.
|
||||
#[derive(thiserror::Error, Debug)]
|
||||
#[allow(dead_code)]
|
||||
pub enum PlatformError {
|
||||
#[error("Console initialization failed: {0}")]
|
||||
ConsoleInit(String),
|
||||
#[error("Platform-specific error: {0}")]
|
||||
Other(String),
|
||||
}
|
||||
|
||||
/// Error type for map parsing operations.
|
||||
#[derive(thiserror::Error, Debug)]
|
||||
pub enum ParseError {
|
||||
#[error("Unknown character in board: {0}")]
|
||||
UnknownCharacter(char),
|
||||
#[error("House door must have exactly 2 positions, found {0}")]
|
||||
InvalidHouseDoorCount(usize),
|
||||
#[error("Map parsing failed: {0}")]
|
||||
ParseFailed(String),
|
||||
}
|
||||
|
||||
/// Errors related to texture operations.
|
||||
#[derive(thiserror::Error, Debug)]
|
||||
pub enum TextureError {
|
||||
#[error("Animated texture error: {0}")]
|
||||
Animated(#[from] AnimatedTextureError),
|
||||
|
||||
#[error("Failed to load texture: {0}")]
|
||||
LoadFailed(String),
|
||||
|
||||
#[error("Texture not found in atlas: {0}")]
|
||||
AtlasTileNotFound(String),
|
||||
|
||||
#[error("Invalid texture format: {0}")]
|
||||
InvalidFormat(String),
|
||||
|
||||
#[error("Rendering failed: {0}")]
|
||||
RenderFailed(String),
|
||||
}
|
||||
|
||||
#[derive(thiserror::Error, Debug)]
|
||||
pub enum AnimatedTextureError {
|
||||
#[error("Frame duration must be positive, got {0}")]
|
||||
InvalidFrameDuration(f32),
|
||||
}
|
||||
|
||||
/// Errors related to entity operations.
|
||||
#[derive(thiserror::Error, Debug)]
|
||||
pub enum EntityError {
|
||||
#[error("Node not found in graph: {0}")]
|
||||
NodeNotFound(usize),
|
||||
|
||||
#[error("Edge not found: from {from} to {to}")]
|
||||
EdgeNotFound { from: usize, to: usize },
|
||||
|
||||
#[error("Invalid movement: {0}")]
|
||||
InvalidMovement(String),
|
||||
|
||||
#[error("Pathfinding failed: {0}")]
|
||||
PathfindingFailed(String),
|
||||
}
|
||||
|
||||
/// Errors related to game state operations.
|
||||
#[derive(thiserror::Error, Debug)]
|
||||
pub enum GameStateError {}
|
||||
|
||||
/// Errors related to map operations.
|
||||
#[derive(thiserror::Error, Debug)]
|
||||
pub enum MapError {
|
||||
#[error("Node not found: {0}")]
|
||||
NodeNotFound(usize),
|
||||
|
||||
#[error("Invalid map configuration: {0}")]
|
||||
InvalidConfig(String),
|
||||
}
|
||||
|
||||
/// Result type for game operations.
|
||||
pub type GameResult<T> = Result<T, GameError>;
|
||||
|
||||
/// Helper trait for converting other error types to GameError.
|
||||
pub trait IntoGameError<T> {
|
||||
#[allow(dead_code)]
|
||||
fn into_game_error(self) -> GameResult<T>;
|
||||
}
|
||||
|
||||
impl<T, E> IntoGameError<T> for Result<T, E>
|
||||
where
|
||||
E: std::error::Error + Send + Sync + 'static,
|
||||
{
|
||||
fn into_game_error(self) -> GameResult<T> {
|
||||
self.map_err(|e| GameError::InvalidState(e.to_string()))
|
||||
}
|
||||
}
|
||||
|
||||
/// Helper trait for converting Option to GameResult with a custom error.
|
||||
pub trait OptionExt<T> {
|
||||
#[allow(dead_code)]
|
||||
fn ok_or_game_error<F>(self, f: F) -> GameResult<T>
|
||||
where
|
||||
F: FnOnce() -> GameError;
|
||||
}
|
||||
|
||||
impl<T> OptionExt<T> for Option<T> {
|
||||
fn ok_or_game_error<F>(self, f: F) -> GameResult<T>
|
||||
where
|
||||
F: FnOnce() -> GameError,
|
||||
{
|
||||
self.ok_or_else(f)
|
||||
}
|
||||
}
|
||||
|
||||
/// Helper trait for converting Result to GameResult with context.
|
||||
pub trait ResultExt<T, E> {
|
||||
#[allow(dead_code)]
|
||||
fn with_context<F>(self, f: F) -> GameResult<T>
|
||||
where
|
||||
F: FnOnce(&E) -> GameError;
|
||||
}
|
||||
|
||||
impl<T, E> ResultExt<T, E> for Result<T, E>
|
||||
where
|
||||
E: std::error::Error + Send + Sync + 'static,
|
||||
{
|
||||
fn with_context<F>(self, f: F) -> GameResult<T>
|
||||
where
|
||||
F: FnOnce(&E) -> GameError,
|
||||
{
|
||||
self.map_err(|e| f(&e))
|
||||
}
|
||||
}
|
||||
215
src/game.rs
Normal file
215
src/game.rs
Normal file
@@ -0,0 +1,215 @@
|
||||
//! This module contains the main game logic and state.
|
||||
|
||||
use anyhow::Result;
|
||||
use glam::UVec2;
|
||||
use rand::{rngs::SmallRng, Rng, SeedableRng};
|
||||
use sdl2::{
|
||||
image::LoadTexture,
|
||||
keyboard::Keycode,
|
||||
pixels::Color,
|
||||
render::{Canvas, RenderTarget, Texture, TextureCreator},
|
||||
video::WindowContext,
|
||||
};
|
||||
|
||||
use crate::{
|
||||
asset::{get_asset_bytes, Asset},
|
||||
audio::Audio,
|
||||
constants::RAW_BOARD,
|
||||
entity::{
|
||||
ghost::{Ghost, GhostType},
|
||||
pacman::Pacman,
|
||||
},
|
||||
map::Map,
|
||||
texture::{
|
||||
sprite::{self, AtlasMapper, AtlasTile, SpriteAtlas},
|
||||
text::TextTexture,
|
||||
},
|
||||
};
|
||||
|
||||
/// The main game state.
|
||||
///
|
||||
/// Contains all the information necessary to run the game, including
|
||||
/// the game state, rendering resources, and audio.
|
||||
pub struct Game {
|
||||
pub score: u32,
|
||||
pub map: Map,
|
||||
pub pacman: Pacman,
|
||||
pub ghosts: Vec<Ghost>,
|
||||
pub debug_mode: bool,
|
||||
|
||||
// Rendering resources
|
||||
atlas: SpriteAtlas,
|
||||
map_texture: AtlasTile,
|
||||
text_texture: TextTexture,
|
||||
|
||||
// Audio
|
||||
pub audio: Audio,
|
||||
}
|
||||
|
||||
impl Game {
|
||||
pub fn new(
|
||||
texture_creator: &TextureCreator<WindowContext>,
|
||||
_ttf_context: &sdl2::ttf::Sdl2TtfContext,
|
||||
_audio_subsystem: &sdl2::AudioSubsystem,
|
||||
) -> Game {
|
||||
let map = Map::new(RAW_BOARD);
|
||||
|
||||
let pacman_start_pos = map.find_starting_position(0).unwrap();
|
||||
let pacman_start_node = *map
|
||||
.grid_to_node
|
||||
.get(&glam::IVec2::new(pacman_start_pos.x as i32, pacman_start_pos.y as i32))
|
||||
.expect("Pac-Man starting position not found in graph");
|
||||
|
||||
let atlas_bytes = get_asset_bytes(Asset::Atlas).expect("Failed to load asset");
|
||||
let atlas_texture = unsafe {
|
||||
let texture = texture_creator
|
||||
.load_texture_bytes(&atlas_bytes)
|
||||
.expect("Could not load atlas texture from asset API");
|
||||
sprite::texture_to_static(texture)
|
||||
};
|
||||
let atlas_json = get_asset_bytes(Asset::AtlasJson).expect("Failed to load asset");
|
||||
let atlas_mapper: AtlasMapper = serde_json::from_slice(&atlas_json).expect("Could not parse atlas JSON");
|
||||
let atlas = SpriteAtlas::new(atlas_texture, atlas_mapper);
|
||||
|
||||
let mut map_texture = SpriteAtlas::get_tile(&atlas, "maze/full.png").expect("Failed to load map tile");
|
||||
map_texture.color = Some(Color::RGB(0x20, 0x20, 0xf9));
|
||||
|
||||
let text_texture = TextTexture::new(1.0);
|
||||
let audio = Audio::new();
|
||||
let pacman = Pacman::new(&map.graph, pacman_start_node, &atlas);
|
||||
|
||||
// Create ghosts at random positions
|
||||
let mut ghosts = Vec::new();
|
||||
let ghost_types = [GhostType::Blinky, GhostType::Pinky, GhostType::Inky, GhostType::Clyde];
|
||||
let mut rng = SmallRng::from_os_rng();
|
||||
|
||||
for &ghost_type in &ghost_types {
|
||||
// Find a random node for the ghost to start at
|
||||
let random_node = rng.random_range(0..map.graph.node_count());
|
||||
let ghost = Ghost::new(&map.graph, random_node, ghost_type, &atlas);
|
||||
ghosts.push(ghost);
|
||||
}
|
||||
|
||||
Game {
|
||||
score: 0,
|
||||
map,
|
||||
pacman,
|
||||
ghosts,
|
||||
debug_mode: false,
|
||||
map_texture,
|
||||
text_texture,
|
||||
audio,
|
||||
atlas,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn keyboard_event(&mut self, keycode: Keycode) {
|
||||
self.pacman.handle_key(keycode);
|
||||
|
||||
if keycode == Keycode::M {
|
||||
self.audio.set_mute(!self.audio.is_muted());
|
||||
}
|
||||
|
||||
if keycode == Keycode::R {
|
||||
self.reset_game_state();
|
||||
}
|
||||
}
|
||||
|
||||
/// Resets the game state, randomizing ghost positions and resetting Pac-Man
|
||||
fn reset_game_state(&mut self) {
|
||||
// Reset Pac-Man to starting position
|
||||
let pacman_start_pos = self.map.find_starting_position(0).unwrap();
|
||||
let pacman_start_node = *self
|
||||
.map
|
||||
.grid_to_node
|
||||
.get(&glam::IVec2::new(pacman_start_pos.x as i32, pacman_start_pos.y as i32))
|
||||
.expect("Pac-Man starting position not found in graph");
|
||||
|
||||
self.pacman = Pacman::new(&self.map.graph, pacman_start_node, &self.atlas);
|
||||
|
||||
// Randomize ghost positions
|
||||
let ghost_types = [GhostType::Blinky, GhostType::Pinky, GhostType::Inky, GhostType::Clyde];
|
||||
let mut rng = SmallRng::from_os_rng();
|
||||
|
||||
for (i, ghost) in self.ghosts.iter_mut().enumerate() {
|
||||
let random_node = rng.random_range(0..self.map.graph.node_count());
|
||||
*ghost = Ghost::new(&self.map.graph, random_node, ghost_types[i], &self.atlas);
|
||||
}
|
||||
}
|
||||
|
||||
pub fn tick(&mut self, dt: f32) {
|
||||
self.pacman.tick(dt, &self.map.graph);
|
||||
|
||||
// Update all ghosts
|
||||
for ghost in &mut self.ghosts {
|
||||
ghost.tick(dt, &self.map.graph);
|
||||
}
|
||||
}
|
||||
|
||||
pub fn draw<T: RenderTarget>(&mut self, canvas: &mut Canvas<T>, backbuffer: &mut Texture) -> Result<()> {
|
||||
canvas.with_texture_canvas(backbuffer, |canvas| {
|
||||
canvas.set_draw_color(Color::BLACK);
|
||||
canvas.clear();
|
||||
self.map.render(canvas, &mut self.atlas, &mut self.map_texture);
|
||||
|
||||
// Render all ghosts
|
||||
for ghost in &self.ghosts {
|
||||
ghost.render(canvas, &mut self.atlas, &self.map.graph);
|
||||
}
|
||||
|
||||
self.pacman.render(canvas, &mut self.atlas, &self.map.graph);
|
||||
})?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn present_backbuffer<T: RenderTarget>(
|
||||
&mut self,
|
||||
canvas: &mut Canvas<T>,
|
||||
backbuffer: &Texture,
|
||||
cursor_pos: glam::Vec2,
|
||||
) -> Result<()> {
|
||||
canvas.copy(backbuffer, None, None).map_err(anyhow::Error::msg)?;
|
||||
if self.debug_mode {
|
||||
self.map
|
||||
.debug_render_with_cursor(canvas, &mut self.text_texture, &mut self.atlas, cursor_pos);
|
||||
}
|
||||
self.draw_hud(canvas)?;
|
||||
canvas.present();
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn draw_hud<T: RenderTarget>(&mut self, canvas: &mut Canvas<T>) -> Result<()> {
|
||||
let lives = 3;
|
||||
let score_text = format!("{:02}", self.score);
|
||||
let x_offset = 4;
|
||||
let y_offset = 2;
|
||||
let lives_offset = 3;
|
||||
let score_offset = 7 - (score_text.len() as i32);
|
||||
self.text_texture.set_scale(1.0);
|
||||
let _ = self.text_texture.render(
|
||||
canvas,
|
||||
&mut self.atlas,
|
||||
&format!("{lives}UP HIGH SCORE "),
|
||||
UVec2::new(8 * lives_offset as u32 + x_offset, y_offset),
|
||||
);
|
||||
let _ = self.text_texture.render(
|
||||
canvas,
|
||||
&mut self.atlas,
|
||||
&score_text,
|
||||
UVec2::new(8 * score_offset as u32 + x_offset, 8 + y_offset),
|
||||
);
|
||||
|
||||
// Display FPS information in top-left corner
|
||||
// let fps_text = format!("FPS: {:.1} (1s) / {:.1} (10s)", self.fps_1s, self.fps_10s);
|
||||
// self.render_text_on(
|
||||
// canvas,
|
||||
// &*texture_creator,
|
||||
// &fps_text,
|
||||
// IVec2::new(10, 10),
|
||||
// Color::RGB(255, 255, 0), // Yellow color for FPS display
|
||||
// );
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
327
src/game/mod.rs
327
src/game/mod.rs
@@ -1,327 +0,0 @@
|
||||
//! This module contains the main game logic and state.
|
||||
|
||||
use glam::{UVec2, Vec2};
|
||||
use rand::{rngs::SmallRng, Rng, SeedableRng};
|
||||
use sdl2::{
|
||||
keyboard::Keycode,
|
||||
pixels::Color,
|
||||
render::{Canvas, RenderTarget, Texture, TextureCreator},
|
||||
video::WindowContext,
|
||||
};
|
||||
|
||||
use crate::error::{EntityError, GameError, GameResult};
|
||||
|
||||
use crate::entity::{
|
||||
collision::{Collidable, CollisionSystem, EntityId},
|
||||
ghost::{Ghost, GhostType},
|
||||
pacman::Pacman,
|
||||
r#trait::Entity,
|
||||
};
|
||||
|
||||
pub mod state;
|
||||
use state::GameState;
|
||||
|
||||
/// The `Game` struct is the main entry point for the game.
|
||||
///
|
||||
/// It contains the game's state and logic, and is responsible for
|
||||
/// handling user input, updating the game state, and rendering the game.
|
||||
pub struct Game {
|
||||
state: GameState,
|
||||
}
|
||||
|
||||
impl Game {
|
||||
pub fn new(texture_creator: &'static TextureCreator<WindowContext>) -> GameResult<Game> {
|
||||
let state = GameState::new(texture_creator)?;
|
||||
|
||||
Ok(Game { state })
|
||||
}
|
||||
|
||||
pub fn keyboard_event(&mut self, keycode: Keycode) {
|
||||
self.state.pacman.handle_key(keycode);
|
||||
|
||||
if keycode == Keycode::M {
|
||||
self.state.audio.set_mute(!self.state.audio.is_muted());
|
||||
}
|
||||
|
||||
if keycode == Keycode::R {
|
||||
if let Err(e) = self.reset_game_state() {
|
||||
tracing::error!("Failed to reset game state: {}", e);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Resets the game state, randomizing ghost positions and resetting Pac-Man
|
||||
fn reset_game_state(&mut self) -> GameResult<()> {
|
||||
let pacman_start_node = self.state.map.start_positions.pacman;
|
||||
self.state.pacman = Pacman::new(&self.state.map.graph, pacman_start_node, &self.state.atlas)?;
|
||||
|
||||
// Reset items
|
||||
self.state.items = self.state.map.generate_items(&self.state.atlas)?;
|
||||
|
||||
// Randomize ghost positions
|
||||
let ghost_types = [GhostType::Blinky, GhostType::Pinky, GhostType::Inky, GhostType::Clyde];
|
||||
let mut rng = SmallRng::from_os_rng();
|
||||
|
||||
for (i, ghost) in self.state.ghosts.iter_mut().enumerate() {
|
||||
let random_node = rng.random_range(0..self.state.map.graph.node_count());
|
||||
*ghost = Ghost::new(&self.state.map.graph, random_node, ghost_types[i], &self.state.atlas)?;
|
||||
}
|
||||
|
||||
// Reset collision system
|
||||
self.state.collision_system = CollisionSystem::default();
|
||||
|
||||
// Re-register Pac-Man
|
||||
self.state.pacman_id = self.state.collision_system.register_entity(self.state.pacman.position());
|
||||
|
||||
// Re-register items
|
||||
self.state.item_ids.clear();
|
||||
for item in &self.state.items {
|
||||
let item_id = self.state.collision_system.register_entity(item.position());
|
||||
self.state.item_ids.push(item_id);
|
||||
}
|
||||
|
||||
// Re-register ghosts
|
||||
self.state.ghost_ids.clear();
|
||||
for ghost in &self.state.ghosts {
|
||||
let ghost_id = self.state.collision_system.register_entity(ghost.position());
|
||||
self.state.ghost_ids.push(ghost_id);
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn tick(&mut self, dt: f32) {
|
||||
self.state.pacman.tick(dt, &self.state.map.graph);
|
||||
|
||||
// Update all ghosts
|
||||
for ghost in &mut self.state.ghosts {
|
||||
ghost.tick(dt, &self.state.map.graph);
|
||||
}
|
||||
|
||||
// Update collision system positions
|
||||
self.update_collision_positions();
|
||||
|
||||
// Check for collisions
|
||||
self.check_collisions();
|
||||
}
|
||||
|
||||
/// Toggles the debug mode on and off.
|
||||
///
|
||||
/// When debug mode is enabled, the game will render additional information
|
||||
/// that is useful for debugging, such as the collision grid and entity paths.
|
||||
pub fn toggle_debug_mode(&mut self) {
|
||||
self.state.debug_mode = !self.state.debug_mode;
|
||||
}
|
||||
|
||||
fn update_collision_positions(&mut self) {
|
||||
// Update Pac-Man's position
|
||||
self.state
|
||||
.collision_system
|
||||
.update_position(self.state.pacman_id, self.state.pacman.position());
|
||||
|
||||
// Update ghost positions
|
||||
for (ghost, &ghost_id) in self.state.ghosts.iter().zip(&self.state.ghost_ids) {
|
||||
self.state.collision_system.update_position(ghost_id, ghost.position());
|
||||
}
|
||||
}
|
||||
|
||||
fn check_collisions(&mut self) {
|
||||
// Check Pac-Man vs Items
|
||||
let potential_collisions = self
|
||||
.state
|
||||
.collision_system
|
||||
.potential_collisions(&self.state.pacman.position());
|
||||
|
||||
for entity_id in potential_collisions {
|
||||
if entity_id != self.state.pacman_id {
|
||||
// Check if this is an item collision
|
||||
if let Some(item_index) = self.find_item_by_id(entity_id) {
|
||||
let item = &mut self.state.items[item_index];
|
||||
if !item.is_collected() {
|
||||
item.collect();
|
||||
self.state.score += item.get_score();
|
||||
self.state.audio.eat();
|
||||
|
||||
// Handle energizer effects
|
||||
if matches!(item.item_type, crate::entity::item::ItemType::Energizer) {
|
||||
// TODO: Make ghosts frightened
|
||||
tracing::info!("Energizer collected! Ghosts should become frightened.");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Check if this is a ghost collision
|
||||
if let Some(_ghost_index) = self.find_ghost_by_id(entity_id) {
|
||||
// TODO: Handle Pac-Man being eaten by ghost
|
||||
tracing::info!("Pac-Man collided with ghost!");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn find_item_by_id(&self, entity_id: EntityId) -> Option<usize> {
|
||||
self.state.item_ids.iter().position(|&id| id == entity_id)
|
||||
}
|
||||
|
||||
fn find_ghost_by_id(&self, entity_id: EntityId) -> Option<usize> {
|
||||
self.state.ghost_ids.iter().position(|&id| id == entity_id)
|
||||
}
|
||||
|
||||
pub fn draw<T: RenderTarget>(&mut self, canvas: &mut Canvas<T>, backbuffer: &mut Texture) -> GameResult<()> {
|
||||
canvas
|
||||
.with_texture_canvas(backbuffer, |canvas| {
|
||||
canvas.set_draw_color(Color::BLACK);
|
||||
canvas.clear();
|
||||
self.state
|
||||
.map
|
||||
.render(canvas, &mut self.state.atlas, &mut self.state.map_texture);
|
||||
|
||||
// Render all items
|
||||
for item in &self.state.items {
|
||||
if let Err(e) = item.render(canvas, &mut self.state.atlas, &self.state.map.graph) {
|
||||
tracing::error!("Failed to render item: {}", e);
|
||||
}
|
||||
}
|
||||
|
||||
// Render all ghosts
|
||||
for ghost in &self.state.ghosts {
|
||||
if let Err(e) = ghost.render(canvas, &mut self.state.atlas, &self.state.map.graph) {
|
||||
tracing::error!("Failed to render ghost: {}", e);
|
||||
}
|
||||
}
|
||||
|
||||
if let Err(e) = self.state.pacman.render(canvas, &mut self.state.atlas, &self.state.map.graph) {
|
||||
tracing::error!("Failed to render pacman: {}", e);
|
||||
}
|
||||
})
|
||||
.map_err(|e| GameError::Sdl(e.to_string()))?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn present_backbuffer<T: RenderTarget>(
|
||||
&mut self,
|
||||
canvas: &mut Canvas<T>,
|
||||
backbuffer: &Texture,
|
||||
cursor_pos: glam::Vec2,
|
||||
) -> GameResult<()> {
|
||||
canvas
|
||||
.copy(backbuffer, None, None)
|
||||
.map_err(|e| GameError::Sdl(e.to_string()))?;
|
||||
if self.state.debug_mode {
|
||||
if let Err(e) =
|
||||
self.state
|
||||
.map
|
||||
.debug_render_with_cursor(canvas, &mut self.state.text_texture, &mut self.state.atlas, cursor_pos)
|
||||
{
|
||||
tracing::error!("Failed to render debug cursor: {}", e);
|
||||
}
|
||||
self.render_pathfinding_debug(canvas)?;
|
||||
}
|
||||
self.draw_hud(canvas)?;
|
||||
canvas.present();
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Renders pathfinding debug lines from each ghost to Pac-Man.
|
||||
///
|
||||
/// Each ghost's path is drawn in its respective color with a small offset
|
||||
/// to prevent overlapping lines.
|
||||
fn render_pathfinding_debug<T: RenderTarget>(&self, canvas: &mut Canvas<T>) -> GameResult<()> {
|
||||
let pacman_node = self.state.pacman.current_node_id();
|
||||
|
||||
for ghost in self.state.ghosts.iter() {
|
||||
if let Ok(path) = ghost.calculate_path_to_target(&self.state.map.graph, pacman_node) {
|
||||
if path.len() < 2 {
|
||||
continue; // Skip if path is too short
|
||||
}
|
||||
|
||||
// Set the ghost's color
|
||||
canvas.set_draw_color(ghost.debug_color());
|
||||
|
||||
// Calculate offset based on ghost index to prevent overlapping lines
|
||||
// let offset = (i as f32) * 2.0 - 3.0; // Offset range: -3.0 to 3.0
|
||||
|
||||
// Calculate a consistent offset direction for the entire path
|
||||
// let first_node = self.map.graph.get_node(path[0]).unwrap();
|
||||
// let last_node = self.map.graph.get_node(path[path.len() - 1]).unwrap();
|
||||
|
||||
// Use the overall direction from start to end to determine the perpendicular offset
|
||||
let offset = match ghost.ghost_type {
|
||||
GhostType::Blinky => Vec2::new(0.25, 0.5),
|
||||
GhostType::Pinky => Vec2::new(-0.25, -0.25),
|
||||
GhostType::Inky => Vec2::new(0.5, -0.5),
|
||||
GhostType::Clyde => Vec2::new(-0.5, 0.25),
|
||||
} * 5.0;
|
||||
|
||||
// Calculate offset positions for all nodes using the same perpendicular direction
|
||||
let mut offset_positions = Vec::new();
|
||||
for &node_id in &path {
|
||||
let node = self
|
||||
.state
|
||||
.map
|
||||
.graph
|
||||
.get_node(node_id)
|
||||
.ok_or(GameError::Entity(EntityError::NodeNotFound(node_id)))?;
|
||||
let pos = node.position + crate::constants::BOARD_PIXEL_OFFSET.as_vec2();
|
||||
offset_positions.push(pos + offset);
|
||||
}
|
||||
|
||||
// Draw lines between the offset positions
|
||||
for window in offset_positions.windows(2) {
|
||||
if let (Some(from), Some(to)) = (window.first(), window.get(1)) {
|
||||
// Skip if the distance is too far (used for preventing lines between tunnel portals)
|
||||
if from.distance_squared(*to) > (crate::constants::CELL_SIZE * 16).pow(2) as f32 {
|
||||
continue;
|
||||
}
|
||||
|
||||
// Draw the line
|
||||
canvas
|
||||
.draw_line((from.x as i32, from.y as i32), (to.x as i32, to.y as i32))
|
||||
.map_err(|e| GameError::Sdl(e.to_string()))?;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn draw_hud<T: RenderTarget>(&mut self, canvas: &mut Canvas<T>) -> GameResult<()> {
|
||||
let lives = 3;
|
||||
let score_text = format!("{:02}", self.state.score);
|
||||
let x_offset = 4;
|
||||
let y_offset = 2;
|
||||
let lives_offset = 3;
|
||||
let score_offset = 7 - (score_text.len() as i32);
|
||||
self.state.text_texture.set_scale(1.0);
|
||||
if let Err(e) = self.state.text_texture.render(
|
||||
canvas,
|
||||
&mut self.state.atlas,
|
||||
&format!("{lives}UP HIGH SCORE "),
|
||||
UVec2::new(8 * lives_offset as u32 + x_offset, y_offset),
|
||||
) {
|
||||
tracing::error!("Failed to render HUD text: {}", e);
|
||||
}
|
||||
if let Err(e) = self.state.text_texture.render(
|
||||
canvas,
|
||||
&mut self.state.atlas,
|
||||
&score_text,
|
||||
UVec2::new(8 * score_offset as u32 + x_offset, 8 + y_offset),
|
||||
) {
|
||||
tracing::error!("Failed to render score text: {}", e);
|
||||
}
|
||||
|
||||
// Display FPS information in top-left corner
|
||||
// let fps_text = format!("FPS: {:.1} (1s) / {:.1} (10s)", self.fps_1s, self.fps_10s);
|
||||
// self.render_text_on(
|
||||
// canvas,
|
||||
// &*texture_creator,
|
||||
// &fps_text,
|
||||
// IVec2::new(10, 10),
|
||||
// Color::RGB(255, 255, 0), // Yellow color for FPS display
|
||||
// );
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
@@ -1,135 +0,0 @@
|
||||
use sdl2::{image::LoadTexture, pixels::Color, render::TextureCreator, video::WindowContext};
|
||||
use smallvec::SmallVec;
|
||||
|
||||
use crate::{
|
||||
asset::{get_asset_bytes, Asset},
|
||||
audio::Audio,
|
||||
constants::RAW_BOARD,
|
||||
entity::{
|
||||
collision::{Collidable, CollisionSystem, EntityId},
|
||||
ghost::{Ghost, GhostType},
|
||||
item::Item,
|
||||
pacman::Pacman,
|
||||
},
|
||||
error::{GameError, GameResult, TextureError},
|
||||
map::Map,
|
||||
texture::{
|
||||
sprite::{AtlasMapper, AtlasTile, SpriteAtlas},
|
||||
text::TextTexture,
|
||||
},
|
||||
};
|
||||
|
||||
/// The `GameState` struct holds all the essential data for the game.
|
||||
///
|
||||
/// This includes the score, map, entities (Pac-Man, ghosts, items),
|
||||
/// collision system, and rendering resources. By centralizing the game's state,
|
||||
/// we can cleanly separate it from the game's logic, making it easier to manage
|
||||
/// and reason about.
|
||||
pub struct GameState {
|
||||
pub score: u32,
|
||||
pub map: Map,
|
||||
pub pacman: Pacman,
|
||||
pub ghosts: SmallVec<[Ghost; 4]>,
|
||||
pub items: Vec<Item>,
|
||||
pub debug_mode: bool,
|
||||
|
||||
// Collision system
|
||||
pub(crate) collision_system: CollisionSystem,
|
||||
pub(crate) pacman_id: EntityId,
|
||||
pub(crate) ghost_ids: SmallVec<[EntityId; 4]>,
|
||||
pub(crate) item_ids: Vec<EntityId>,
|
||||
|
||||
// Rendering resources
|
||||
pub(crate) atlas: SpriteAtlas,
|
||||
pub(crate) map_texture: AtlasTile,
|
||||
pub(crate) text_texture: TextTexture,
|
||||
|
||||
// Audio
|
||||
pub audio: Audio,
|
||||
}
|
||||
|
||||
impl GameState {
|
||||
/// Creates a new `GameState` by initializing all the game's data.
|
||||
///
|
||||
/// This function sets up the map, Pac-Man, ghosts, items, collision system,
|
||||
/// and all rendering resources required to start the game. It returns a `GameResult`
|
||||
/// to handle any potential errors during initialization.
|
||||
pub fn new(texture_creator: &'static TextureCreator<WindowContext>) -> GameResult<Self> {
|
||||
let map = Map::new(RAW_BOARD)?;
|
||||
|
||||
let pacman_start_node = map.start_positions.pacman;
|
||||
|
||||
let atlas_bytes = get_asset_bytes(Asset::Atlas)?;
|
||||
let atlas_texture = texture_creator.load_texture_bytes(&atlas_bytes).map_err(|e| {
|
||||
if e.to_string().contains("format") || e.to_string().contains("unsupported") {
|
||||
GameError::Texture(TextureError::InvalidFormat(format!("Unsupported texture format: {e}")))
|
||||
} else {
|
||||
GameError::Texture(TextureError::LoadFailed(e.to_string()))
|
||||
}
|
||||
})?;
|
||||
let atlas_json = get_asset_bytes(Asset::AtlasJson)?;
|
||||
let atlas_mapper: AtlasMapper = serde_json::from_slice(&atlas_json)?;
|
||||
let atlas = SpriteAtlas::new(atlas_texture, atlas_mapper);
|
||||
|
||||
let mut map_texture = SpriteAtlas::get_tile(&atlas, "maze/full.png")
|
||||
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("maze/full.png".to_string())))?;
|
||||
map_texture.color = Some(Color::RGB(0x20, 0x20, 0xf9));
|
||||
|
||||
let text_texture = TextTexture::new(1.0);
|
||||
let audio = Audio::new();
|
||||
let pacman = Pacman::new(&map.graph, pacman_start_node, &atlas)?;
|
||||
|
||||
// Generate items (pellets and energizers)
|
||||
let items = map.generate_items(&atlas)?;
|
||||
|
||||
// Initialize collision system
|
||||
let mut collision_system = CollisionSystem::default();
|
||||
|
||||
// Register Pac-Man
|
||||
let pacman_id = collision_system.register_entity(pacman.position());
|
||||
|
||||
// Register items
|
||||
let mut item_ids = Vec::new();
|
||||
for item in &items {
|
||||
let item_id = collision_system.register_entity(item.position());
|
||||
item_ids.push(item_id);
|
||||
}
|
||||
|
||||
// Create and register ghosts
|
||||
let ghosts = [GhostType::Blinky, GhostType::Pinky, GhostType::Inky, GhostType::Clyde]
|
||||
.iter()
|
||||
.zip(
|
||||
[
|
||||
map.start_positions.blinky,
|
||||
map.start_positions.pinky,
|
||||
map.start_positions.inky,
|
||||
map.start_positions.clyde,
|
||||
]
|
||||
.iter(),
|
||||
)
|
||||
.map(|(ghost_type, start_node)| Ghost::new(&map.graph, *start_node, *ghost_type, &atlas))
|
||||
.collect::<GameResult<SmallVec<[_; 4]>>>()?;
|
||||
|
||||
let ghost_ids = ghosts
|
||||
.iter()
|
||||
.map(|ghost| collision_system.register_entity(ghost.position()))
|
||||
.collect::<SmallVec<[_; 4]>>();
|
||||
|
||||
Ok(Self {
|
||||
score: 0,
|
||||
map,
|
||||
pacman,
|
||||
ghosts,
|
||||
items,
|
||||
debug_mode: false,
|
||||
collision_system,
|
||||
pacman_id,
|
||||
ghost_ids,
|
||||
item_ids,
|
||||
map_texture,
|
||||
text_texture,
|
||||
audio,
|
||||
atlas,
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -2,9 +2,10 @@ use glam::{IVec2, UVec2};
|
||||
use sdl2::rect::Rect;
|
||||
|
||||
pub fn centered_with_size(pixel_pos: IVec2, size: UVec2) -> Rect {
|
||||
// Ensure the position doesn't cause integer overflow when centering
|
||||
let x = pixel_pos.x.saturating_sub(size.x as i32 / 2);
|
||||
let y = pixel_pos.y.saturating_sub(size.y as i32 / 2);
|
||||
|
||||
Rect::new(x, y, size.x, size.y)
|
||||
Rect::new(
|
||||
pixel_pos.x - size.x as i32 / 2,
|
||||
pixel_pos.y - size.y as i32 / 2,
|
||||
size.x,
|
||||
size.y,
|
||||
)
|
||||
}
|
||||
|
||||
@@ -5,7 +5,6 @@ pub mod asset;
|
||||
pub mod audio;
|
||||
pub mod constants;
|
||||
pub mod entity;
|
||||
pub mod error;
|
||||
pub mod game;
|
||||
pub mod helpers;
|
||||
pub mod map;
|
||||
|
||||
@@ -11,7 +11,6 @@ mod audio;
|
||||
mod constants;
|
||||
|
||||
mod entity;
|
||||
mod error;
|
||||
mod game;
|
||||
mod helpers;
|
||||
mod map;
|
||||
|
||||
@@ -1,20 +1,18 @@
|
||||
//! Map construction and building functionality.
|
||||
|
||||
use crate::constants::{MapTile, BOARD_CELL_SIZE, CELL_SIZE, RAW_BOARD};
|
||||
use crate::constants::{MapTile, BOARD_CELL_SIZE, CELL_SIZE};
|
||||
use crate::entity::direction::Direction;
|
||||
use crate::entity::graph::{EdgePermissions, Graph, Node, NodeId};
|
||||
use crate::entity::item::{Item, ItemType};
|
||||
use crate::map::parser::MapTileParser;
|
||||
use crate::map::render::MapRenderer;
|
||||
use crate::texture::sprite::{AtlasTile, Sprite, SpriteAtlas};
|
||||
use glam::{IVec2, Vec2};
|
||||
use crate::texture::sprite::{AtlasTile, SpriteAtlas};
|
||||
use glam::{IVec2, UVec2, Vec2};
|
||||
use sdl2::render::{Canvas, RenderTarget};
|
||||
use std::collections::{HashMap, VecDeque};
|
||||
use tracing::debug;
|
||||
|
||||
use crate::error::{GameResult, MapError};
|
||||
|
||||
/// The starting positions of the entities in the game.
|
||||
#[allow(dead_code)]
|
||||
pub struct NodePositions {
|
||||
pub pacman: NodeId,
|
||||
pub blinky: NodeId,
|
||||
@@ -25,12 +23,18 @@ pub struct NodePositions {
|
||||
|
||||
/// The main map structure containing the game board and navigation graph.
|
||||
pub struct Map {
|
||||
/// The current state of the map.
|
||||
#[allow(dead_code)]
|
||||
current: [[MapTile; BOARD_CELL_SIZE.y as usize]; BOARD_CELL_SIZE.x as usize],
|
||||
/// The node map for entity movement.
|
||||
pub graph: Graph,
|
||||
/// A mapping from grid positions to node IDs.
|
||||
pub grid_to_node: HashMap<IVec2, NodeId>,
|
||||
/// A mapping of the starting positions of the entities.
|
||||
#[allow(dead_code)]
|
||||
pub start_positions: NodePositions,
|
||||
/// Pac-Man's starting position.
|
||||
pacman_start: Option<IVec2>,
|
||||
}
|
||||
|
||||
impl Map {
|
||||
@@ -43,12 +47,13 @@ impl Map {
|
||||
///
|
||||
/// This function will panic if the board layout contains unknown characters or if
|
||||
/// the house door is not defined by exactly two '=' characters.
|
||||
pub fn new(raw_board: [&str; BOARD_CELL_SIZE.y as usize]) -> GameResult<Map> {
|
||||
let parsed_map = MapTileParser::parse_board(raw_board)?;
|
||||
pub fn new(raw_board: [&str; BOARD_CELL_SIZE.y as usize]) -> Map {
|
||||
let parsed_map = MapTileParser::parse_board(raw_board).expect("Failed to parse board layout");
|
||||
|
||||
let map = parsed_map.tiles;
|
||||
let house_door = parsed_map.house_door;
|
||||
let tunnel_ends = parsed_map.tunnel_ends;
|
||||
let pacman_start = parsed_map.pacman_start;
|
||||
|
||||
let mut graph = Graph::new();
|
||||
let mut grid_to_node = HashMap::new();
|
||||
@@ -56,9 +61,7 @@ impl Map {
|
||||
let cell_offset = Vec2::splat(CELL_SIZE as f32 / 2.0);
|
||||
|
||||
// Find a starting point for the graph generation, preferably Pac-Man's position.
|
||||
let start_pos = parsed_map
|
||||
.pacman_start
|
||||
.ok_or_else(|| MapError::InvalidConfig("Pac-Man's starting position not found".to_string()))?;
|
||||
let start_pos = pacman_start.expect("Pac-Man's starting position not found");
|
||||
|
||||
// Add the starting position to the graph/queue
|
||||
let mut queue = VecDeque::new();
|
||||
@@ -111,7 +114,7 @@ impl Map {
|
||||
// Connect the new node to the source node
|
||||
graph
|
||||
.connect(*source_node_id, new_node_id, false, None, dir)
|
||||
.map_err(|e| MapError::InvalidConfig(format!("Failed to add edge: {e}")))?;
|
||||
.expect("Failed to add edge");
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -126,7 +129,7 @@ impl Map {
|
||||
if let Some(&neighbor_id) = grid_to_node.get(&neighbor) {
|
||||
graph
|
||||
.connect(node_id, neighbor_id, false, None, dir)
|
||||
.map_err(|e| MapError::InvalidConfig(format!("Failed to add edge: {e}")))?;
|
||||
.expect("Failed to add edge");
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -134,7 +137,7 @@ impl Map {
|
||||
|
||||
// Build house structure
|
||||
let (house_entrance_node_id, left_center_node_id, center_center_node_id, right_center_node_id) =
|
||||
Self::build_house(&mut graph, &grid_to_node, &house_door)?;
|
||||
Self::build_house(&mut graph, &grid_to_node, &house_door);
|
||||
|
||||
let start_positions = NodePositions {
|
||||
pacman: grid_to_node[&start_pos],
|
||||
@@ -145,13 +148,32 @@ impl Map {
|
||||
};
|
||||
|
||||
// Build tunnel connections
|
||||
Self::build_tunnels(&mut graph, &grid_to_node, &tunnel_ends)?;
|
||||
Self::build_tunnels(&mut graph, &grid_to_node, &tunnel_ends);
|
||||
|
||||
Ok(Map {
|
||||
Map {
|
||||
current: map,
|
||||
graph,
|
||||
grid_to_node,
|
||||
start_positions,
|
||||
})
|
||||
pacman_start,
|
||||
}
|
||||
}
|
||||
|
||||
/// Finds the starting position for a given entity ID.
|
||||
///
|
||||
/// # Arguments
|
||||
///
|
||||
/// * `entity_id` - The entity ID (0 for Pac-Man, 1-4 for ghosts)
|
||||
///
|
||||
/// # Returns
|
||||
///
|
||||
/// The starting position as a grid coordinate (`UVec2`), or `None` if not found.
|
||||
pub fn find_starting_position(&self, entity_id: u8) -> Option<UVec2> {
|
||||
// For now, only Pac-Man (entity_id 0) is supported
|
||||
if entity_id == 0 {
|
||||
return self.pacman_start.map(|pos| UVec2::new(pos.x as u32, pos.y as u32));
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
/// Renders the map to the given canvas.
|
||||
@@ -162,44 +184,6 @@ impl Map {
|
||||
MapRenderer::render_map(canvas, atlas, map_texture);
|
||||
}
|
||||
|
||||
/// Generates Item entities for pellets and energizers from the parsed map.
|
||||
pub fn generate_items(&self, atlas: &SpriteAtlas) -> GameResult<Vec<Item>> {
|
||||
// Pre-load sprites to avoid repeated texture lookups
|
||||
let pellet_sprite = SpriteAtlas::get_tile(atlas, "maze/pellet.png")
|
||||
.ok_or_else(|| MapError::InvalidConfig("Pellet texture not found".to_string()))?;
|
||||
let energizer_sprite = SpriteAtlas::get_tile(atlas, "maze/energizer.png")
|
||||
.ok_or_else(|| MapError::InvalidConfig("Energizer texture not found".to_string()))?;
|
||||
|
||||
// Pre-allocate with estimated capacity (typical Pac-Man maps have ~240 pellets + 4 energizers)
|
||||
let mut items = Vec::with_capacity(250);
|
||||
|
||||
// Parse the raw board once
|
||||
let parsed_map = MapTileParser::parse_board(RAW_BOARD)?;
|
||||
let map = parsed_map.tiles;
|
||||
|
||||
// Iterate through the map and collect items more efficiently
|
||||
for (x, row) in map.iter().enumerate() {
|
||||
for (y, tile) in row.iter().enumerate() {
|
||||
match tile {
|
||||
MapTile::Pellet | MapTile::PowerPellet => {
|
||||
let grid_pos = IVec2::new(x as i32, y as i32);
|
||||
if let Some(&node_id) = self.grid_to_node.get(&grid_pos) {
|
||||
let (item_type, sprite) = match tile {
|
||||
MapTile::Pellet => (ItemType::Pellet, Sprite::new(pellet_sprite)),
|
||||
MapTile::PowerPellet => (ItemType::Energizer, Sprite::new(energizer_sprite)),
|
||||
_ => unreachable!(), // We already filtered for these types
|
||||
};
|
||||
items.push(Item::new(node_id, item_type, sprite));
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Ok(items)
|
||||
}
|
||||
|
||||
/// Renders a debug visualization with cursor-based highlighting.
|
||||
///
|
||||
/// This function provides interactive debugging by highlighting the nearest node
|
||||
@@ -210,8 +194,8 @@ impl Map {
|
||||
text_renderer: &mut crate::texture::text::TextTexture,
|
||||
atlas: &mut SpriteAtlas,
|
||||
cursor_pos: glam::Vec2,
|
||||
) -> GameResult<()> {
|
||||
MapRenderer::debug_render_with_cursor(&self.graph, canvas, text_renderer, atlas, cursor_pos)
|
||||
) {
|
||||
MapRenderer::debug_render_with_cursor(&self.graph, canvas, text_renderer, atlas, cursor_pos);
|
||||
}
|
||||
|
||||
/// Builds the house structure in the graph.
|
||||
@@ -219,32 +203,21 @@ impl Map {
|
||||
graph: &mut Graph,
|
||||
grid_to_node: &HashMap<IVec2, NodeId>,
|
||||
house_door: &[Option<IVec2>; 2],
|
||||
) -> GameResult<(usize, usize, usize, usize)> {
|
||||
) -> (usize, usize, usize, usize) {
|
||||
// Calculate the position of the house entrance node
|
||||
let (house_entrance_node_id, house_entrance_node_position) = {
|
||||
// Translate the grid positions to the actual node ids
|
||||
let left_node = grid_to_node
|
||||
.get(
|
||||
&(house_door[0]
|
||||
.ok_or_else(|| MapError::InvalidConfig("First house door position not acquired".to_string()))?
|
||||
+ Direction::Left.as_ivec2()),
|
||||
)
|
||||
.ok_or_else(|| MapError::InvalidConfig("Left house door node not found".to_string()))?;
|
||||
.get(&(house_door[0].expect("First house door position not acquired") + Direction::Left.as_ivec2()))
|
||||
.expect("Left house door node not found");
|
||||
let right_node = grid_to_node
|
||||
.get(
|
||||
&(house_door[1]
|
||||
.ok_or_else(|| MapError::InvalidConfig("Second house door position not acquired".to_string()))?
|
||||
+ Direction::Right.as_ivec2()),
|
||||
)
|
||||
.ok_or_else(|| MapError::InvalidConfig("Right house door node not found".to_string()))?;
|
||||
.get(&(house_door[1].expect("Second house door position not acquired") + Direction::Right.as_ivec2()))
|
||||
.expect("Right house door node not found");
|
||||
|
||||
// Calculate the position of the house node
|
||||
let (node_id, node_position) = {
|
||||
let left_pos = graph.get_node(*left_node).ok_or(MapError::NodeNotFound(*left_node))?.position;
|
||||
let right_pos = graph
|
||||
.get_node(*right_node)
|
||||
.ok_or(MapError::NodeNotFound(*right_node))?
|
||||
.position;
|
||||
let left_pos = graph.get_node(*left_node).unwrap().position;
|
||||
let right_pos = graph.get_node(*right_node).unwrap().position;
|
||||
let house_node = graph.add_node(Node {
|
||||
position: left_pos.lerp(right_pos, 0.5),
|
||||
});
|
||||
@@ -254,16 +227,16 @@ impl Map {
|
||||
// Connect the house door to the left and right nodes
|
||||
graph
|
||||
.connect(node_id, *left_node, true, None, Direction::Left)
|
||||
.map_err(|e| MapError::InvalidConfig(format!("Failed to connect house door to left node: {e}")))?;
|
||||
.expect("Failed to connect house door to left node");
|
||||
graph
|
||||
.connect(node_id, *right_node, true, None, Direction::Right)
|
||||
.map_err(|e| MapError::InvalidConfig(format!("Failed to connect house door to right node: {e}")))?;
|
||||
.expect("Failed to connect house door to right node");
|
||||
|
||||
(node_id, node_position)
|
||||
};
|
||||
|
||||
// A helper function to help create the various 'lines' of nodes within the house
|
||||
let create_house_line = |graph: &mut Graph, center_pos: Vec2| -> GameResult<(NodeId, NodeId)> {
|
||||
let create_house_line = |graph: &mut Graph, center_pos: Vec2| -> (NodeId, NodeId) {
|
||||
// Place the nodes at, above, and below the center position
|
||||
let center_node_id = graph.add_node(Node { position: center_pos });
|
||||
let top_node_id = graph.add_node(Node {
|
||||
@@ -276,12 +249,12 @@ impl Map {
|
||||
// Connect the center node to the top and bottom nodes
|
||||
graph
|
||||
.connect(center_node_id, top_node_id, false, None, Direction::Up)
|
||||
.map_err(|e| MapError::InvalidConfig(format!("Failed to connect house line to top node: {e}")))?;
|
||||
.expect("Failed to connect house line to left node");
|
||||
graph
|
||||
.connect(center_node_id, bottom_node_id, false, None, Direction::Down)
|
||||
.map_err(|e| MapError::InvalidConfig(format!("Failed to connect house line to bottom node: {e}")))?;
|
||||
.expect("Failed to connect house line to right node");
|
||||
|
||||
Ok((center_node_id, top_node_id))
|
||||
(center_node_id, top_node_id)
|
||||
};
|
||||
|
||||
// Calculate the position of the center line's center node
|
||||
@@ -289,7 +262,7 @@ impl Map {
|
||||
house_entrance_node_position + (Direction::Down.as_ivec2() * (3 * CELL_SIZE as i32)).as_vec2();
|
||||
|
||||
// Create the center line
|
||||
let (center_center_node_id, center_top_node_id) = create_house_line(graph, center_line_center_position)?;
|
||||
let (center_center_node_id, center_top_node_id) = create_house_line(graph, center_line_center_position);
|
||||
|
||||
// Create a ghost-only, two-way connection for the house door.
|
||||
// This prevents Pac-Man from entering or exiting through the door.
|
||||
@@ -302,7 +275,7 @@ impl Map {
|
||||
Direction::Down,
|
||||
EdgePermissions::GhostsOnly,
|
||||
)
|
||||
.map_err(|e| MapError::InvalidConfig(format!("Failed to create ghost-only entrance to house: {e}")))?;
|
||||
.expect("Failed to create ghost-only entrance to house");
|
||||
|
||||
graph
|
||||
.add_edge(
|
||||
@@ -313,57 +286,52 @@ impl Map {
|
||||
Direction::Up,
|
||||
EdgePermissions::GhostsOnly,
|
||||
)
|
||||
.map_err(|e| MapError::InvalidConfig(format!("Failed to create ghost-only exit from house: {e}")))?;
|
||||
.expect("Failed to create ghost-only exit from house");
|
||||
|
||||
// Create the left line
|
||||
let (left_center_node_id, _) = create_house_line(
|
||||
graph,
|
||||
center_line_center_position + (Direction::Left.as_ivec2() * (CELL_SIZE as i32 * 2)).as_vec2(),
|
||||
)?;
|
||||
);
|
||||
|
||||
// Create the right line
|
||||
let (right_center_node_id, _) = create_house_line(
|
||||
graph,
|
||||
center_line_center_position + (Direction::Right.as_ivec2() * (CELL_SIZE as i32 * 2)).as_vec2(),
|
||||
)?;
|
||||
);
|
||||
|
||||
debug!("Left center node id: {left_center_node_id}");
|
||||
|
||||
// Connect the center line to the left and right lines
|
||||
graph
|
||||
.connect(center_center_node_id, left_center_node_id, false, None, Direction::Left)
|
||||
.map_err(|e| MapError::InvalidConfig(format!("Failed to connect house entrance to left top line: {e}")))?;
|
||||
.expect("Failed to connect house entrance to left top line");
|
||||
|
||||
graph
|
||||
.connect(center_center_node_id, right_center_node_id, false, None, Direction::Right)
|
||||
.map_err(|e| MapError::InvalidConfig(format!("Failed to connect house entrance to right top line: {e}")))?;
|
||||
.expect("Failed to connect house entrance to right top line");
|
||||
|
||||
debug!("House entrance node id: {house_entrance_node_id}");
|
||||
|
||||
Ok((
|
||||
(
|
||||
house_entrance_node_id,
|
||||
left_center_node_id,
|
||||
center_center_node_id,
|
||||
right_center_node_id,
|
||||
))
|
||||
)
|
||||
}
|
||||
|
||||
/// Builds the tunnel connections in the graph.
|
||||
fn build_tunnels(
|
||||
graph: &mut Graph,
|
||||
grid_to_node: &HashMap<IVec2, NodeId>,
|
||||
tunnel_ends: &[Option<IVec2>; 2],
|
||||
) -> GameResult<()> {
|
||||
fn build_tunnels(graph: &mut Graph, grid_to_node: &HashMap<IVec2, NodeId>, tunnel_ends: &[Option<IVec2>; 2]) {
|
||||
// Create the hidden tunnel nodes
|
||||
let left_tunnel_hidden_node_id = {
|
||||
let left_tunnel_entrance_node_id =
|
||||
grid_to_node[&tunnel_ends[0].ok_or_else(|| MapError::InvalidConfig("Left tunnel end not found".to_string()))?];
|
||||
let left_tunnel_entrance_node_id = grid_to_node[&tunnel_ends[0].expect("Left tunnel end not found")];
|
||||
let left_tunnel_entrance_node = graph
|
||||
.get_node(left_tunnel_entrance_node_id)
|
||||
.ok_or_else(|| MapError::InvalidConfig("Left tunnel entrance node not found".to_string()))?;
|
||||
.expect("Left tunnel entrance node not found");
|
||||
|
||||
graph
|
||||
.add_connected(
|
||||
.connect_node(
|
||||
left_tunnel_entrance_node_id,
|
||||
Direction::Left,
|
||||
Node {
|
||||
@@ -371,24 +339,18 @@ impl Map {
|
||||
+ (Direction::Left.as_ivec2() * (CELL_SIZE as i32 * 2)).as_vec2(),
|
||||
},
|
||||
)
|
||||
.map_err(|e| {
|
||||
MapError::InvalidConfig(format!(
|
||||
"Failed to connect left tunnel entrance to left tunnel hidden node: {}",
|
||||
e
|
||||
))
|
||||
})?
|
||||
.expect("Failed to connect left tunnel entrance to left tunnel hidden node")
|
||||
};
|
||||
|
||||
// Create the right tunnel nodes
|
||||
let right_tunnel_hidden_node_id = {
|
||||
let right_tunnel_entrance_node_id =
|
||||
grid_to_node[&tunnel_ends[1].ok_or_else(|| MapError::InvalidConfig("Right tunnel end not found".to_string()))?];
|
||||
let right_tunnel_entrance_node_id = grid_to_node[&tunnel_ends[1].expect("Right tunnel end not found")];
|
||||
let right_tunnel_entrance_node = graph
|
||||
.get_node(right_tunnel_entrance_node_id)
|
||||
.ok_or_else(|| MapError::InvalidConfig("Right tunnel entrance node not found".to_string()))?;
|
||||
.expect("Right tunnel entrance node not found");
|
||||
|
||||
graph
|
||||
.add_connected(
|
||||
.connect_node(
|
||||
right_tunnel_entrance_node_id,
|
||||
Direction::Right,
|
||||
Node {
|
||||
@@ -396,12 +358,7 @@ impl Map {
|
||||
+ (Direction::Right.as_ivec2() * (CELL_SIZE as i32 * 2)).as_vec2(),
|
||||
},
|
||||
)
|
||||
.map_err(|e| {
|
||||
MapError::InvalidConfig(format!(
|
||||
"Failed to connect right tunnel entrance to right tunnel hidden node: {}",
|
||||
e
|
||||
))
|
||||
})?
|
||||
.expect("Failed to connect right tunnel entrance to right tunnel hidden node")
|
||||
};
|
||||
|
||||
// Connect the left tunnel hidden node to the right tunnel hidden node
|
||||
@@ -413,13 +370,6 @@ impl Map {
|
||||
Some(0.0),
|
||||
Direction::Left,
|
||||
)
|
||||
.map_err(|e| {
|
||||
MapError::InvalidConfig(format!(
|
||||
"Failed to connect left tunnel hidden node to right tunnel hidden node: {}",
|
||||
e
|
||||
))
|
||||
})?;
|
||||
|
||||
Ok(())
|
||||
.expect("Failed to connect left tunnel hidden node to right tunnel hidden node");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,8 +1,17 @@
|
||||
//! Map parsing functionality for converting raw board layouts into structured data.
|
||||
|
||||
use crate::constants::{MapTile, BOARD_CELL_SIZE};
|
||||
use crate::error::ParseError;
|
||||
use glam::IVec2;
|
||||
use thiserror::Error;
|
||||
|
||||
/// Error type for map parsing operations.
|
||||
#[derive(Debug, Error)]
|
||||
pub enum ParseError {
|
||||
#[error("Unknown character in board: {0}")]
|
||||
UnknownCharacter(char),
|
||||
#[error("House door must have exactly 2 positions, found {0}")]
|
||||
InvalidHouseDoorCount(usize),
|
||||
}
|
||||
|
||||
/// Represents the parsed data from a raw board layout.
|
||||
#[derive(Debug)]
|
||||
@@ -58,25 +67,6 @@ impl MapTileParser {
|
||||
/// Returns an error if the board contains unknown characters or if the house door
|
||||
/// is not properly defined by exactly two '=' characters.
|
||||
pub fn parse_board(raw_board: [&str; BOARD_CELL_SIZE.y as usize]) -> Result<ParsedMap, ParseError> {
|
||||
// Validate board dimensions
|
||||
if raw_board.len() != BOARD_CELL_SIZE.y as usize {
|
||||
return Err(ParseError::ParseFailed(format!(
|
||||
"Invalid board height: expected {}, got {}",
|
||||
BOARD_CELL_SIZE.y,
|
||||
raw_board.len()
|
||||
)));
|
||||
}
|
||||
|
||||
for (i, line) in raw_board.iter().enumerate() {
|
||||
if line.len() != BOARD_CELL_SIZE.x as usize {
|
||||
return Err(ParseError::ParseFailed(format!(
|
||||
"Invalid board width at line {}: expected {}, got {}",
|
||||
i,
|
||||
BOARD_CELL_SIZE.x,
|
||||
line.len()
|
||||
)));
|
||||
}
|
||||
}
|
||||
let mut tiles = [[MapTile::Empty; BOARD_CELL_SIZE.y as usize]; BOARD_CELL_SIZE.x as usize];
|
||||
let mut house_door = [None; 2];
|
||||
let mut tunnel_ends = [None; 2];
|
||||
|
||||
@@ -7,8 +7,6 @@ use sdl2::pixels::Color;
|
||||
use sdl2::rect::{Point, Rect};
|
||||
use sdl2::render::{Canvas, RenderTarget};
|
||||
|
||||
use crate::error::{EntityError, GameError, GameResult};
|
||||
|
||||
/// Handles rendering operations for the map.
|
||||
pub struct MapRenderer;
|
||||
|
||||
@@ -24,9 +22,7 @@ impl MapRenderer {
|
||||
crate::constants::BOARD_PIXEL_SIZE.x,
|
||||
crate::constants::BOARD_PIXEL_SIZE.y,
|
||||
);
|
||||
if let Err(e) = map_texture.render(canvas, atlas, dest) {
|
||||
tracing::error!("Failed to render map: {}", e);
|
||||
}
|
||||
let _ = map_texture.render(canvas, atlas, dest);
|
||||
}
|
||||
|
||||
/// Renders a debug visualization with cursor-based highlighting.
|
||||
@@ -39,67 +35,55 @@ impl MapRenderer {
|
||||
text_renderer: &mut TextTexture,
|
||||
atlas: &mut SpriteAtlas,
|
||||
cursor_pos: Vec2,
|
||||
) -> GameResult<()> {
|
||||
) {
|
||||
// Find the nearest node to the cursor
|
||||
let nearest_node = Self::find_nearest_node(graph, cursor_pos);
|
||||
|
||||
// Draw all connections in blue
|
||||
canvas.set_draw_color(Color::RGB(0, 0, 128)); // Dark blue for regular connections
|
||||
for i in 0..graph.node_count() {
|
||||
let node = graph.get_node(i).ok_or(GameError::Entity(EntityError::NodeNotFound(i)))?;
|
||||
let node = graph.get_node(i).unwrap();
|
||||
let pos = node.position + crate::constants::BOARD_PIXEL_OFFSET.as_vec2();
|
||||
|
||||
for edge in graph.adjacency_list[i].edges() {
|
||||
let end_pos = graph
|
||||
.get_node(edge.target)
|
||||
.ok_or(GameError::Entity(EntityError::NodeNotFound(edge.target)))?
|
||||
.position
|
||||
+ crate::constants::BOARD_PIXEL_OFFSET.as_vec2();
|
||||
let end_pos = graph.get_node(edge.target).unwrap().position + crate::constants::BOARD_PIXEL_OFFSET.as_vec2();
|
||||
canvas
|
||||
.draw_line((pos.x as i32, pos.y as i32), (end_pos.x as i32, end_pos.y as i32))
|
||||
.map_err(|e| GameError::Sdl(e.to_string()))?;
|
||||
.unwrap();
|
||||
}
|
||||
}
|
||||
|
||||
// Draw all nodes in green
|
||||
canvas.set_draw_color(Color::RGB(0, 128, 0)); // Dark green for regular nodes
|
||||
for i in 0..graph.node_count() {
|
||||
let node = graph.get_node(i).ok_or(GameError::Entity(EntityError::NodeNotFound(i)))?;
|
||||
let node = graph.get_node(i).unwrap();
|
||||
let pos = node.position + crate::constants::BOARD_PIXEL_OFFSET.as_vec2();
|
||||
|
||||
canvas
|
||||
.fill_rect(Rect::new(0, 0, 3, 3).centered_on(Point::new(pos.x as i32, pos.y as i32)))
|
||||
.map_err(|e| GameError::Sdl(e.to_string()))?;
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
// Highlight connections from the nearest node in bright blue
|
||||
if let Some(nearest_id) = nearest_node {
|
||||
let nearest_pos = graph
|
||||
.get_node(nearest_id)
|
||||
.ok_or(GameError::Entity(EntityError::NodeNotFound(nearest_id)))?
|
||||
.position
|
||||
+ crate::constants::BOARD_PIXEL_OFFSET.as_vec2();
|
||||
let nearest_pos = graph.get_node(nearest_id).unwrap().position + crate::constants::BOARD_PIXEL_OFFSET.as_vec2();
|
||||
|
||||
canvas.set_draw_color(Color::RGB(0, 255, 255)); // Bright cyan for highlighted connections
|
||||
for edge in graph.adjacency_list[nearest_id].edges() {
|
||||
let end_pos = graph
|
||||
.get_node(edge.target)
|
||||
.ok_or(GameError::Entity(EntityError::NodeNotFound(edge.target)))?
|
||||
.position
|
||||
+ crate::constants::BOARD_PIXEL_OFFSET.as_vec2();
|
||||
let end_pos = graph.get_node(edge.target).unwrap().position + crate::constants::BOARD_PIXEL_OFFSET.as_vec2();
|
||||
canvas
|
||||
.draw_line(
|
||||
(nearest_pos.x as i32, nearest_pos.y as i32),
|
||||
(end_pos.x as i32, end_pos.y as i32),
|
||||
)
|
||||
.map_err(|e| GameError::Sdl(e.to_string()))?;
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
// Highlight the nearest node in bright green
|
||||
canvas.set_draw_color(Color::RGB(0, 255, 0)); // Bright green for highlighted node
|
||||
canvas
|
||||
.fill_rect(Rect::new(0, 0, 5, 5).centered_on(Point::new(nearest_pos.x as i32, nearest_pos.y as i32)))
|
||||
.map_err(|e| GameError::Sdl(e.to_string()))?;
|
||||
.unwrap();
|
||||
|
||||
// Draw node ID text (small, offset to top right)
|
||||
text_renderer.set_scale(0.5); // Small text
|
||||
@@ -108,21 +92,17 @@ impl MapRenderer {
|
||||
(nearest_pos.x + 4.0) as u32, // Offset to the right
|
||||
(nearest_pos.y - 6.0) as u32, // Offset to the top
|
||||
);
|
||||
if let Err(e) = text_renderer.render(canvas, atlas, &id_text, text_pos) {
|
||||
tracing::error!("Failed to render node ID text: {}", e);
|
||||
let _ = text_renderer.render(canvas, atlas, &id_text, text_pos);
|
||||
}
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Finds the nearest node to the given cursor position.
|
||||
pub fn find_nearest_node(graph: &crate::entity::graph::Graph, cursor_pos: Vec2) -> Option<usize> {
|
||||
let mut nearest_id = None;
|
||||
let mut nearest_distance = f32::INFINITY;
|
||||
|
||||
for i in 0..graph.node_count() {
|
||||
if let Some(node) = graph.get_node(i) {
|
||||
let node = graph.get_node(i).unwrap();
|
||||
let node_pos = node.position + crate::constants::BOARD_PIXEL_OFFSET.as_vec2();
|
||||
let distance = cursor_pos.distance(node_pos);
|
||||
|
||||
@@ -131,7 +111,6 @@ impl MapRenderer {
|
||||
nearest_id = Some(i);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
nearest_id
|
||||
}
|
||||
|
||||
@@ -3,9 +3,8 @@
|
||||
use std::borrow::Cow;
|
||||
use std::time::Duration;
|
||||
|
||||
use crate::asset::Asset;
|
||||
use crate::error::{AssetError, PlatformError};
|
||||
use crate::platform::Platform;
|
||||
use crate::asset::{Asset, AssetError};
|
||||
use crate::platform::{Platform, PlatformError};
|
||||
|
||||
/// Desktop platform implementation.
|
||||
pub struct DesktopPlatform;
|
||||
|
||||
@@ -3,9 +3,8 @@
|
||||
use std::borrow::Cow;
|
||||
use std::time::Duration;
|
||||
|
||||
use crate::asset::Asset;
|
||||
use crate::error::{AssetError, PlatformError};
|
||||
use crate::platform::Platform;
|
||||
use crate::asset::{Asset, AssetError};
|
||||
use crate::platform::{Platform, PlatformError};
|
||||
|
||||
/// Emscripten platform implementation.
|
||||
pub struct EmscriptenPlatform;
|
||||
|
||||
@@ -1,10 +1,10 @@
|
||||
//! Platform abstraction layer for cross-platform functionality.
|
||||
|
||||
use crate::asset::Asset;
|
||||
use crate::error::{AssetError, PlatformError};
|
||||
use std::borrow::Cow;
|
||||
use std::time::Duration;
|
||||
|
||||
use crate::asset::{Asset, AssetError};
|
||||
|
||||
pub mod desktop;
|
||||
pub mod emscripten;
|
||||
|
||||
@@ -30,6 +30,16 @@ pub trait Platform {
|
||||
fn get_asset_bytes(&self, asset: Asset) -> Result<Cow<'static, [u8]>, AssetError>;
|
||||
}
|
||||
|
||||
/// Platform-specific errors.
|
||||
#[derive(Debug, thiserror::Error)]
|
||||
#[allow(dead_code)]
|
||||
pub enum PlatformError {
|
||||
#[error("Console initialization failed: {0}")]
|
||||
ConsoleInit(String),
|
||||
#[error("Platform-specific error: {0}")]
|
||||
Other(String),
|
||||
}
|
||||
|
||||
/// Get the current platform implementation.
|
||||
#[allow(dead_code)]
|
||||
pub fn get_platform() -> &'static dyn Platform {
|
||||
|
||||
@@ -1,9 +1,16 @@
|
||||
use anyhow::Result;
|
||||
use sdl2::rect::Rect;
|
||||
use sdl2::render::{Canvas, RenderTarget};
|
||||
use thiserror::Error;
|
||||
|
||||
use crate::error::{AnimatedTextureError, GameError, GameResult, TextureError};
|
||||
use crate::texture::sprite::{AtlasTile, SpriteAtlas};
|
||||
|
||||
#[derive(Error, Debug)]
|
||||
pub enum AnimatedTextureError {
|
||||
#[error("Frame duration must be positive, got {0}")]
|
||||
InvalidFrameDuration(f32),
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct AnimatedTexture {
|
||||
tiles: Vec<AtlasTile>,
|
||||
@@ -13,11 +20,9 @@ pub struct AnimatedTexture {
|
||||
}
|
||||
|
||||
impl AnimatedTexture {
|
||||
pub fn new(tiles: Vec<AtlasTile>, frame_duration: f32) -> GameResult<Self> {
|
||||
pub fn new(tiles: Vec<AtlasTile>, frame_duration: f32) -> Result<Self, AnimatedTextureError> {
|
||||
if frame_duration <= 0.0 {
|
||||
return Err(GameError::Texture(TextureError::Animated(
|
||||
AnimatedTextureError::InvalidFrameDuration(frame_duration),
|
||||
)));
|
||||
return Err(AnimatedTextureError::InvalidFrameDuration(frame_duration));
|
||||
}
|
||||
|
||||
Ok(Self {
|
||||
@@ -40,10 +45,9 @@ impl AnimatedTexture {
|
||||
&self.tiles[self.current_frame]
|
||||
}
|
||||
|
||||
pub fn render<T: RenderTarget>(&self, canvas: &mut Canvas<T>, atlas: &mut SpriteAtlas, dest: Rect) -> GameResult<()> {
|
||||
pub fn render<T: RenderTarget>(&self, canvas: &mut Canvas<T>, atlas: &mut SpriteAtlas, dest: Rect) -> Result<()> {
|
||||
let mut tile = *self.current_tile();
|
||||
tile.render(canvas, atlas, dest)?;
|
||||
Ok(())
|
||||
tile.render(canvas, atlas, dest)
|
||||
}
|
||||
|
||||
/// Returns the current frame index.
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
use anyhow::Result;
|
||||
use sdl2::rect::Rect;
|
||||
use sdl2::render::{Canvas, RenderTarget};
|
||||
|
||||
use crate::entity::direction::Direction;
|
||||
use crate::error::GameResult;
|
||||
use crate::texture::animated::AnimatedTexture;
|
||||
use crate::texture::sprite::SpriteAtlas;
|
||||
|
||||
@@ -32,7 +32,7 @@ impl DirectionalAnimatedTexture {
|
||||
atlas: &mut SpriteAtlas,
|
||||
dest: Rect,
|
||||
direction: Direction,
|
||||
) -> GameResult<()> {
|
||||
) -> Result<()> {
|
||||
if let Some(texture) = &self.textures[direction.as_usize()] {
|
||||
texture.render(canvas, atlas, dest)
|
||||
} else {
|
||||
@@ -46,7 +46,7 @@ impl DirectionalAnimatedTexture {
|
||||
atlas: &mut SpriteAtlas,
|
||||
dest: Rect,
|
||||
direction: Direction,
|
||||
) -> GameResult<()> {
|
||||
) -> Result<()> {
|
||||
if let Some(texture) = &self.stopped_textures[direction.as_usize()] {
|
||||
texture.render(canvas, atlas, dest)
|
||||
} else {
|
||||
|
||||
@@ -6,35 +6,6 @@ use sdl2::render::{Canvas, RenderTarget, Texture};
|
||||
use serde::Deserialize;
|
||||
use std::collections::HashMap;
|
||||
|
||||
use crate::error::TextureError;
|
||||
|
||||
/// A simple sprite for stationary items like pellets and energizers.
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct Sprite {
|
||||
pub atlas_tile: AtlasTile,
|
||||
}
|
||||
|
||||
impl Sprite {
|
||||
pub fn new(atlas_tile: AtlasTile) -> Self {
|
||||
Self { atlas_tile }
|
||||
}
|
||||
|
||||
pub fn render<C: RenderTarget>(
|
||||
&self,
|
||||
canvas: &mut Canvas<C>,
|
||||
atlas: &mut SpriteAtlas,
|
||||
position: glam::Vec2,
|
||||
) -> Result<(), TextureError> {
|
||||
let dest = crate::helpers::centered_with_size(
|
||||
glam::IVec2::new(position.x as i32, position.y as i32),
|
||||
glam::UVec2::new(self.atlas_tile.size.x as u32, self.atlas_tile.size.y as u32),
|
||||
);
|
||||
let mut tile = self.atlas_tile;
|
||||
tile.render(canvas, atlas, dest)?;
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Deserialize)]
|
||||
pub struct AtlasMapper {
|
||||
pub frames: HashMap<String, MapperFrame>,
|
||||
@@ -56,15 +27,9 @@ pub struct AtlasTile {
|
||||
}
|
||||
|
||||
impl AtlasTile {
|
||||
pub fn render<C: RenderTarget>(
|
||||
&mut self,
|
||||
canvas: &mut Canvas<C>,
|
||||
atlas: &mut SpriteAtlas,
|
||||
dest: Rect,
|
||||
) -> Result<(), TextureError> {
|
||||
pub fn render<C: RenderTarget>(&mut self, canvas: &mut Canvas<C>, atlas: &mut SpriteAtlas, dest: Rect) -> Result<()> {
|
||||
let color = self.color.unwrap_or(atlas.default_color.unwrap_or(Color::WHITE));
|
||||
self.render_with_color(canvas, atlas, dest, color)?;
|
||||
Ok(())
|
||||
self.render_with_color(canvas, atlas, dest, color)
|
||||
}
|
||||
|
||||
pub fn render_with_color<C: RenderTarget>(
|
||||
@@ -73,7 +38,7 @@ impl AtlasTile {
|
||||
atlas: &mut SpriteAtlas,
|
||||
dest: Rect,
|
||||
color: Color,
|
||||
) -> Result<(), TextureError> {
|
||||
) -> Result<()> {
|
||||
let src = Rect::new(self.pos.x as i32, self.pos.y as i32, self.size.x as u32, self.size.y as u32);
|
||||
|
||||
if atlas.last_modulation != Some(color) {
|
||||
@@ -81,7 +46,7 @@ impl AtlasTile {
|
||||
atlas.last_modulation = Some(color);
|
||||
}
|
||||
|
||||
canvas.copy(&atlas.texture, src, dest).map_err(TextureError::RenderFailed)?;
|
||||
canvas.copy(&atlas.texture, src, dest).map_err(anyhow::Error::msg)?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -152,3 +117,20 @@ impl SpriteAtlas {
|
||||
self.default_color
|
||||
}
|
||||
}
|
||||
|
||||
/// Converts a `Texture` to a `Texture<'static>` using transmute.
|
||||
///
|
||||
/// # Safety
|
||||
///
|
||||
/// This function is unsafe because it uses `std::mem::transmute` to change the lifetime
|
||||
/// of the texture from the original lifetime to `'static`. The caller must ensure that:
|
||||
///
|
||||
/// - The original `Texture` will live for the entire duration of the program
|
||||
/// - No references to the original texture exist that could become invalid
|
||||
/// - The texture is not dropped while still being used as a `'static` reference
|
||||
///
|
||||
/// This is typically used when you have a texture that you know will live for the entire
|
||||
/// program duration and need to store it in a structure that requires a `'static` lifetime.
|
||||
pub unsafe fn texture_to_static(texture: Texture) -> Texture<'static> {
|
||||
std::mem::transmute(texture)
|
||||
}
|
||||
|
||||
@@ -1,6 +1,5 @@
|
||||
use glam::U16Vec2;
|
||||
use pacman::error::{AnimatedTextureError, GameError, TextureError};
|
||||
use pacman::texture::animated::AnimatedTexture;
|
||||
use pacman::texture::animated::{AnimatedTexture, AnimatedTextureError};
|
||||
use pacman::texture::sprite::AtlasTile;
|
||||
use sdl2::pixels::Color;
|
||||
|
||||
@@ -18,12 +17,12 @@ fn test_animated_texture_creation_errors() {
|
||||
|
||||
assert!(matches!(
|
||||
AnimatedTexture::new(tiles.clone(), 0.0).unwrap_err(),
|
||||
GameError::Texture(TextureError::Animated(AnimatedTextureError::InvalidFrameDuration(0.0)))
|
||||
AnimatedTextureError::InvalidFrameDuration(0.0)
|
||||
));
|
||||
|
||||
assert!(matches!(
|
||||
AnimatedTexture::new(tiles, -0.1).unwrap_err(),
|
||||
GameError::Texture(TextureError::Animated(AnimatedTextureError::InvalidFrameDuration(-0.1)))
|
||||
AnimatedTextureError::InvalidFrameDuration(-0.1)
|
||||
));
|
||||
}
|
||||
|
||||
|
||||
@@ -16,16 +16,16 @@ fn test_blinking_texture() {
|
||||
let tile = mock_atlas_tile(1);
|
||||
let mut texture = BlinkingTexture::new(tile, 0.5);
|
||||
|
||||
assert!(texture.is_on());
|
||||
assert_eq!(texture.is_on(), true);
|
||||
|
||||
texture.tick(0.5);
|
||||
assert!(!texture.is_on());
|
||||
assert_eq!(texture.is_on(), false);
|
||||
|
||||
texture.tick(0.5);
|
||||
assert!(texture.is_on());
|
||||
assert_eq!(texture.is_on(), true);
|
||||
|
||||
texture.tick(0.5);
|
||||
assert!(!texture.is_on());
|
||||
assert_eq!(texture.is_on(), false);
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -34,7 +34,7 @@ fn test_blinking_texture_partial_duration() {
|
||||
let mut texture = BlinkingTexture::new(tile, 0.5);
|
||||
|
||||
texture.tick(0.625);
|
||||
assert!(!texture.is_on());
|
||||
assert_eq!(texture.is_on(), false);
|
||||
assert_eq!(texture.time_bank(), 0.125);
|
||||
}
|
||||
|
||||
@@ -44,6 +44,6 @@ fn test_blinking_texture_negative_time() {
|
||||
let mut texture = BlinkingTexture::new(tile, 0.5);
|
||||
|
||||
texture.tick(-0.1);
|
||||
assert!(texture.is_on());
|
||||
assert_eq!(texture.is_on(), true);
|
||||
assert_eq!(texture.time_bank(), -0.1);
|
||||
}
|
||||
|
||||
@@ -1,119 +0,0 @@
|
||||
use pacman::entity::collision::{Collidable, CollisionSystem};
|
||||
use pacman::entity::traversal::Position;
|
||||
|
||||
struct MockCollidable {
|
||||
pos: Position,
|
||||
}
|
||||
|
||||
impl Collidable for MockCollidable {
|
||||
fn position(&self) -> Position {
|
||||
self.pos
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_is_colliding_with() {
|
||||
let entity1 = MockCollidable {
|
||||
pos: Position::AtNode(1),
|
||||
};
|
||||
let entity2 = MockCollidable {
|
||||
pos: Position::AtNode(1),
|
||||
};
|
||||
let entity3 = MockCollidable {
|
||||
pos: Position::AtNode(2),
|
||||
};
|
||||
let entity4 = MockCollidable {
|
||||
pos: Position::BetweenNodes {
|
||||
from: 1,
|
||||
to: 2,
|
||||
traversed: 0.5,
|
||||
},
|
||||
};
|
||||
|
||||
assert!(entity1.is_colliding_with(&entity2));
|
||||
assert!(!entity1.is_colliding_with(&entity3));
|
||||
assert!(entity1.is_colliding_with(&entity4));
|
||||
assert!(entity3.is_colliding_with(&entity4));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_collision_system_register_and_query() {
|
||||
let mut collision_system = CollisionSystem::default();
|
||||
|
||||
let pos1 = Position::AtNode(1);
|
||||
let entity1 = collision_system.register_entity(pos1);
|
||||
|
||||
let pos2 = Position::BetweenNodes {
|
||||
from: 1,
|
||||
to: 2,
|
||||
traversed: 0.5,
|
||||
};
|
||||
let entity2 = collision_system.register_entity(pos2);
|
||||
|
||||
let pos3 = Position::AtNode(3);
|
||||
let entity3 = collision_system.register_entity(pos3);
|
||||
|
||||
// Test entities_at_node
|
||||
assert_eq!(collision_system.entities_at_node(1), &[entity1, entity2]);
|
||||
assert_eq!(collision_system.entities_at_node(2), &[entity2]);
|
||||
assert_eq!(collision_system.entities_at_node(3), &[entity3]);
|
||||
assert_eq!(collision_system.entities_at_node(4), &[] as &[u32]);
|
||||
|
||||
// Test potential_collisions
|
||||
let mut collisions1 = collision_system.potential_collisions(&pos1);
|
||||
collisions1.sort_unstable();
|
||||
assert_eq!(collisions1, vec![entity1, entity2]);
|
||||
|
||||
let mut collisions2 = collision_system.potential_collisions(&pos2);
|
||||
collisions2.sort_unstable();
|
||||
assert_eq!(collisions2, vec![entity1, entity2]);
|
||||
|
||||
let mut collisions3 = collision_system.potential_collisions(&pos3);
|
||||
collisions3.sort_unstable();
|
||||
assert_eq!(collisions3, vec![entity3]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_collision_system_update() {
|
||||
let mut collision_system = CollisionSystem::default();
|
||||
|
||||
let entity1 = collision_system.register_entity(Position::AtNode(1));
|
||||
|
||||
assert_eq!(collision_system.entities_at_node(1), &[entity1]);
|
||||
assert_eq!(collision_system.entities_at_node(2), &[] as &[u32]);
|
||||
|
||||
collision_system.update_position(entity1, Position::AtNode(2));
|
||||
|
||||
assert_eq!(collision_system.entities_at_node(1), &[] as &[u32]);
|
||||
assert_eq!(collision_system.entities_at_node(2), &[entity1]);
|
||||
|
||||
collision_system.update_position(
|
||||
entity1,
|
||||
Position::BetweenNodes {
|
||||
from: 2,
|
||||
to: 3,
|
||||
traversed: 0.1,
|
||||
},
|
||||
);
|
||||
|
||||
assert_eq!(collision_system.entities_at_node(1), &[] as &[u32]);
|
||||
assert_eq!(collision_system.entities_at_node(2), &[entity1]);
|
||||
assert_eq!(collision_system.entities_at_node(3), &[entity1]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_collision_system_remove() {
|
||||
let mut collision_system = CollisionSystem::default();
|
||||
|
||||
let entity1 = collision_system.register_entity(Position::AtNode(1));
|
||||
let entity2 = collision_system.register_entity(Position::AtNode(1));
|
||||
|
||||
assert_eq!(collision_system.entities_at_node(1), &[entity1, entity2]);
|
||||
|
||||
collision_system.remove_entity(entity1);
|
||||
|
||||
assert_eq!(collision_system.entities_at_node(1), &[entity2]);
|
||||
|
||||
collision_system.remove_entity(entity2);
|
||||
assert_eq!(collision_system.entities_at_node(1), &[] as &[u32]);
|
||||
}
|
||||
@@ -52,26 +52,3 @@ fn test_directional_texture_all_directions() {
|
||||
assert!(texture.has_direction(*direction));
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_directional_texture_stopped() {
|
||||
let mut stopped_textures = [None, None, None, None];
|
||||
stopped_textures[Direction::Up.as_usize()] = Some(mock_animated_texture(1));
|
||||
|
||||
let texture = DirectionalAnimatedTexture::new([None, None, None, None], stopped_textures);
|
||||
|
||||
assert_eq!(texture.stopped_texture_count(), 1);
|
||||
assert!(texture.has_stopped_direction(Direction::Up));
|
||||
assert!(!texture.has_stopped_direction(Direction::Down));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_directional_texture_tick() {
|
||||
let mut textures = [None, None, None, None];
|
||||
textures[Direction::Up.as_usize()] = Some(mock_animated_texture(1));
|
||||
let mut texture = DirectionalAnimatedTexture::new(textures, [None, None, None, None]);
|
||||
|
||||
// This is a bit of a placeholder, since we can't inspect the inner state easily.
|
||||
// We're just ensuring the tick method runs without panicking.
|
||||
texture.tick(0.1);
|
||||
}
|
||||
|
||||
@@ -1,13 +1,21 @@
|
||||
use pacman::constants::RAW_BOARD;
|
||||
use pacman::map::Map;
|
||||
|
||||
mod collision;
|
||||
mod item;
|
||||
|
||||
#[test]
|
||||
fn test_game_map_creation() {
|
||||
let map = Map::new(RAW_BOARD).unwrap();
|
||||
let map = Map::new(RAW_BOARD);
|
||||
|
||||
assert!(map.graph.node_count() > 0);
|
||||
assert!(!map.grid_to_node.is_empty());
|
||||
|
||||
// Should find Pac-Man's starting position
|
||||
let pacman_pos = map.find_starting_position(0);
|
||||
assert!(pacman_pos.is_some());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_game_score_initialization() {
|
||||
// This would require creating a full Game instance, but we can test the concept
|
||||
let map = Map::new(RAW_BOARD);
|
||||
assert!(map.find_starting_position(0).is_some());
|
||||
}
|
||||
|
||||
@@ -41,7 +41,7 @@ fn test_ghost_creation() {
|
||||
let graph = Graph::new();
|
||||
let atlas = create_test_atlas();
|
||||
|
||||
let ghost = Ghost::new(&graph, 0, GhostType::Blinky, &atlas).unwrap();
|
||||
let ghost = Ghost::new(&graph, 0, GhostType::Blinky, &atlas);
|
||||
|
||||
assert_eq!(ghost.ghost_type, GhostType::Blinky);
|
||||
assert_eq!(ghost.traverser.position.from_node_id(), 0);
|
||||
|
||||
@@ -1,6 +1,5 @@
|
||||
use pacman::entity::direction::Direction;
|
||||
use pacman::entity::graph::{EdgePermissions, Graph, Node};
|
||||
use pacman::entity::traversal::{Position, Traverser};
|
||||
use pacman::entity::graph::{EdgePermissions, Graph, Node, Position, Traverser};
|
||||
|
||||
fn create_test_graph() -> Graph {
|
||||
let mut graph = Graph::new();
|
||||
@@ -101,7 +100,7 @@ fn test_traverser_advance() {
|
||||
let graph = create_test_graph();
|
||||
let mut traverser = Traverser::new(&graph, 0, Direction::Right, &|_| true);
|
||||
|
||||
traverser.advance(&graph, 5.0, &|_| true).unwrap();
|
||||
traverser.advance(&graph, 5.0, &|_| true);
|
||||
|
||||
match traverser.position {
|
||||
Position::BetweenNodes { from, to, traversed } => {
|
||||
@@ -112,7 +111,7 @@ fn test_traverser_advance() {
|
||||
_ => panic!("Expected to be between nodes"),
|
||||
}
|
||||
|
||||
traverser.advance(&graph, 3.0, &|_| true).unwrap();
|
||||
traverser.advance(&graph, 3.0, &|_| true);
|
||||
|
||||
match traverser.position {
|
||||
Position::BetweenNodes { from, to, traversed } => {
|
||||
@@ -143,9 +142,7 @@ fn test_traverser_with_permissions() {
|
||||
matches!(edge.permissions, EdgePermissions::All)
|
||||
});
|
||||
|
||||
traverser
|
||||
.advance(&graph, 5.0, &|edge| matches!(edge.permissions, EdgePermissions::All))
|
||||
.unwrap();
|
||||
traverser.advance(&graph, 5.0, &|edge| matches!(edge.permissions, EdgePermissions::All));
|
||||
|
||||
// Should still be at the node since it can't traverse
|
||||
assert!(traverser.position.is_at_node());
|
||||
|
||||
@@ -1,53 +0,0 @@
|
||||
use glam::U16Vec2;
|
||||
use pacman::{
|
||||
entity::{
|
||||
collision::Collidable,
|
||||
item::{FruitKind, Item, ItemType},
|
||||
},
|
||||
texture::sprite::{AtlasTile, Sprite},
|
||||
};
|
||||
use strum::{EnumCount, IntoEnumIterator};
|
||||
|
||||
#[test]
|
||||
fn test_item_type_get_score() {
|
||||
assert_eq!(ItemType::Pellet.get_score(), 10);
|
||||
assert_eq!(ItemType::Energizer.get_score(), 50);
|
||||
|
||||
let fruit = ItemType::Fruit { kind: FruitKind::Apple };
|
||||
assert_eq!(fruit.get_score(), 100);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_fruit_kind_increasing_score() {
|
||||
// Build a list of fruit kinds, sorted by their index
|
||||
let mut kinds = FruitKind::iter()
|
||||
.map(|kind| (kind.index(), kind.get_score()))
|
||||
.collect::<Vec<_>>();
|
||||
kinds.sort_unstable_by_key(|(index, _)| *index);
|
||||
|
||||
assert_eq!(kinds.len(), FruitKind::COUNT);
|
||||
|
||||
// Check that the score increases as expected
|
||||
for window in kinds.windows(2) {
|
||||
let ((_, prev), (_, next)) = (window[0], window[1]);
|
||||
assert!(prev < next, "Fruits should have increasing scores, but {prev:?} < {next:?}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_item_creation_and_collection() {
|
||||
let atlas_tile = AtlasTile {
|
||||
pos: U16Vec2::new(0, 0),
|
||||
size: U16Vec2::new(16, 16),
|
||||
color: None,
|
||||
};
|
||||
let sprite = Sprite::new(atlas_tile);
|
||||
let mut item = Item::new(0, ItemType::Pellet, sprite);
|
||||
|
||||
assert!(!item.is_collected());
|
||||
assert_eq!(item.get_score(), 10);
|
||||
assert_eq!(item.position().from_node_id(), 0);
|
||||
|
||||
item.collect();
|
||||
assert!(item.is_collected());
|
||||
}
|
||||
@@ -1,11 +1,47 @@
|
||||
use glam::Vec2;
|
||||
use pacman::constants::{CELL_SIZE, RAW_BOARD};
|
||||
use pacman::constants::{BOARD_CELL_SIZE, CELL_SIZE};
|
||||
use pacman::map::Map;
|
||||
use sdl2::render::Texture;
|
||||
|
||||
fn create_minimal_test_board() -> [&'static str; BOARD_CELL_SIZE.y as usize] {
|
||||
let mut board = [""; BOARD_CELL_SIZE.y as usize];
|
||||
board[0] = "############################";
|
||||
board[1] = "#............##............#";
|
||||
board[2] = "#.####.#####.##.#####.####.#";
|
||||
board[3] = "#o####.#####.##.#####.####o#";
|
||||
board[4] = "#.####.#####.##.#####.####.#";
|
||||
board[5] = "#..........................#";
|
||||
board[6] = "#.####.##.########.##.####.#";
|
||||
board[7] = "#.####.##.########.##.####.#";
|
||||
board[8] = "#......##....##....##......#";
|
||||
board[9] = "######.##### ## #####.######";
|
||||
board[10] = " #.##### ## #####.# ";
|
||||
board[11] = " #.## == ##.# ";
|
||||
board[12] = " #.## ######## ##.# ";
|
||||
board[13] = "######.## ######## ##.######";
|
||||
board[14] = "T . ######## . T";
|
||||
board[15] = "######.## ######## ##.######";
|
||||
board[16] = " #.## ######## ##.# ";
|
||||
board[17] = " #.## ##.# ";
|
||||
board[18] = " #.## ######## ##.# ";
|
||||
board[19] = "######.## ######## ##.######";
|
||||
board[20] = "#............##............#";
|
||||
board[21] = "#.####.#####.##.#####.####.#";
|
||||
board[22] = "#.####.#####.##.#####.####.#";
|
||||
board[23] = "#o..##.......X .......##..o#";
|
||||
board[24] = "###.##.##.########.##.##.###";
|
||||
board[25] = "###.##.##.########.##.##.###";
|
||||
board[26] = "#......##....##....##......#";
|
||||
board[27] = "#.##########.##.##########.#";
|
||||
board[28] = "#.##########.##.##########.#";
|
||||
board[29] = "#..........................#";
|
||||
board[30] = "############################";
|
||||
board
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_map_creation() {
|
||||
let map = Map::new(RAW_BOARD).unwrap();
|
||||
let board = create_minimal_test_board();
|
||||
let map = Map::new(board);
|
||||
|
||||
assert!(map.graph.node_count() > 0);
|
||||
assert!(!map.grid_to_node.is_empty());
|
||||
@@ -21,9 +57,24 @@ fn test_map_creation() {
|
||||
assert!(has_connections);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_map_starting_positions() {
|
||||
let board = create_minimal_test_board();
|
||||
let map = Map::new(board);
|
||||
|
||||
let pacman_pos = map.find_starting_position(0);
|
||||
assert!(pacman_pos.is_some());
|
||||
assert!(pacman_pos.unwrap().x < BOARD_CELL_SIZE.x);
|
||||
assert!(pacman_pos.unwrap().y < BOARD_CELL_SIZE.y);
|
||||
|
||||
let nonexistent_pos = map.find_starting_position(99);
|
||||
assert_eq!(nonexistent_pos, None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_map_node_positions() {
|
||||
let map = Map::new(RAW_BOARD).unwrap();
|
||||
let board = create_minimal_test_board();
|
||||
let map = Map::new(board);
|
||||
|
||||
for (grid_pos, &node_id) in &map.grid_to_node {
|
||||
let node = map.graph.get_node(node_id).unwrap();
|
||||
@@ -33,61 +84,3 @@ fn test_map_node_positions() {
|
||||
assert_eq!(node.position, expected_pos);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_generate_items() {
|
||||
use pacman::texture::sprite::{AtlasMapper, MapperFrame, SpriteAtlas};
|
||||
use std::collections::HashMap;
|
||||
|
||||
let map = Map::new(RAW_BOARD).unwrap();
|
||||
|
||||
// Create a minimal atlas for testing
|
||||
let mut frames = HashMap::new();
|
||||
frames.insert(
|
||||
"maze/pellet.png".to_string(),
|
||||
MapperFrame {
|
||||
x: 0,
|
||||
y: 0,
|
||||
width: 8,
|
||||
height: 8,
|
||||
},
|
||||
);
|
||||
frames.insert(
|
||||
"maze/energizer.png".to_string(),
|
||||
MapperFrame {
|
||||
x: 8,
|
||||
y: 0,
|
||||
width: 8,
|
||||
height: 8,
|
||||
},
|
||||
);
|
||||
|
||||
let mapper = AtlasMapper { frames };
|
||||
let texture = unsafe { std::mem::transmute::<usize, Texture<'static>>(0usize) };
|
||||
let atlas = SpriteAtlas::new(texture, mapper);
|
||||
|
||||
let items = map.generate_items(&atlas).unwrap();
|
||||
|
||||
// Verify we have items
|
||||
assert!(!items.is_empty());
|
||||
|
||||
// Count different types
|
||||
let pellet_count = items
|
||||
.iter()
|
||||
.filter(|item| matches!(item.item_type, pacman::entity::item::ItemType::Pellet))
|
||||
.count();
|
||||
let energizer_count = items
|
||||
.iter()
|
||||
.filter(|item| matches!(item.item_type, pacman::entity::item::ItemType::Energizer))
|
||||
.count();
|
||||
|
||||
// Should have both types
|
||||
assert_eq!(pellet_count, 240);
|
||||
assert_eq!(energizer_count, 4);
|
||||
|
||||
// All items should be uncollected initially
|
||||
assert!(items.iter().all(|item| !item.is_collected()));
|
||||
|
||||
// All items should have valid node indices
|
||||
assert!(items.iter().all(|item| item.node_index < map.graph.node_count()));
|
||||
}
|
||||
|
||||
@@ -67,7 +67,7 @@ fn create_test_atlas() -> SpriteAtlas {
|
||||
fn test_pacman_creation() {
|
||||
let graph = create_test_graph();
|
||||
let atlas = create_test_atlas();
|
||||
let pacman = Pacman::new(&graph, 0, &atlas).unwrap();
|
||||
let pacman = Pacman::new(&graph, 0, &atlas);
|
||||
|
||||
assert!(pacman.traverser.position.is_at_node());
|
||||
assert_eq!(pacman.traverser.direction, Direction::Left);
|
||||
@@ -77,7 +77,7 @@ fn test_pacman_creation() {
|
||||
fn test_pacman_key_handling() {
|
||||
let graph = create_test_graph();
|
||||
let atlas = create_test_atlas();
|
||||
let mut pacman = Pacman::new(&graph, 0, &atlas).unwrap();
|
||||
let mut pacman = Pacman::new(&graph, 0, &atlas);
|
||||
|
||||
let test_cases = [
|
||||
(Keycode::Up, Direction::Up),
|
||||
@@ -96,7 +96,7 @@ fn test_pacman_key_handling() {
|
||||
fn test_pacman_invalid_key() {
|
||||
let graph = create_test_graph();
|
||||
let atlas = create_test_atlas();
|
||||
let mut pacman = Pacman::new(&graph, 0, &atlas).unwrap();
|
||||
let mut pacman = Pacman::new(&graph, 0, &atlas);
|
||||
|
||||
let original_direction = pacman.traverser.direction;
|
||||
let original_next_direction = pacman.traverser.next_direction;
|
||||
|
||||
@@ -1,6 +1,5 @@
|
||||
use pacman::constants::{BOARD_CELL_SIZE, RAW_BOARD};
|
||||
use pacman::error::ParseError;
|
||||
use pacman::map::parser::MapTileParser;
|
||||
use pacman::map::parser::{MapTileParser, ParseError};
|
||||
|
||||
#[test]
|
||||
fn test_parse_character() {
|
||||
@@ -38,10 +37,10 @@ fn test_parse_board() {
|
||||
|
||||
#[test]
|
||||
fn test_parse_board_invalid_character() {
|
||||
let mut invalid_board = RAW_BOARD.map(|s| s.to_string());
|
||||
invalid_board[0] = "###########################Z".to_string();
|
||||
let mut invalid_board = RAW_BOARD.clone();
|
||||
invalid_board[0] = "###########################Z";
|
||||
|
||||
let result = MapTileParser::parse_board(invalid_board.each_ref().map(|s| s.as_str()));
|
||||
let result = MapTileParser::parse_board(invalid_board);
|
||||
assert!(result.is_err());
|
||||
assert!(matches!(result.unwrap_err(), ParseError::UnknownCharacter('Z')));
|
||||
}
|
||||
|
||||
@@ -1,120 +0,0 @@
|
||||
use pacman::entity::direction::Direction;
|
||||
use pacman::entity::ghost::{Ghost, GhostType};
|
||||
use pacman::entity::graph::{Graph, Node};
|
||||
use pacman::texture::sprite::{AtlasMapper, MapperFrame, SpriteAtlas};
|
||||
use std::collections::HashMap;
|
||||
|
||||
fn create_test_atlas() -> SpriteAtlas {
|
||||
let mut frames = HashMap::new();
|
||||
let directions = ["up", "down", "left", "right"];
|
||||
let ghost_types = ["blinky", "pinky", "inky", "clyde"];
|
||||
|
||||
for ghost_type in &ghost_types {
|
||||
for (i, dir) in directions.iter().enumerate() {
|
||||
frames.insert(
|
||||
format!("ghost/{}/{}_{}.png", ghost_type, dir, "a"),
|
||||
MapperFrame {
|
||||
x: i as u16 * 16,
|
||||
y: 0,
|
||||
width: 16,
|
||||
height: 16,
|
||||
},
|
||||
);
|
||||
frames.insert(
|
||||
format!("ghost/{}/{}_{}.png", ghost_type, dir, "b"),
|
||||
MapperFrame {
|
||||
x: i as u16 * 16,
|
||||
y: 16,
|
||||
width: 16,
|
||||
height: 16,
|
||||
},
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
let mapper = AtlasMapper { frames };
|
||||
let dummy_texture = unsafe { std::mem::zeroed() };
|
||||
SpriteAtlas::new(dummy_texture, mapper)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_ghost_pathfinding() {
|
||||
// Create a simple test graph
|
||||
let mut graph = Graph::new();
|
||||
|
||||
// Add nodes in a simple line: 0 -> 1 -> 2
|
||||
let node0 = graph.add_node(Node {
|
||||
position: glam::Vec2::new(0.0, 0.0),
|
||||
});
|
||||
let node1 = graph.add_node(Node {
|
||||
position: glam::Vec2::new(10.0, 0.0),
|
||||
});
|
||||
let node2 = graph.add_node(Node {
|
||||
position: glam::Vec2::new(20.0, 0.0),
|
||||
});
|
||||
|
||||
// Connect the nodes
|
||||
graph.connect(node0, node1, false, None, Direction::Right).unwrap();
|
||||
graph.connect(node1, node2, false, None, Direction::Right).unwrap();
|
||||
|
||||
// Create a test atlas for the ghost
|
||||
let atlas = create_test_atlas();
|
||||
|
||||
// Create a ghost at node 0
|
||||
let ghost = Ghost::new(&graph, node0, GhostType::Blinky, &atlas).unwrap();
|
||||
|
||||
// Test pathfinding from node 0 to node 2
|
||||
let path = ghost.calculate_path_to_target(&graph, node2);
|
||||
|
||||
assert!(path.is_ok());
|
||||
let path = path.unwrap();
|
||||
assert!(
|
||||
path == vec![node0, node1, node2] || path == vec![node2, node1, node0],
|
||||
"Path was not what was expected"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_ghost_pathfinding_no_path() {
|
||||
// Create a test graph with disconnected components
|
||||
let mut graph = Graph::new();
|
||||
|
||||
let node0 = graph.add_node(Node {
|
||||
position: glam::Vec2::new(0.0, 0.0),
|
||||
});
|
||||
let node1 = graph.add_node(Node {
|
||||
position: glam::Vec2::new(10.0, 0.0),
|
||||
});
|
||||
|
||||
// Don't connect the nodes
|
||||
let atlas = create_test_atlas();
|
||||
let ghost = Ghost::new(&graph, node0, GhostType::Blinky, &atlas).unwrap();
|
||||
|
||||
// Test pathfinding when no path exists
|
||||
let path = ghost.calculate_path_to_target(&graph, node1);
|
||||
|
||||
assert!(path.is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_ghost_debug_colors() {
|
||||
let atlas = create_test_atlas();
|
||||
let mut graph = Graph::new();
|
||||
let node = graph.add_node(Node {
|
||||
position: glam::Vec2::new(0.0, 0.0),
|
||||
});
|
||||
|
||||
let blinky = Ghost::new(&graph, node, GhostType::Blinky, &atlas).unwrap();
|
||||
let pinky = Ghost::new(&graph, node, GhostType::Pinky, &atlas).unwrap();
|
||||
let inky = Ghost::new(&graph, node, GhostType::Inky, &atlas).unwrap();
|
||||
let clyde = Ghost::new(&graph, node, GhostType::Clyde, &atlas).unwrap();
|
||||
|
||||
// Test that each ghost has a different debug color
|
||||
let colors = std::collections::HashSet::from([
|
||||
blinky.debug_color(),
|
||||
pinky.debug_color(),
|
||||
inky.debug_color(),
|
||||
clyde.debug_color(),
|
||||
]);
|
||||
assert_eq!(colors.len(), 4, "All ghost colors should be unique");
|
||||
}
|
||||
@@ -1,5 +1,4 @@
|
||||
use glam::U16Vec2;
|
||||
use pacman::texture::sprite::{AtlasMapper, AtlasTile, MapperFrame, Sprite, SpriteAtlas};
|
||||
use pacman::texture::sprite::{AtlasMapper, MapperFrame, SpriteAtlas};
|
||||
use sdl2::pixels::Color;
|
||||
use std::collections::HashMap;
|
||||
|
||||
@@ -77,27 +76,3 @@ fn test_sprite_atlas_color() {
|
||||
atlas.set_color(color);
|
||||
assert_eq!(atlas.default_color(), Some(color));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_atlas_tile_new_and_with_color() {
|
||||
let pos = U16Vec2::new(10, 20);
|
||||
let size = U16Vec2::new(30, 40);
|
||||
let color = Color::RGB(100, 150, 200);
|
||||
|
||||
let tile = AtlasTile::new(pos, size, None);
|
||||
assert_eq!(tile.pos, pos);
|
||||
assert_eq!(tile.size, size);
|
||||
assert_eq!(tile.color, None);
|
||||
|
||||
let tile_with_color = tile.with_color(color);
|
||||
assert_eq!(tile_with_color.color, Some(color));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_sprite_new() {
|
||||
let atlas_tile = AtlasTile::new(U16Vec2::new(0, 0), U16Vec2::new(16, 16), None);
|
||||
let sprite = Sprite::new(atlas_tile);
|
||||
|
||||
assert_eq!(sprite.atlas_tile.pos, atlas_tile.pos);
|
||||
assert_eq!(sprite.atlas_tile.size, atlas_tile.size);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user