From 03249c88a45d585d179ff30a3298ca64f2bc20d6 Mon Sep 17 00:00:00 2001 From: Ryan Walters Date: Fri, 5 Sep 2025 14:45:42 -0500 Subject: [PATCH] feat: sprite enums for avoiding hardcoded string paths --- src/game.rs | 216 +++++++++++++++-------------------------- src/texture/mod.rs | 1 + src/texture/sprite.rs | 17 +++- src/texture/sprites.rs | 104 ++++++++++++++++++++ src/texture/text.rs | 9 +- 5 files changed, 198 insertions(+), 149 deletions(-) create mode 100644 src/texture/sprites.rs diff --git a/src/game.rs b/src/game.rs index f954c4d..c1c5103 100644 --- a/src/game.rs +++ b/src/game.rs @@ -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::(), "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::(), "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::(), + &GameSprite::Maze(MazeSprite::Pellet).to_path(), + )?; + let energizer_sprite = SpriteAtlas::get_tile( + world.non_send_resource::(), + &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::().get_normal(&ghost_type).unwrap(); let atlas = world.non_send_resource::(); + 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 { // 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( diff --git a/src/texture/mod.rs b/src/texture/mod.rs index ddc368c..b70145e 100644 --- a/src/texture/mod.rs +++ b/src/texture/mod.rs @@ -1,5 +1,6 @@ pub mod animated; pub mod blinking; pub mod sprite; +pub mod sprites; pub mod text; pub mod ttf; diff --git a/src/texture/sprite.rs b/src/texture/sprite.rs index e1d11e0..b5e8d1a 100644 --- a/src/texture/sprite.rs +++ b/src/texture/sprite.rs @@ -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 { - self.tiles.get(name).map(|frame| AtlasTile { + pub fn get_tile(&self, name: &str) -> Result { + 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, }) } diff --git a/src/texture/sprites.rs b/src/texture/sprites.rs new file mode 100644 index 0000000..2d84e16 --- /dev/null +++ b/src/texture/sprites.rs @@ -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(), + }, + } + } +} diff --git a/src/texture/text.rs b/src/texture/text.rs index 63df3d9..fb039da 100644 --- a/src/texture/text.rs +++ b/src/texture/text.rs @@ -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 { @@ -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 {