xevion/Pac-Man
1
0
Fork 0
mirror of https://github.com/Xevion/Pac-Man.git synced 2025-12-06 13:15:47 -06:00
Code Issues Packages Projects Releases Wiki Activity

feat: sprite enums for avoiding hardcoded string paths

Browse Source
This commit is contained in:
Ryan Walters
2025-09-05 14:45:42 -05:00
parent 2d4f97e04b
commit 03249c88a4
5 changed files with 198 additions and 149 deletions
Download Patch File Download Diff File Expand all files Collapse all files

216
src/game.rs
View File

@@ -5,7 +5,7 @@ include!(concat!(env!("OUT_DIR"), "/atlas_data.rs"));
use std::collections::HashMap;
use crate::constants::{self, animation, MapTile, CANVAS_SIZE};
use crate::error::{GameError, GameResult, TextureError};
use crate::error::{GameError, GameResult};
use crate::events::GameEvent;
use crate::map::builder::Map;
use crate::map::direction::Direction;
@@ -28,6 +28,7 @@ use crate::systems::{
};
use crate::texture::animated::{DirectionalTiles, TileSequence};
use crate::texture::sprite::AtlasTile;
use crate::texture::sprites::{FrightenedColor, GameSprite, GhostSprite, MazeSprite, PacmanSprite};
use bevy_ecs::event::EventRegistry;
use bevy_ecs::observer::Trigger;
use bevy_ecs::schedule::common_conditions::resource_changed;
@@ -199,8 +200,8 @@ impl Game {
// Create map tiles
let mut map_tiles = Vec::with_capacity(35);
for i in 0..35 {
let tile_name = format!("maze/tiles/{}.png", i);
let tile = atlas.get_tile(&tile_name).unwrap();
let tile_name = GameSprite::Maze(MazeSprite::Tile(i)).to_path();
let tile = atlas.get_tile(&tile_name)?;
map_tiles.push(tile);
}
@@ -215,36 +216,42 @@ impl Game {
// Create directional animated textures for Pac-Man
let up_moving_tiles = [
SpriteAtlas::get_tile(&atlas, "pacman/up_a.png")
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/up_a.png".to_string())))?,
SpriteAtlas::get_tile(&atlas, "pacman/up_b.png")
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/up_b.png".to_string())))?,
SpriteAtlas::get_tile(&atlas, "pacman/full.png")
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/full.png".to_string())))?,
SpriteAtlas::get_tile(&atlas, &GameSprite::Pacman(PacmanSprite::Moving(Direction::Up, 0)).to_path())?,
SpriteAtlas::get_tile(&atlas, &GameSprite::Pacman(PacmanSprite::Moving(Direction::Up, 1)).to_path())?,
SpriteAtlas::get_tile(&atlas, &GameSprite::Pacman(PacmanSprite::Full).to_path())?,
];
let down_moving_tiles = [
SpriteAtlas::get_tile(&atlas, "pacman/down_a.png")
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/down_a.png".to_string())))?,
SpriteAtlas::get_tile(&atlas, "pacman/down_b.png")
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/down_b.png".to_string())))?,
SpriteAtlas::get_tile(&atlas, "pacman/full.png")
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/full.png".to_string())))?,
SpriteAtlas::get_tile(
&atlas,
&GameSprite::Pacman(PacmanSprite::Moving(Direction::Down, 0)).to_path(),
)?,
SpriteAtlas::get_tile(
&atlas,
&GameSprite::Pacman(PacmanSprite::Moving(Direction::Down, 1)).to_path(),
)?,
SpriteAtlas::get_tile(&atlas, &GameSprite::Pacman(PacmanSprite::Full).to_path())?,
];
let left_moving_tiles = [
SpriteAtlas::get_tile(&atlas, "pacman/left_a.png")
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/left_a.png".to_string())))?,
SpriteAtlas::get_tile(&atlas, "pacman/left_b.png")
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/left_b.png".to_string())))?,
SpriteAtlas::get_tile(&atlas, "pacman/full.png")
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/full.png".to_string())))?,
SpriteAtlas::get_tile(
&atlas,
&GameSprite::Pacman(PacmanSprite::Moving(Direction::Left, 0)).to_path(),
)?,
SpriteAtlas::get_tile(
&atlas,
&GameSprite::Pacman(PacmanSprite::Moving(Direction::Left, 1)).to_path(),
)?,
SpriteAtlas::get_tile(&atlas, &GameSprite::Pacman(PacmanSprite::Full).to_path())?,
];
let right_moving_tiles = [
SpriteAtlas::get_tile(&atlas, "pacman/right_a.png")
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/right_a.png".to_string())))?,
SpriteAtlas::get_tile(&atlas, "pacman/right_b.png")
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/right_b.png".to_string())))?,
SpriteAtlas::get_tile(&atlas, "pacman/full.png")
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/full.png".to_string())))?,
SpriteAtlas::get_tile(
&atlas,
&GameSprite::Pacman(PacmanSprite::Moving(Direction::Right, 0)).to_path(),
)?,
SpriteAtlas::get_tile(
&atlas,
&GameSprite::Pacman(PacmanSprite::Moving(Direction::Right, 1)).to_path(),
)?,
SpriteAtlas::get_tile(&atlas, &GameSprite::Pacman(PacmanSprite::Full).to_path())?,
];
let moving_tiles = DirectionalTiles::new(
@@ -254,14 +261,20 @@ impl Game {
TileSequence::new(&right_moving_tiles),
);
let up_stopped_tile = SpriteAtlas::get_tile(&atlas, "pacman/up_b.png")
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/up_b.png".to_string())))?;
let down_stopped_tile = SpriteAtlas::get_tile(&atlas, "pacman/down_b.png")
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/down_b.png".to_string())))?;
let left_stopped_tile = SpriteAtlas::get_tile(&atlas, "pacman/left_b.png")
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/left_b.png".to_string())))?;
let right_stopped_tile = SpriteAtlas::get_tile(&atlas, "pacman/right_b.png")
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/right_b.png".to_string())))?;
let up_stopped_tile =
SpriteAtlas::get_tile(&atlas, &GameSprite::Pacman(PacmanSprite::Moving(Direction::Up, 1)).to_path())?;
let down_stopped_tile = SpriteAtlas::get_tile(
&atlas,
&GameSprite::Pacman(PacmanSprite::Moving(Direction::Down, 1)).to_path(),
)?;
let left_stopped_tile = SpriteAtlas::get_tile(
&atlas,
&GameSprite::Pacman(PacmanSprite::Moving(Direction::Left, 1)).to_path(),
)?;
let right_stopped_tile = SpriteAtlas::get_tile(
&atlas,
&GameSprite::Pacman(PacmanSprite::Moving(Direction::Right, 1)).to_path(),
)?;
let stopped_tiles = DirectionalTiles::new(
TileSequence::new(&[up_stopped_tile]),
@@ -282,8 +295,7 @@ impl Game {
movement_modifiers: MovementModifiers::default(),
buffered_direction: BufferedDirection::None,
sprite: Renderable {
sprite: SpriteAtlas::get_tile(&atlas, "pacman/full.png")
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("pacman/full.png".to_string())))?,
sprite: SpriteAtlas::get_tile(&atlas, &GameSprite::Pacman(PacmanSprite::Full).to_path())?,
layer: 0,
},
directional_animation: DirectionalAnimation::new(moving_tiles, stopped_tiles, 5),
@@ -397,10 +409,14 @@ impl Game {
// Spawn ghosts
Self::spawn_ghosts(&mut world)?;
let pellet_sprite = SpriteAtlas::get_tile(world.non_send_resource::<SpriteAtlas>(), "maze/pellet.png")
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("maze/pellet.png".to_string())))?;
let energizer_sprite = SpriteAtlas::get_tile(world.non_send_resource::<SpriteAtlas>(), "maze/energizer.png")
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("maze/energizer.png".to_string())))?;
let pellet_sprite = SpriteAtlas::get_tile(
world.non_send_resource::<SpriteAtlas>(),
&GameSprite::Maze(MazeSprite::Pellet).to_path(),
)?;
let energizer_sprite = SpriteAtlas::get_tile(
world.non_send_resource::<SpriteAtlas>(),
&GameSprite::Maze(MazeSprite::Energizer).to_path(),
)?;
// Build a list of item entities to spawn from the map
let nodes: Vec<(NodeId, EntityType, AtlasTile, f32)> = world
@@ -460,6 +476,7 @@ impl Game {
let ghost = {
let animations = *world.resource::<GhostAnimations>().get_normal(&ghost_type).unwrap();
let atlas = world.non_send_resource::<SpriteAtlas>();
let sprite_path = GameSprite::Ghost(GhostSprite::Normal(ghost_type, Direction::Left, 0)).to_path();
GhostBundle {
ghost: ghost_type,
@@ -469,14 +486,7 @@ impl Game {
direction: Direction::Left,
},
sprite: Renderable {
sprite: SpriteAtlas::get_tile(atlas, &format!("ghost/{}/left_a.png", ghost_type.as_str())).ok_or_else(
|| {
GameError::Texture(TextureError::AtlasTileNotFound(format!(
"ghost/{}/left_a.png",
ghost_type.as_str()
)))
},
)?,
sprite: SpriteAtlas::get_tile(atlas, &sprite_path)?,
layer: 0,
},
directional_animation: animations,
@@ -498,18 +508,10 @@ impl Game {
fn create_ghost_animations(atlas: &SpriteAtlas) -> GameResult<GhostAnimations> {
// Eaten (eyes) animations - single tile per direction
let up_eye = atlas
.get_tile("ghost/eyes/up.png")
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("ghost/eyes/up.png".to_string())))?;
let down_eye = atlas
.get_tile("ghost/eyes/down.png")
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("ghost/eyes/down.png".to_string())))?;
let left_eye = atlas
.get_tile("ghost/eyes/left.png")
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("ghost/eyes/left.png".to_string())))?;
let right_eye = atlas
.get_tile("ghost/eyes/right.png")
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("ghost/eyes/right.png".to_string())))?;
let up_eye = atlas.get_tile(&GameSprite::Ghost(GhostSprite::Eyes(Direction::Up)).to_path())?;
let down_eye = atlas.get_tile(&GameSprite::Ghost(GhostSprite::Eyes(Direction::Down)).to_path())?;
let left_eye = atlas.get_tile(&GameSprite::Ghost(GhostSprite::Eyes(Direction::Left)).to_path())?;
let right_eye = atlas.get_tile(&GameSprite::Ghost(GhostSprite::Eyes(Direction::Right)).to_path())?;
let eyes_tiles = DirectionalTiles::new(
TileSequence::new(&[up_eye]),
@@ -524,76 +526,20 @@ impl Game {
for ghost_type in [Ghost::Blinky, Ghost::Pinky, Ghost::Inky, Ghost::Clyde] {
// Normal animations - create directional tiles for each direction
let up_tiles = [
atlas
.get_tile(&format!("ghost/{}/up_a.png", ghost_type.as_str()))
.ok_or_else(|| {
GameError::Texture(TextureError::AtlasTileNotFound(format!(
"ghost/{}/up_a.png",
ghost_type.as_str()
)))
})?,
atlas
.get_tile(&format!("ghost/{}/up_b.png", ghost_type.as_str()))
.ok_or_else(|| {
GameError::Texture(TextureError::AtlasTileNotFound(format!(
"ghost/{}/up_b.png",
ghost_type.as_str()
)))
})?,
atlas.get_tile(&GameSprite::Ghost(GhostSprite::Normal(ghost_type, Direction::Up, 0)).to_path())?,
atlas.get_tile(&GameSprite::Ghost(GhostSprite::Normal(ghost_type, Direction::Up, 1)).to_path())?,
];
let down_tiles = [
atlas
.get_tile(&format!("ghost/{}/down_a.png", ghost_type.as_str()))
.ok_or_else(|| {
GameError::Texture(TextureError::AtlasTileNotFound(format!(
"ghost/{}/down_a.png",
ghost_type.as_str()
)))
})?,
atlas
.get_tile(&format!("ghost/{}/down_b.png", ghost_type.as_str()))
.ok_or_else(|| {
GameError::Texture(TextureError::AtlasTileNotFound(format!(
"ghost/{}/down_b.png",
ghost_type.as_str()
)))
})?,
atlas.get_tile(&GameSprite::Ghost(GhostSprite::Normal(ghost_type, Direction::Down, 0)).to_path())?,
atlas.get_tile(&GameSprite::Ghost(GhostSprite::Normal(ghost_type, Direction::Down, 1)).to_path())?,
];
let left_tiles = [
atlas
.get_tile(&format!("ghost/{}/left_a.png", ghost_type.as_str()))
.ok_or_else(|| {
GameError::Texture(TextureError::AtlasTileNotFound(format!(
"ghost/{}/left_a.png",
ghost_type.as_str()
)))
})?,
atlas
.get_tile(&format!("ghost/{}/left_b.png", ghost_type.as_str()))
.ok_or_else(|| {
GameError::Texture(TextureError::AtlasTileNotFound(format!(
"ghost/{}/left_b.png",
ghost_type.as_str()
)))
})?,
atlas.get_tile(&GameSprite::Ghost(GhostSprite::Normal(ghost_type, Direction::Left, 0)).to_path())?,
atlas.get_tile(&GameSprite::Ghost(GhostSprite::Normal(ghost_type, Direction::Left, 1)).to_path())?,
];
let right_tiles = [
atlas
.get_tile(&format!("ghost/{}/right_a.png", ghost_type.as_str()))
.ok_or_else(|| {
GameError::Texture(TextureError::AtlasTileNotFound(format!(
"ghost/{}/right_a.png",
ghost_type.as_str()
)))
})?,
atlas
.get_tile(&format!("ghost/{}/right_b.png", ghost_type.as_str()))
.ok_or_else(|| {
GameError::Texture(TextureError::AtlasTileNotFound(format!(
"ghost/{}/right_b.png",
ghost_type.as_str()
)))
})?,
atlas.get_tile(&GameSprite::Ghost(GhostSprite::Normal(ghost_type, Direction::Right, 0)).to_path())?,
atlas.get_tile(&GameSprite::Ghost(GhostSprite::Normal(ghost_type, Direction::Right, 1)).to_path())?,
];
let normal_moving = DirectionalTiles::new(
@@ -609,18 +555,14 @@ impl Game {
let (frightened, frightened_flashing) = {
// Load frightened animation tiles (same for all ghosts)
let frightened_blue_a = atlas
.get_tile("ghost/frightened/blue_a.png")
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("ghost/frightened/blue_a.png".to_string())))?;
let frightened_blue_b = atlas
.get_tile("ghost/frightened/blue_b.png")
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("ghost/frightened/blue_b.png".to_string())))?;
let frightened_white_a = atlas
.get_tile("ghost/frightened/white_a.png")
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("ghost/frightened/white_a.png".to_string())))?;
let frightened_white_b = atlas
.get_tile("ghost/frightened/white_b.png")
.ok_or_else(|| GameError::Texture(TextureError::AtlasTileNotFound("ghost/frightened/white_b.png".to_string())))?;
let frightened_blue_a =
atlas.get_tile(&GameSprite::Ghost(GhostSprite::Frightened(FrightenedColor::Blue, 0)).to_path())?;
let frightened_blue_b =
atlas.get_tile(&GameSprite::Ghost(GhostSprite::Frightened(FrightenedColor::Blue, 1)).to_path())?;
let frightened_white_a =
atlas.get_tile(&GameSprite::Ghost(GhostSprite::Frightened(FrightenedColor::White, 0)).to_path())?;
let frightened_white_b =
atlas.get_tile(&GameSprite::Ghost(GhostSprite::Frightened(FrightenedColor::White, 1)).to_path())?;
(
LinearAnimation::new(

1
src/texture/mod.rs
View File

@@ -1,5 +1,6 @@
pub mod animated;
pub mod blinking;
pub mod sprite;
pub mod sprites;
pub mod text;
pub mod ttf;

17
src/texture/sprite.rs
View File

@@ -20,7 +20,8 @@ pub struct MapperFrame {
pub size: U16Vec2,
}
#[derive(Copy, Clone, Debug, PartialEq)]
/// A single tile within a sprite atlas, defined by its position and size.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
pub struct AtlasTile {
pub pos: U16Vec2,
pub size: U16Vec2,
@@ -89,9 +90,11 @@ pub struct SpriteAtlas {
impl SpriteAtlas {
pub fn new(texture: Texture, mapper: AtlasMapper) -> Self {
let tiles = mapper.frames.into_iter().collect();
Self {
texture,
tiles: mapper.frames,
tiles,
default_color: None,
last_modulation: None,
}
@@ -103,11 +106,15 @@ impl SpriteAtlas {
/// for the named sprite, or `None` if the sprite name is not found in the
/// atlas. The returned tile can be used for immediate rendering or stored
/// for repeated use in animations and entity sprites.
pub fn get_tile(&self, name: &str) -> Option<AtlasTile> {
self.tiles.get(name).map(|frame| AtlasTile {
pub fn get_tile(&self, name: &str) -> Result<AtlasTile, TextureError> {
let frame = self
.tiles
.get(name)
.ok_or_else(|| TextureError::AtlasTileNotFound(name.to_string()))?;
Ok(AtlasTile {
pos: frame.pos,
size: frame.size,
color: None,
color: self.default_color,
})
}

104
src/texture/sprites.rs Normal file
View File

@@ -0,0 +1,104 @@
//! A structured representation of all sprite assets in the game.
//!
//! This module provides a set of enums to represent every sprite, allowing for
//! type-safe access to asset paths and avoiding the use of raw strings.
//! The `GameSprite` enum is the main entry point, and its `to_path` method
//! generates the correct path for a given sprite in the texture atlas.
use crate::map::direction::Direction;
use crate::systems::components::Ghost;
/// Represents the different sprites for Pac-Man.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum PacmanSprite {
/// A moving Pac-Man sprite for a given direction and animation frame.
Moving(Direction, u8),
/// The full, closed-mouth Pac-Man sprite.
Full,
}
/// Represents the color of a frightened ghost.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum FrightenedColor {
Blue,
White,
}
/// Represents the different sprites for ghosts.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum GhostSprite {
/// The normal appearance of a ghost for a given type, direction, and animation frame.
Normal(Ghost, Direction, u8),
/// The frightened appearance of a ghost, with a specific color and animation frame.
Frightened(FrightenedColor, u8),
/// The "eyes only" appearance of a ghost after being eaten.
Eyes(Direction),
}
/// Represents the different sprites for the maze and collectibles.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum MazeSprite {
/// A specific tile of the maze.
Tile(u8),
/// A standard pellet.
Pellet,
/// An energizer/power pellet.
Energizer,
}
/// A top-level enum that encompasses all game sprites.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum GameSprite {
Pacman(PacmanSprite),
Ghost(GhostSprite),
Maze(MazeSprite),
}
impl GameSprite {
/// Generates the asset path for the sprite.
///
/// 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 {
PacmanSprite::Moving(dir, frame) => {
let frame_char = match frame {
0 => 'a',
1 => 'b',
_ => panic!("Invalid animation frame"),
};
format!("pacman/{}_{}.png", dir.as_ref().to_lowercase(), frame_char)
}
PacmanSprite::Full => "pacman/full.png".to_string(),
},
GameSprite::Ghost(sprite) => match sprite {
GhostSprite::Normal(ghost, dir, frame) => {
let frame_char = match frame {
0 => 'a',
1 => 'b',
_ => panic!("Invalid animation frame"),
};
format!("ghost/{}/{}_{}.png", ghost.as_str(), dir.as_ref().to_lowercase(), frame_char)
}
GhostSprite::Frightened(color, frame) => {
let frame_char = match frame {
0 => 'a',
1 => 'b',
_ => panic!("Invalid animation frame"),
};
let color_str = match color {
FrightenedColor::Blue => "blue",
FrightenedColor::White => "white",
};
format!("ghost/frightened/{}_{}.png", color_str, frame_char)
}
GhostSprite::Eyes(dir) => format!("ghost/eyes/{}.png", dir.as_ref().to_lowercase()),
},
GameSprite::Maze(sprite) => match sprite {
MazeSprite::Tile(index) => format!("maze/tiles/{}.png", index),
MazeSprite::Pellet => "maze/pellet.png".to_string(),
MazeSprite::Energizer => "maze/energizer.png".to_string(),
},
}
}
}

9
src/texture/text.rs
View File

@@ -60,10 +60,7 @@ use sdl2::pixels::Color;
use sdl2::render::{Canvas, RenderTarget};
use std::collections::HashMap;
use crate::{
error::{GameError, TextureError},
texture::sprite::{AtlasTile, SpriteAtlas},
};
use crate::texture::sprite::{AtlasTile, SpriteAtlas};
/// Converts a character to its tile name in the atlas.
fn char_to_tile_name(c: char) -> Option<String> {
@@ -122,9 +119,7 @@ impl TextTexture {
}
if let Some(tile_name) = char_to_tile_name(c) {
let tile = atlas
.get_tile(&tile_name)
.ok_or(GameError::Texture(TextureError::AtlasTileNotFound(tile_name)))?;
let tile = atlas.get_tile(&tile_name)?;
self.char_map.insert(c, tile);
Ok(self.char_map.get(&c))
} else {