feat: setup dying sprites with sprite validation tests

.github/workflows/coverage.yaml

@@ -46,11 +46,12 @@ jobs:
 
       - name: Generate coverage report
         run: |
-          just coverage
+          just coverage-codecov
 
       - name: Upload coverage reports to Codecov
-        uses: codecov/codecov-action@v5
+        uses: codecov/codecov-action@v4
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
-          files: ./lcov.info
+          files: ./codecov.json
           disable_search: true
+          verbose: true

.gitignore

@@ -14,6 +14,7 @@ assets/site/build.css
 
 # Coverage reports
 lcov.info
+codecov.json
 coverage.html
 
 # Profiling output

Justfile

@@ -2,8 +2,8 @@ set shell := ["bash", "-c"]
 set windows-shell := ["powershell.exe", "-NoLogo", "-Command"]
 
 # Regex to exclude files from coverage report, double escapes for Justfile + CLI
-# You can use src\\\\..., but the filename alone is acceptable too
+# You can use src/..., but the filename alone is acceptable too
-coverage_exclude_pattern := "src\\\\app\\.rs|audio\\.rs|src\\\\error\\.rs|platform\\\\emscripten\\.rs|bin\\\\.+\\.rs|main\\.rs|platform\\\\desktop\\.rs|platform\\\\tracing_buffer\\.rs|platform\\\\buffered_writer\\.rs|systems\\\\debug\\.rs|systems\\\\profiling\\.rs"
+coverage_exclude_pattern := "src/app\\.rs|audio\\.rs|src/error\\.rs|platform/emscripten\\.rs|bin/.+\\.rs|main\\.rs|platform/desktop\\.rs|platform/tracing_buffer\\.rs|platform/buffered_writer\\.rs|systems/debug\\.rs|systems/profiling\\.rs"
 
 binary_extension := if os() == "windows" { ".exe" } else { "" }
 
@@ -11,7 +11,7 @@ binary_extension := if os() == "windows" { ".exe" } else { "" }
 # !!! --remap-path-prefix prevents the absolute path from being used in the generated report
 
 # Generate HTML report (for humans, source line inspection)
-html: coverage
+html: coverage-lcov
     cargo llvm-cov report \
     --remap-path-prefix \
     --ignore-filename-regex "{{ coverage_exclude_pattern }}" \
@@ -19,13 +19,13 @@ html: coverage
     --open
 
 # Display report (for humans)
-report-coverage: coverage
+report-coverage: coverage-lcov
     cargo llvm-cov report \
     --remap-path-prefix \
     --ignore-filename-regex "{{ coverage_exclude_pattern }}"
 
-# Run & generate report (for CI)
+# Run & generate LCOV report (as base report)
-coverage:
+coverage-lcov:
     cargo llvm-cov \
     --lcov \
     --remap-path-prefix \
@@ -34,6 +34,16 @@ coverage:
     --profile coverage \
     --no-fail-fast nextest
 
+# Run & generate Codecov report (for CI)
+coverage-codecov:
+    cargo llvm-cov \
+    --codecov \
+    --remap-path-prefix \
+    --ignore-filename-regex "{{ coverage_exclude_pattern }}" \
+    --output-path codecov.json \
+    --profile coverage \
+    --no-fail-fast nextest
+
 # Profile the project using 'samply'
 samply:
     cargo build --profile profile

codecov.yml

@@ -1,17 +1,3 @@
-coverage:
-  status:
-    project:
-      default:
-        target: 70%
-    patch:
-      default:
-        informational: true
-
 ignore:
   - "src/(?:bin|platform))/.+\\.rs"
   - "src/(?:app|events|formatter)\\.rs"
-
-comment:
-  layout: "reach,diff,flags,files,footer"
-  behavior: default
-  require_changes: false

src/texture/sprites.rs

@@ -15,6 +15,8 @@ pub enum PacmanSprite {
     Moving(Direction, u8),
     /// The full, closed-mouth Pac-Man sprite.
     Full,
+    /// A single frame of the dying animation.
+    Dying(u8),
 }
 
 /// Represents the color of a frightened ghost.
@@ -60,45 +62,50 @@ impl GameSprite {
     /// This path corresponds to the filename in the texture atlas JSON file.
     pub fn to_path(self) -> String {
         match self {
-            GameSprite::Pacman(sprite) => match sprite {
+            GameSprite::Pacman(PacmanSprite::Moving(dir, frame)) => format!(
-                PacmanSprite::Moving(dir, frame) => {
+                "pacman/{}_{}.png",
-                    let frame_char = match frame {
+                dir.as_ref(),
-                        0 => 'a',
+                match frame {
-                        1 => 'b',
+                    0 => "a",
-                        _ => panic!("Invalid animation frame"),
+                    1 => "b",
-                    };
+                    _ => panic!("Invalid animation frame"),
-                    format!("pacman/{}_{}.png", dir.as_ref().to_lowercase(), frame_char)
                 }
-                PacmanSprite::Full => "pacman/full.png".to_string(),
+            ),
-            },
+            GameSprite::Pacman(PacmanSprite::Full) => "pacman/full.png".to_string(),
-            GameSprite::Ghost(sprite) => match sprite {
+            GameSprite::Pacman(PacmanSprite::Dying(frame)) => format!("pacman/death/{}.png", frame),
-                GhostSprite::Normal(ghost, dir, frame) => {
+
-                    let frame_char = match frame {
+            // Ghost sprites
-                        0 => 'a',
+            GameSprite::Ghost(GhostSprite::Normal(ghost_type, dir, frame)) => {
-                        1 => 'b',
+                let frame_char = match frame {
-                        _ => panic!("Invalid animation frame"),
+                    0 => 'a',
-                    };
+                    1 => 'b',
-                    format!("ghost/{}/{}_{}.png", ghost.as_str(), dir.as_ref().to_lowercase(), frame_char)
+                    _ => panic!("Invalid animation frame"),
-                }
+                };
-                GhostSprite::Frightened(color, frame) => {
+                format!(
-                    let frame_char = match frame {
+                    "ghost/{}/{}_{}.png",
-                        0 => 'a',
+                    ghost_type.as_str(),
-                        1 => 'b',
+                    dir.as_ref().to_lowercase(),
-                        _ => panic!("Invalid animation frame"),
+                    frame_char
-                    };
+                )
-                    let color_str = match color {
+            }
-                        FrightenedColor::Blue => "blue",
+            GameSprite::Ghost(GhostSprite::Frightened(color, frame)) => {
-                        FrightenedColor::White => "white",
+                let frame_char = match frame {
-                    };
+                    0 => 'a',
-                    format!("ghost/frightened/{}_{}.png", color_str, frame_char)
+                    1 => 'b',
-                }
+                    _ => panic!("Invalid animation frame"),
-                GhostSprite::Eyes(dir) => format!("ghost/eyes/{}.png", dir.as_ref().to_lowercase()),
+                };
-            },
+                let color_str = match color {
-            GameSprite::Maze(sprite) => match sprite {
+                    FrightenedColor::Blue => "blue",
-                MazeSprite::Tile(index) => format!("maze/tiles/{}.png", index),
+                    FrightenedColor::White => "white",
-                MazeSprite::Pellet => "maze/pellet.png".to_string(),
+                };
-                MazeSprite::Energizer => "maze/energizer.png".to_string(),
+                format!("ghost/frightened/{}_{}.png", color_str, frame_char)
-            },
+            }
+            GameSprite::Ghost(GhostSprite::Eyes(dir)) => format!("ghost/eyes/{}.png", dir.as_ref().to_lowercase()),
+
+            // Maze sprites
+            GameSprite::Maze(MazeSprite::Tile(index)) => format!("maze/tiles/{}.png", index),
+            GameSprite::Maze(MazeSprite::Pellet) => "maze/pellet.png".to_string(),
+            GameSprite::Maze(MazeSprite::Energizer) => "maze/energizer.png".to_string(),
         }
     }
 }

tests/sprites.rs

@@ -0,0 +1,73 @@
+//! Tests for the sprite path generation.
+use pacman::{
+    game::ATLAS_FRAMES,
+    map::direction::Direction,
+    systems::components::Ghost,
+    texture::sprites::{FrightenedColor, GameSprite, GhostSprite, MazeSprite, PacmanSprite},
+};
+
+#[test]
+fn test_all_sprite_paths_exist() {
+    let mut sprites_to_test = Vec::new();
+
+    // Pac-Man sprites
+    for &dir in &[Direction::Up, Direction::Down, Direction::Left, Direction::Right] {
+        for frame in 0..2 {
+            sprites_to_test.push(GameSprite::Pacman(PacmanSprite::Moving(dir, frame)));
+        }
+    }
+    sprites_to_test.push(GameSprite::Pacman(PacmanSprite::Full));
+    for frame in 0..=10 {
+        sprites_to_test.push(GameSprite::Pacman(PacmanSprite::Dying(frame)));
+    }
+
+    // Ghost sprites
+    for &ghost in &[Ghost::Blinky, Ghost::Pinky, Ghost::Inky, Ghost::Clyde] {
+        for &dir in &[Direction::Up, Direction::Down, Direction::Left, Direction::Right] {
+            for frame in 0..2 {
+                sprites_to_test.push(GameSprite::Ghost(GhostSprite::Normal(ghost, dir, frame)));
+            }
+            sprites_to_test.push(GameSprite::Ghost(GhostSprite::Eyes(dir)));
+        }
+    }
+    for &color in &[FrightenedColor::Blue, FrightenedColor::White] {
+        for frame in 0..2 {
+            sprites_to_test.push(GameSprite::Ghost(GhostSprite::Frightened(color, frame)));
+        }
+    }
+
+    // Maze sprites
+    for i in 0..=34 {
+        sprites_to_test.push(GameSprite::Maze(MazeSprite::Tile(i)));
+    }
+    sprites_to_test.push(GameSprite::Maze(MazeSprite::Pellet));
+    sprites_to_test.push(GameSprite::Maze(MazeSprite::Energizer));
+
+    for sprite in sprites_to_test {
+        let path = sprite.to_path();
+        assert!(
+            ATLAS_FRAMES.contains_key(&path),
+            "Sprite path '{}' does not exist in the atlas.",
+            path
+        );
+    }
+}
+
+#[test]
+fn test_invalid_sprite_paths_do_not_exist() {
+    let invalid_sprites = vec![
+        // An invalid Pac-Man dying frame
+        GameSprite::Pacman(PacmanSprite::Dying(99)),
+        // An invalid maze tile
+        GameSprite::Maze(MazeSprite::Tile(99)),
+    ];
+
+    for sprite in invalid_sprites {
+        let path = sprite.to_path();
+        assert!(
+            !ATLAS_FRAMES.contains_key(&path),
+            "Invalid sprite path '{}' was found in the atlas, but it should not exist.",
+            path
+        );
+    }
+}