refactor: remove dead code, tune lints, remove useless tests

Cargo.lock

@@ -663,7 +663,7 @@ checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
 
 [[package]]
 name = "pacman"
-version = "0.78.3"
+version = "0.78.5"
 dependencies = [
  "anyhow",
  "bevy_ecs",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "pacman"
-version = "0.78.3"
+version = "0.78.5"
 authors = ["Xevion"]
 edition = "2021"
 rust-version = "1.86.0"

ROADMAP.md

@@ -1,30 +1,161 @@
 # Roadmap
 
-A list of ideas and features that I might implement in the future.
+A comprehensive list of features needed to complete the Pac-Man emulation, organized by priority and implementation complexity.
 
-## Debug Tooling
+## Core Game Features
+
+### Ghost AI & Behavior
+
+- [x] Core Ghost System Architecture
+  - [x] Ghost entity types (Blinky, Pinky, Inky, Clyde)
+  - [x] Ghost state management (Normal, Frightened, Eyes)
+  - [x] Ghost movement and pathfinding systems
+- [ ] Authentic Ghost AI Personalities
+  - [ ] Blinky (Red): Direct chase behavior
+  - [ ] Pinky (Pink): Target 4 tiles ahead of Pac-Man
+  - [ ] Inky (Cyan): Complex behavior based on Blinky's position
+  - [ ] Clyde (Orange): Chase when far, flee when close
+- [x] Mode Switching System
+  - [ ] Scatter/Chase pattern with proper timing
+  - [x] Frightened mode transitions
+  - [ ] Ghost house entry/exit mechanics
+- [x] Ghost House Behavior
+  - [x] Proper spawning sequence
+  - [ ] Exit timing and patterns
+  - [ ] House-specific movement rules
+
+### Fruit Bonus System
+
+- [x] Fruit Spawning Mechanics
+  - [x] Spawn at pellet counts 70 and 170
+  - [ ] Fruit display in bottom-right corner
+  - [x] Fruit collection and scoring
+  - [x] Bonus point display system
+
+### Level Progression
+
+- [ ] Multiple Levels
+  - [ ] Level completion detection
+  - [ ] Progressive difficulty scaling
+  - [ ] Ghost speed increases per level
+  - [ ] Power pellet duration decreases
+- [ ] Intermission Screens
+  - [ ] Between-level cutscenes
+  - [ ] Proper graphics and timing
+
+### Audio System Completion
+
+- [x] Core Audio Infrastructure
+  - [x] Audio event system
+  - [x] Sound effect playback
+  - [x] Audio muting controls
+- [ ] Background Music
+  - [ ] Continuous gameplay music
+  - [ ] Escalating siren based on remaining pellets
+  - [ ] Power pellet mode music
+  - [ ] Intermission music
+- [x] Sound Effects
+  - [x] Pellet eating sounds
+  - [x] Fruit collection sounds
+  - [ ] Ghost movement sounds
+  - [ ] Level completion fanfare
+
+### Game Mechanics
+
+- [ ] Bonus Lives
+  - [ ] Extra life at 10,000 points
+  - [x] Life counter display
+- [ ] High Score System
+  - [ ] High score tracking
+  - [x] High score display
+  - [ ] Score persistence
+
+## Secondary Features (Medium Priority)
+
+### Game Polish
+
+- [x] Core Input System
+  - [x] Keyboard controls
+  - [x] Direction buffering for responsive controls
+  - [x] Touch controls for mobile
+- [ ] Pause System
+  - [ ] Pause/unpause functionality
+  - [ ] Pause menu with options
+- [ ] Input System
+  - [ ] Input remapping
+  - [ ] Multiple input methods
+
+## Advanced Features (Lower Priority)
+
+### Difficulty Options
+
+- [ ] Easy/Normal/Hard modes
+- [ ] Customizable ghost speeds
+
+### Data Persistence
+
+- [ ] High Score Persistence
+  - [ ] Save high scores to file
+  - [ ] High score table display
+- [ ] Settings Storage
+  - [ ] Save user preferences
+  - [ ] Audio/visual settings
+- [ ] Statistics Tracking
+  - [ ] Game statistics
+  - [ ] Achievement system
+
+### Debug & Development Tools
 
-- [ ] Game state visualization
-- [ ] Game speed controls + pausing
-- [ ] Log tracing
 - [x] Performance details
+- [x] Core Debug Infrastructure
+  - [x] Debug mode toggle
+  - [x] Comprehensive game event logging
+  - [x] Performance profiling tools
+- [ ] Game State Visualization
+  - [ ] Ghost AI state display
+  - [ ] Pathfinding visualization
+  - [ ] Collision detection display
+- [ ] Game Speed Controls
+  - [ ] Variable game speed for testing
+  - [ ] Frame-by-frame stepping
 
-## Customization
+## Customization & Extensions
 
-- [ ] Themes & Colors
-  - Color-blind friendly options
-- [ ] Perfected ghost AI algorithms
-- [ ] Support for >4 ghosts
-- [ ] Custom level generation with multi-map tunneling
+### Visual Customization
 
-## Online Features
+- [x] Core Rendering System
+  - [x] Sprite-based rendering
+  - [x] Layered rendering system
+  - [x] Animation system
+  - [x] HUD rendering
+- [ ] Display Options
+  - [ ] Fullscreen support
+  - [x] Window resizing
+    - [ ] Pause while resizing (SDL2 limitation mitigation)
+  - [ ] Multiple resolution support
 
-- [ ] Scoreboard system
-  - Axum server with database and OAuth2 auth
-  - Authentication via GitHub/Discord/Google
-  - Profile features:
-    - [ ] Optional avatars (downscaled to match 8-bit aesthetic)
-    - Custom names (3-14 chars, filtered for abuse)
-  - Zero-config client implementation
-    - Uses default API endpoint
-    - Manual override available
+### Gameplay Extensions
+
+- [ ] Advanced Ghost AI
+  - [ ] Support for >4 ghosts
+  - [ ] Custom ghost behaviors
+- [ ] Level Generation
+  - [ ] Custom level creation
+  - [ ] Multi-map tunneling
+  - [ ] Level editor
+
+## Online Features (Future)
+
+### Scoreboard System
+
+- [ ] Backend Infrastructure
+  - [ ] Axum server with database
+  - [ ] OAuth2 authentication
+  - [ ] GitHub/Discord/Google auth
+- [ ] Profile Features
+  - [ ] Optional avatars (8-bit aesthetic)
+  - [ ] Custom names (3-14 chars, filtered)
+- [ ] Client Implementation
+  - [ ] Zero-config client
+  - [ ] Default API endpoint
+  - [ ] Manual override available

src/asset.rs

@@ -1,4 +1,3 @@
-#![allow(dead_code)]
 //! Cross-platform asset loading abstraction.
 //! On desktop, assets are embedded using include_bytes!; on Emscripten, assets are loaded from the filesystem.
 
@@ -62,7 +61,7 @@ mod imp {
     /// Returns `AssetError::NotFound` if the asset file cannot be located (Emscripten only),
     /// or `AssetError::Io` for filesystem I/O failures.
     pub fn get_asset_bytes(asset: Asset) -> Result<Cow<'static, [u8]>, AssetError> {
-        trace!(asset = ?asset, path = asset.path(), "Loading game asset");
+        trace!(asset = ?asset, "Loading game asset");
         let result = platform::get_asset_bytes(asset);
         match &result {
             Ok(bytes) => trace!(asset = ?asset, size_bytes = bytes.len(), "Asset loaded successfully"),

src/audio.rs

@@ -12,7 +12,6 @@ const SOUND_ASSETS: [Asset; 4] = [Asset::Wav1, Asset::Wav2, Asset::Wav3, Asset::
 /// This struct is responsible for initializing the audio device, loading sounds,
 /// and playing them. If audio fails to initialize, it will be disabled and all
 /// functions will silently do nothing.
-#[allow(dead_code)]
 pub struct Audio {
     _mixer_context: Option<mixer::Sdl2MixerContext>,
     sounds: Vec<Chunk>,
@@ -144,7 +143,6 @@ impl Audio {
     /// Automatically rotates through the four eating sound assets. The sound plays on channel 0 and the internal sound index
     /// advances to the next variant. Silently returns if audio is disabled, muted,
     /// or no sounds were loaded successfully.
-    #[allow(dead_code)]
     pub fn eat(&mut self) {
         if self.disabled || self.muted || self.sounds.is_empty() {
             return;
@@ -211,7 +209,6 @@ impl Audio {
     /// Audio can be disabled due to SDL2_mixer initialization failures, missing
     /// audio device, or failure to load any sound assets. When disabled, all
     /// audio operations become no-ops.
-    #[allow(dead_code)]
     pub fn is_disabled(&self) -> bool {
         self.disabled
     }

src/constants.rs

@@ -79,6 +79,8 @@ pub mod collider {
     pub const PELLET_SIZE: f32 = CELL_SIZE as f32 * 0.4;
     /// Collider size for power pellets/energizers (0.95x cell size)
     pub const POWER_PELLET_SIZE: f32 = CELL_SIZE as f32 * 0.95;
+    /// Collider size for fruits (0.8x cell size)
+    pub const FRUIT_SIZE: f32 = CELL_SIZE as f32 * 1.375;
 }
 
 /// UI and rendering constants

src/error.rs

@@ -46,6 +46,7 @@ pub enum AssetError {
     #[error("IO error: {0}")]
     Io(#[from] io::Error),
 
+    // This error is only possible on Emscripten, as the assets are loaded from a 'filesystem' of sorts (while on Desktop, they are included in the binary at compile time)
     #[allow(dead_code)]
     #[error("Asset not found: {0}")]
     NotFound(String),
@@ -53,12 +54,9 @@ pub enum AssetError {
 
 /// 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.
@@ -110,55 +108,3 @@ pub enum MapError {
 
 /// 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))
-    }
-}

src/formatter.rs

@@ -150,11 +150,3 @@ pub fn increment_tick() {
 pub fn get_tick_count() -> u64 {
     TICK_COUNTER.load(Ordering::Relaxed)
 }
-
-/// Reset the tick counter to 0
-///
-/// This can be used for testing or when restarting the game
-#[allow(dead_code)]
-pub fn reset_tick_counter() {
-    TICK_COUNTER.store(0, Ordering::Relaxed);
-}

src/game.rs

@@ -42,8 +42,7 @@ use crate::{
     asset::{get_asset_bytes, Asset},
     events::GameCommand,
     map::render::MapRenderer,
-    systems::debug::{BatchedLinesResource, TtfAtlasResource},
-    systems::input::{Bindings, CursorPosition},
+    systems::{BatchedLinesResource, Bindings, CursorPosition, TtfAtlasResource},
     texture::sprite::{AtlasMapper, SpriteAtlas},
 };
 
@@ -128,6 +127,8 @@ impl Game {
         debug!("Setting up ECS event registry and observers");
         Self::setup_ecs(&mut world);
 
+        world.add_observer(systems::spawn_fruit_observer);
+
         debug!("Inserting resources into ECS world");
         Self::insert_resources(
             &mut world,
@@ -410,6 +411,7 @@ impl Game {
         world.insert_resource(GlobalState { exit: false });
         world.insert_resource(PlayerLives::default());
         world.insert_resource(ScoreResource(0));
+        world.insert_resource(crate::systems::item::PelletCount(0));
         world.insert_resource(SystemTimings::default());
         world.insert_resource(Timing::default());
         world.insert_resource(Bindings::default());

src/main.rs

@@ -1,10 +1,12 @@
 // Note: This disables the console window on Windows. We manually re-attach to the parent terminal or process later on.
 #![windows_subsystem = "windows"]
 #![cfg_attr(coverage_nightly, feature(coverage_attribute))]
+#![cfg_attr(coverage_nightly, coverage(off))]
 
 use crate::{app::App, constants::LOOP_TIME};
 use tracing::info;
 
+// These modules are excluded from coverage.
 #[cfg_attr(coverage_nightly, coverage(off))]
 mod app;
 #[cfg_attr(coverage_nightly, coverage(off))]
@@ -29,7 +31,6 @@ mod texture;
 ///
 /// This function initializes SDL, the window, the game state, and then enters
 /// the main game loop.
-#[cfg_attr(coverage_nightly, coverage(off))]
 pub fn main() {
     // On Windows, this connects output streams to the console dynamically
     // On Emscripten, this connects the subscriber to the browser console

src/map/builder.rs

@@ -3,7 +3,7 @@ use crate::constants::{MapTile, BOARD_CELL_SIZE, CELL_SIZE};
 use crate::map::direction::Direction;
 use crate::map::graph::{Graph, Node, TraversalFlags};
 use crate::map::parser::MapTileParser;
-use crate::systems::movement::NodeId;
+use crate::systems::{NodeId, Position};
 use bevy_ecs::resource::Resource;
 use glam::{I8Vec2, IVec2, Vec2};
 use std::collections::{HashMap, VecDeque};
@@ -25,6 +25,8 @@ pub struct NodePositions {
     pub inky: NodeId,
     /// Clyde starts in the center of the ghost house
     pub clyde: NodeId,
+    /// Fruit spawn location directly below the ghost house
+    pub fruit_spawn: Position,
 }
 
 /// Complete maze representation combining visual layout with navigation pathfinding.
@@ -154,12 +156,37 @@ impl Map {
         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)?;
 
+        // Find fruit spawn location (directly below ghost house)
+        let left_node_position = I8Vec2::new(13, 17);
+        let left_node_id = grid_to_node.get(&left_node_position).unwrap();
+        let right_node_position = I8Vec2::new(14, 17);
+        let right_node_id = grid_to_node.get(&right_node_position).unwrap();
+
+        let distance = graph
+            .get_node(*right_node_id)
+            .unwrap()
+            .position
+            .distance(graph.get_node(*left_node_id).unwrap().position);
+
+        // interpolate between the two nodes
+        let fruit_spawn_position: Position = Position::Moving {
+            from: *left_node_id,
+            to: *right_node_id,
+            remaining_distance: distance / 2.0,
+        };
+
+        tracing::warn!(
+            fruit_spawn_position = ?fruit_spawn_position,
+            "Fruit spawn position found"
+        );
+
         let start_positions = NodePositions {
             pacman: grid_to_node[&start_pos],
             blinky: house_entrance_node_id,
             pinky: left_center_node_id,
             inky: right_center_node_id,
             clyde: center_center_node_id,
+            fruit_spawn: fruit_spawn_position,
         };
 
         // Build tunnel connections

src/map/graph.rs

@@ -1,6 +1,6 @@
 use glam::Vec2;
 
-use crate::systems::movement::NodeId;
+use crate::systems::NodeId;
 
 use super::direction::Direction;
 

src/platform/emscripten.rs

@@ -11,11 +11,8 @@ use std::io::{self, Read, Write};
 use std::time::Duration;
 
 // Emscripten FFI functions
-#[allow(dead_code)]
 extern "C" {
     fn emscripten_sleep(ms: u32);
-    fn emscripten_get_element_css_size(target: *const u8, width: *mut f64, height: *mut f64) -> i32;
-    // Standard C functions that Emscripten redirects to console
     fn printf(format: *const u8, ...) -> i32;
 }
 
@@ -65,20 +62,6 @@ impl Write for EmscriptenConsoleWriter {
     }
 }
 
-#[allow(dead_code)]
-pub fn get_canvas_size() -> Option<(u32, u32)> {
-    let mut width = 0.0;
-    let mut height = 0.0;
-
-    unsafe {
-        emscripten_get_element_css_size(c"canvas".as_ptr().cast(), &mut width, &mut height);
-        if width == 0.0 || height == 0.0 {
-            return None;
-        }
-    }
-    Some((width as u32, height as u32))
-}
-
 pub fn get_asset_bytes(asset: Asset) -> Result<Cow<'static, [u8]>, AssetError> {
     let path = format!("assets/game/{}", asset.path());
     let mut rwops = RWops::from_file(&path, "rb").map_err(|_| AssetError::NotFound(asset.path().to_string()))?;

src/platform/tracing_buffer.rs

@@ -1,4 +1,3 @@
-#![allow(dead_code)]
 //! Buffered tracing setup for handling logs before console attachment.
 
 use crate::formatter::CustomFormatter;

src/systems/animation.rs

@@ -0,0 +1,132 @@
+use bevy_ecs::{
+    component::Component,
+    query::{Has, Or, With, Without},
+    resource::Resource,
+    system::{Query, Res},
+};
+
+use crate::{
+    systems::{DeltaTime, Dying, Frozen, Position, Renderable, Velocity},
+    texture::animated::{DirectionalTiles, TileSequence},
+};
+
+/// Directional animation component with shared timing across all directions
+#[derive(Component, Clone)]
+pub struct DirectionalAnimation {
+    pub moving_tiles: DirectionalTiles,
+    pub stopped_tiles: DirectionalTiles,
+    pub current_frame: usize,
+    pub time_bank: u16,
+    pub frame_duration: u16,
+}
+
+impl DirectionalAnimation {
+    /// Creates a new directional animation with the given tiles and frame duration
+    pub fn new(moving_tiles: DirectionalTiles, stopped_tiles: DirectionalTiles, frame_duration: u16) -> Self {
+        Self {
+            moving_tiles,
+            stopped_tiles,
+            current_frame: 0,
+            time_bank: 0,
+            frame_duration,
+        }
+    }
+}
+
+/// Tag component to mark animations that should loop when they reach the end
+#[derive(Component, Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Looping;
+
+/// Linear animation component for non-directional animations (frightened ghosts)
+#[derive(Component, Resource, Clone)]
+pub struct LinearAnimation {
+    pub tiles: TileSequence,
+    pub current_frame: usize,
+    pub time_bank: u16,
+    pub frame_duration: u16,
+    pub finished: bool,
+}
+
+impl LinearAnimation {
+    /// Creates a new linear animation with the given tiles and frame duration
+    pub fn new(tiles: TileSequence, frame_duration: u16) -> Self {
+        Self {
+            tiles,
+            current_frame: 0,
+            time_bank: 0,
+            frame_duration,
+            finished: false,
+        }
+    }
+}
+
+/// Updates directional animated entities with synchronized timing across directions.
+///
+/// This runs before the render system to update sprites based on current direction and movement state.
+/// All directions share the same frame timing to ensure perfect synchronization.
+pub fn directional_render_system(
+    dt: Res<DeltaTime>,
+    mut query: Query<(&Position, &Velocity, &mut DirectionalAnimation, &mut Renderable), Without<Frozen>>,
+) {
+    let ticks = (dt.seconds * 60.0).round() as u16; // Convert from seconds to ticks at 60 ticks/sec
+
+    for (position, velocity, mut anim, mut renderable) in query.iter_mut() {
+        let stopped = matches!(position, Position::Stopped { .. });
+
+        // Only tick animation when moving to preserve stopped frame
+        if !stopped {
+            // Tick shared animation state
+            anim.time_bank += ticks;
+            while anim.time_bank >= anim.frame_duration {
+                anim.time_bank -= anim.frame_duration;
+                anim.current_frame += 1;
+            }
+        }
+
+        // Get tiles for current direction and movement state
+        let tiles = if stopped {
+            anim.stopped_tiles.get(velocity.direction)
+        } else {
+            anim.moving_tiles.get(velocity.direction)
+        };
+
+        if !tiles.is_empty() {
+            let new_tile = tiles.get_tile(anim.current_frame);
+            if renderable.sprite != new_tile {
+                renderable.sprite = new_tile;
+            }
+        }
+    }
+}
+
+/// System that updates `Renderable` sprites for entities with `LinearAnimation`.
+#[allow(clippy::type_complexity)]
+pub fn linear_render_system(
+    dt: Res<DeltaTime>,
+    mut query: Query<(&mut LinearAnimation, &mut Renderable, Has<Looping>), Or<(Without<Frozen>, With<Dying>)>>,
+) {
+    for (mut anim, mut renderable, looping) in query.iter_mut() {
+        if anim.finished {
+            continue;
+        }
+
+        anim.time_bank += dt.ticks as u16;
+        let frames_to_advance = (anim.time_bank / anim.frame_duration) as usize;
+
+        if frames_to_advance == 0 {
+            continue;
+        }
+
+        let total_frames = anim.tiles.len();
+
+        if !looping && anim.current_frame + frames_to_advance >= total_frames {
+            anim.finished = true;
+            anim.current_frame = total_frames - 1;
+        } else {
+            anim.current_frame += frames_to_advance;
+        }
+
+        anim.time_bank %= anim.frame_duration;
+        renderable.sprite = anim.tiles.get_tile(anim.current_frame);
+    }
+}

src/systems/blinking.rs

@@ -5,10 +5,7 @@ use bevy_ecs::{
     system::{Commands, Query, Res},
 };
 
-use crate::systems::{
-    components::{DeltaTime, Renderable},
-    Frozen, Hidden,
-};
+use crate::systems::{DeltaTime, Frozen, Hidden, Renderable};
 
 #[derive(Component, Debug)]
 pub struct Blinking {

src/systems/collision.rs

@@ -7,13 +7,10 @@ use bevy_ecs::{
 };
 use tracing::{debug, trace, warn};
 
-use crate::error::GameError;
 use crate::events::{GameEvent, StageTransition};
 use crate::map::builder::Map;
-use crate::systems::{
-    components::GhostState, movement::Position, AudioEvent, DyingSequence, Frozen, GameStage, Ghost, PlayerControlled,
-    ScoreResource,
-};
+use crate::systems::{movement::Position, AudioEvent, DyingSequence, Frozen, GameStage, Ghost, PlayerControlled, ScoreResource};
+use crate::{error::GameError, systems::GhostState};
 
 /// A component for defining the collision area of an entity.
 #[derive(Component)]

src/systems/common/bundles.rs

@@ -0,0 +1,43 @@
+use bevy_ecs::bundle::Bundle;
+
+use crate::systems::{
+    BufferedDirection, Collider, DirectionalAnimation, EntityType, Ghost, GhostCollider, GhostState, ItemCollider,
+    LastAnimationState, MovementModifiers, PacmanCollider, PlayerControlled, Position, Renderable, Velocity,
+};
+
+#[derive(Bundle)]
+pub struct PlayerBundle {
+    pub player: PlayerControlled,
+    pub position: Position,
+    pub velocity: Velocity,
+    pub buffered_direction: BufferedDirection,
+    pub sprite: Renderable,
+    pub directional_animation: DirectionalAnimation,
+    pub entity_type: EntityType,
+    pub collider: Collider,
+    pub movement_modifiers: MovementModifiers,
+    pub pacman_collider: PacmanCollider,
+}
+
+#[derive(Bundle)]
+pub struct ItemBundle {
+    pub position: Position,
+    pub sprite: Renderable,
+    pub entity_type: EntityType,
+    pub collider: Collider,
+    pub item_collider: ItemCollider,
+}
+
+#[derive(Bundle)]
+pub struct GhostBundle {
+    pub ghost: Ghost,
+    pub position: Position,
+    pub velocity: Velocity,
+    pub sprite: Renderable,
+    pub directional_animation: DirectionalAnimation,
+    pub entity_type: EntityType,
+    pub collider: Collider,
+    pub ghost_collider: GhostCollider,
+    pub ghost_state: GhostState,
+    pub last_animation_state: LastAnimationState,
+}

src/systems/common/components.rs

@@ -0,0 +1,106 @@
+use bevy_ecs::{component::Component, resource::Resource};
+
+use crate::{map::graph::TraversalFlags, systems::FruitType};
+
+/// A tag component denoting the type of entity.
+#[derive(Component, Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum EntityType {
+    Player,
+    Ghost,
+    Pellet,
+    PowerPellet,
+    Fruit(FruitType),
+    Effect,
+}
+
+impl EntityType {
+    /// Returns the traversal flags for this entity type.
+    pub fn traversal_flags(&self) -> TraversalFlags {
+        match self {
+            EntityType::Player => TraversalFlags::PACMAN,
+            EntityType::Ghost => TraversalFlags::GHOST,
+            _ => TraversalFlags::empty(), // Static entities don't traverse
+        }
+    }
+    pub fn score_value(&self) -> Option<u32> {
+        match self {
+            EntityType::Pellet => Some(10),
+            EntityType::PowerPellet => Some(50),
+            EntityType::Fruit(fruit_type) => Some(fruit_type.score_value()),
+            _ => None,
+        }
+    }
+
+    pub fn is_collectible(&self) -> bool {
+        matches!(self, EntityType::Pellet | EntityType::PowerPellet | EntityType::Fruit(_))
+    }
+}
+
+#[derive(Resource)]
+pub struct GlobalState {
+    pub exit: bool,
+}
+
+#[derive(Resource)]
+pub struct ScoreResource(pub u32);
+
+#[derive(Resource)]
+pub struct DeltaTime {
+    /// Floating-point delta time in seconds
+    pub seconds: f32,
+    /// Integer tick delta (usually 1, but can be different for testing)
+    pub ticks: u32,
+}
+
+#[allow(dead_code)]
+impl DeltaTime {
+    /// Creates a new DeltaTime from a floating-point delta time in seconds
+    ///
+    /// While this method exists as a helper, it does not mean that seconds and ticks are interchangeable.
+    pub fn from_seconds(seconds: f32) -> Self {
+        Self {
+            seconds,
+            ticks: (seconds * 60.0).round() as u32,
+        }
+    }
+
+    /// Creates a new DeltaTime from an integer tick delta
+    ///
+    /// While this method exists as a helper, it does not mean that seconds and ticks are interchangeable.
+    pub fn from_ticks(ticks: u32) -> Self {
+        Self {
+            seconds: ticks as f32 / 60.0,
+            ticks,
+        }
+    }
+}
+
+/// Movement modifiers that can affect Pac-Man's speed or handling.
+#[derive(Component, Debug, Clone, Copy)]
+pub struct MovementModifiers {
+    /// Multiplier applied to base speed (e.g., tunnels)
+    pub speed_multiplier: f32,
+    /// True when currently in a tunnel slowdown region
+    pub tunnel_slowdown_active: bool,
+}
+
+impl Default for MovementModifiers {
+    fn default() -> Self {
+        Self {
+            speed_multiplier: 1.0,
+            tunnel_slowdown_active: false,
+        }
+    }
+}
+
+/// Tag component for entities that should be frozen during startup
+#[derive(Component, Debug, Clone, Copy)]
+pub struct Frozen;
+
+/// Component for HUD life sprite entities.
+/// Each life sprite entity has an index indicating its position from left to right (0, 1, 2, etc.).
+/// This mostly functions as a tag component for sprites.
+#[derive(Component, Debug, Clone, Copy)]
+pub struct PlayerLife {
+    pub index: u32,
+}

src/systems/common/mod.rs

@@ -0,0 +1,5 @@
+pub mod bundles;
+pub mod components;
+
+pub use self::bundles::*;
+pub use self::components::*;

src/systems/components.rs

@@ -1,411 +0,0 @@
-use std::collections::HashMap;
-
-use bevy_ecs::{bundle::Bundle, component::Component, resource::Resource};
-use bitflags::bitflags;
-
-use crate::{
-    map::graph::TraversalFlags,
-    systems::{
-        movement::{BufferedDirection, Position, Velocity},
-        Collider, GhostCollider, ItemCollider, PacmanCollider,
-    },
-    texture::{
-        animated::{DirectionalTiles, TileSequence},
-        sprite::AtlasTile,
-    },
-};
-
-/// A tag component for entities that are controlled by the player.
-#[derive(Default, Component)]
-pub struct PlayerControlled;
-
-#[derive(Component, Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub enum Ghost {
-    Blinky,
-    Pinky,
-    Inky,
-    Clyde,
-}
-
-impl Ghost {
-    /// Returns the ghost type name for atlas lookups.
-    pub fn as_str(self) -> &'static str {
-        match self {
-            Ghost::Blinky => "blinky",
-            Ghost::Pinky => "pinky",
-            Ghost::Inky => "inky",
-            Ghost::Clyde => "clyde",
-        }
-    }
-
-    /// Returns the base movement speed for this ghost type.
-    pub fn base_speed(self) -> f32 {
-        match self {
-            Ghost::Blinky => 1.0,
-            Ghost::Pinky => 0.95,
-            Ghost::Inky => 0.9,
-            Ghost::Clyde => 0.85,
-        }
-    }
-
-    /// Returns the ghost's color for debug rendering.
-    #[allow(dead_code)]
-    pub fn debug_color(&self) -> sdl2::pixels::Color {
-        match self {
-            Ghost::Blinky => sdl2::pixels::Color::RGB(255, 0, 0),    // Red
-            Ghost::Pinky => sdl2::pixels::Color::RGB(255, 182, 255), // Pink
-            Ghost::Inky => sdl2::pixels::Color::RGB(0, 255, 255),    // Cyan
-            Ghost::Clyde => sdl2::pixels::Color::RGB(255, 182, 85),  // Orange
-        }
-    }
-}
-
-/// A tag component denoting the type of entity.
-#[derive(Component, Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub enum EntityType {
-    Player,
-    Ghost,
-    Pellet,
-    PowerPellet,
-}
-
-impl EntityType {
-    /// Returns the traversal flags for this entity type.
-    pub fn traversal_flags(&self) -> TraversalFlags {
-        match self {
-            EntityType::Player => TraversalFlags::PACMAN,
-            EntityType::Ghost => TraversalFlags::GHOST,
-            _ => TraversalFlags::empty(), // Static entities don't traverse
-        }
-    }
-    pub fn score_value(&self) -> Option<u32> {
-        match self {
-            EntityType::Pellet => Some(10),
-            EntityType::PowerPellet => Some(50),
-            _ => None,
-        }
-    }
-
-    pub fn is_collectible(&self) -> bool {
-        matches!(self, EntityType::Pellet | EntityType::PowerPellet)
-    }
-}
-
-/// A component for entities that have a sprite, with a layer for ordering.
-///
-/// This is intended to be modified by other entities allowing animation.
-#[derive(Component)]
-pub struct Renderable {
-    pub sprite: AtlasTile,
-    pub layer: u8,
-}
-
-/// Directional animation component with shared timing across all directions
-#[derive(Component, Clone)]
-pub struct DirectionalAnimation {
-    pub moving_tiles: DirectionalTiles,
-    pub stopped_tiles: DirectionalTiles,
-    pub current_frame: usize,
-    pub time_bank: u16,
-    pub frame_duration: u16,
-}
-
-impl DirectionalAnimation {
-    /// Creates a new directional animation with the given tiles and frame duration
-    pub fn new(moving_tiles: DirectionalTiles, stopped_tiles: DirectionalTiles, frame_duration: u16) -> Self {
-        Self {
-            moving_tiles,
-            stopped_tiles,
-            current_frame: 0,
-            time_bank: 0,
-            frame_duration,
-        }
-    }
-}
-
-/// Tag component to mark animations that should loop when they reach the end
-#[derive(Component, Clone, Copy, Debug, PartialEq, Eq)]
-pub struct Looping;
-
-/// Linear animation component for non-directional animations (frightened ghosts)
-#[derive(Component, Resource, Clone)]
-pub struct LinearAnimation {
-    pub tiles: TileSequence,
-    pub current_frame: usize,
-    pub time_bank: u16,
-    pub frame_duration: u16,
-    pub finished: bool,
-}
-
-impl LinearAnimation {
-    /// Creates a new linear animation with the given tiles and frame duration
-    pub fn new(tiles: TileSequence, frame_duration: u16) -> Self {
-        Self {
-            tiles,
-            current_frame: 0,
-            time_bank: 0,
-            frame_duration,
-            finished: false,
-        }
-    }
-}
-
-bitflags! {
-    #[derive(Component, Default, Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
-    pub struct CollisionLayer: u8 {
-        const PACMAN = 1 << 0;
-        const GHOST = 1 << 1;
-        const ITEM = 1 << 2;
-    }
-}
-
-#[derive(Resource)]
-pub struct GlobalState {
-    pub exit: bool,
-}
-
-#[derive(Resource)]
-pub struct ScoreResource(pub u32);
-
-#[derive(Resource)]
-pub struct DeltaTime {
-    /// Floating-point delta time in seconds
-    pub seconds: f32,
-    /// Integer tick delta (usually 1, but can be different for testing)
-    pub ticks: u32,
-}
-
-#[allow(dead_code)]
-impl DeltaTime {
-    /// Creates a new DeltaTime from a floating-point delta time in seconds
-    ///
-    /// While this method exists as a helper, it does not mean that seconds and ticks are interchangeable.
-    pub fn from_seconds(seconds: f32) -> Self {
-        Self {
-            seconds,
-            ticks: (seconds * 60.0).round() as u32,
-        }
-    }
-
-    /// Creates a new DeltaTime from an integer tick delta
-    ///
-    /// While this method exists as a helper, it does not mean that seconds and ticks are interchangeable.
-    pub fn from_ticks(ticks: u32) -> Self {
-        Self {
-            seconds: ticks as f32 / 60.0,
-            ticks,
-        }
-    }
-}
-
-/// Movement modifiers that can affect Pac-Man's speed or handling.
-#[derive(Component, Debug, Clone, Copy)]
-pub struct MovementModifiers {
-    /// Multiplier applied to base speed (e.g., tunnels)
-    pub speed_multiplier: f32,
-    /// True when currently in a tunnel slowdown region
-    pub tunnel_slowdown_active: bool,
-}
-
-impl Default for MovementModifiers {
-    fn default() -> Self {
-        Self {
-            speed_multiplier: 1.0,
-            tunnel_slowdown_active: false,
-        }
-    }
-}
-
-/// Tag component for entities that should be frozen during startup
-#[derive(Component, Debug, Clone, Copy)]
-pub struct Frozen;
-
-/// Tag component for eaten ghosts
-#[derive(Component, Debug, Clone, Copy)]
-pub struct Eaten;
-
-/// Tag component for Pac-Man during his death animation.
-/// This is mainly because the Frozen tag would stop both movement and animation, while the Dying tag can signal that the animation should continue despite being frozen.
-#[derive(Component, Debug, Clone, Copy)]
-pub struct Dying;
-
-/// Component for HUD life sprite entities.
-/// Each life sprite entity has an index indicating its position from left to right (0, 1, 2, etc.).
-/// This mostly functions as a tag component for sprites.
-#[derive(Component, Debug, Clone, Copy)]
-pub struct PlayerLife {
-    pub index: u32,
-}
-
-#[derive(Component, Debug, Clone, Copy)]
-pub enum GhostState {
-    /// Normal ghost behavior - chasing Pac-Man
-    Normal,
-    /// Frightened state after power pellet - ghost can be eaten
-    Frightened {
-        remaining_ticks: u32,
-        flash: bool,
-        remaining_flash_ticks: u32,
-    },
-    /// Eyes state - ghost has been eaten and is returning to ghost house
-    Eyes,
-}
-
-/// Component to track the last animation state for efficient change detection
-#[derive(Component, Debug, Clone, Copy, PartialEq)]
-pub struct LastAnimationState(pub GhostAnimation);
-
-impl GhostState {
-    /// Creates a new frightened state with the specified duration
-    pub fn new_frightened(total_ticks: u32, flash_start_ticks: u32) -> Self {
-        Self::Frightened {
-            remaining_ticks: total_ticks,
-            flash: false,
-            remaining_flash_ticks: flash_start_ticks, // Time until flashing starts
-        }
-    }
-
-    /// Ticks the ghost state, returning true if the state changed.
-    pub fn tick(&mut self) -> bool {
-        if let GhostState::Frightened {
-            remaining_ticks,
-            flash,
-            remaining_flash_ticks,
-        } = self
-        {
-            // Transition out of frightened state
-            if *remaining_ticks == 0 {
-                *self = GhostState::Normal;
-                return true;
-            }
-
-            *remaining_ticks -= 1;
-
-            if *remaining_flash_ticks > 0 {
-                *remaining_flash_ticks = remaining_flash_ticks.saturating_sub(1);
-                if *remaining_flash_ticks == 0 {
-                    *flash = true;
-                    true
-                } else {
-                    false
-                }
-            } else {
-                false
-            }
-        } else {
-            false
-        }
-    }
-
-    /// Returns the appropriate animation state for this ghost state
-    pub fn animation_state(&self) -> GhostAnimation {
-        match self {
-            GhostState::Normal => GhostAnimation::Normal,
-            GhostState::Eyes => GhostAnimation::Eyes,
-            GhostState::Frightened { flash: false, .. } => GhostAnimation::Frightened { flash: false },
-            GhostState::Frightened { flash: true, .. } => GhostAnimation::Frightened { flash: true },
-        }
-    }
-}
-
-/// Enumeration of different ghost animation states.
-/// Note that this is used in micromap which has a fixed size based on the number of variants,
-/// so extending this should be done with caution, and will require updating the micromap's capacity.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub enum GhostAnimation {
-    /// Normal ghost appearance with directional movement animations
-    Normal,
-    /// Blue ghost appearance when vulnerable (power pellet active)
-    Frightened { flash: bool },
-    /// Eyes-only animation when ghost has been consumed by Pac-Man (Eaten state)
-    Eyes,
-}
-
-/// Global resource containing pre-loaded animation sets for all ghost types.
-///
-/// This resource is initialized once during game startup and provides O(1) access
-/// to animation sets for each ghost type. The animation system uses this resource
-/// to efficiently switch between different ghost states without runtime asset loading.
-///
-/// The HashMap is keyed by `Ghost` enum variants (Blinky, Pinky, Inky, Clyde) and
-/// contains the normal directional animation for each ghost type.
-#[derive(Resource)]
-pub struct GhostAnimations {
-    pub normal: HashMap<Ghost, DirectionalAnimation>,
-    pub eyes: DirectionalAnimation,
-    pub frightened: LinearAnimation,
-    pub frightened_flashing: LinearAnimation,
-}
-
-impl GhostAnimations {
-    /// Creates a new GhostAnimations resource with the provided data.
-    pub fn new(
-        normal: HashMap<Ghost, DirectionalAnimation>,
-        eyes: DirectionalAnimation,
-        frightened: LinearAnimation,
-        frightened_flashing: LinearAnimation,
-    ) -> Self {
-        Self {
-            normal,
-            eyes,
-            frightened,
-            frightened_flashing,
-        }
-    }
-
-    /// Gets the normal directional animation for the specified ghost type.
-    pub fn get_normal(&self, ghost_type: &Ghost) -> Option<&DirectionalAnimation> {
-        self.normal.get(ghost_type)
-    }
-
-    /// Gets the eyes animation (shared across all ghosts).
-    pub fn eyes(&self) -> &DirectionalAnimation {
-        &self.eyes
-    }
-
-    /// Gets the frightened animations (shared across all ghosts).
-    pub fn frightened(&self, flash: bool) -> &LinearAnimation {
-        if flash {
-            &self.frightened_flashing
-        } else {
-            &self.frightened
-        }
-    }
-}
-
-#[derive(Bundle)]
-pub struct PlayerBundle {
-    pub player: PlayerControlled,
-    pub position: Position,
-    pub velocity: Velocity,
-    pub buffered_direction: BufferedDirection,
-    pub sprite: Renderable,
-    pub directional_animation: DirectionalAnimation,
-    pub entity_type: EntityType,
-    pub collider: Collider,
-    pub movement_modifiers: MovementModifiers,
-    pub pacman_collider: PacmanCollider,
-}
-
-#[derive(Bundle)]
-pub struct ItemBundle {
-    pub position: Position,
-    pub sprite: Renderable,
-    pub entity_type: EntityType,
-    pub collider: Collider,
-    pub item_collider: ItemCollider,
-}
-
-#[derive(Bundle)]
-pub struct GhostBundle {
-    pub ghost: Ghost,
-    pub position: Position,
-    pub velocity: Velocity,
-    pub sprite: Renderable,
-    pub directional_animation: DirectionalAnimation,
-    pub entity_type: EntityType,
-    pub collider: Collider,
-    pub ghost_collider: GhostCollider,
-    pub ghost_state: GhostState,
-    pub last_animation_state: LastAnimationState,
-}

src/systems/debug.rs

@@ -1,5 +1,4 @@
 //! Debug rendering system
-#[cfg_attr(coverage_nightly, feature(coverage_attribute))]
 use crate::constants::{self, BOARD_PIXEL_OFFSET};
 use crate::map::builder::Map;
 use crate::systems::{Collider, CursorPosition, NodeId, Position, SystemTimings};

src/systems/ghost.rs

@@ -1,7 +1,7 @@
+use std::collections::HashMap;
+
 use crate::platform;
-use crate::systems::components::{
-    DirectionalAnimation, Frozen, GhostAnimation, GhostState, LastAnimationState, LinearAnimation, Looping,
-};
+use crate::systems::{DirectionalAnimation, Frozen, LinearAnimation, Looping};
 use crate::{
     map::{
         builder::Map,
@@ -9,18 +9,190 @@ use crate::{
         graph::{Edge, TraversalFlags},
     },
     systems::{
-        components::{DeltaTime, Ghost},
+        components::DeltaTime,
         movement::{Position, Velocity},
     },
 };
+use bevy_ecs::component::Component;
+use bevy_ecs::resource::Resource;
 use tracing::{debug, trace, warn};
 
-use crate::systems::GhostAnimations;
 use bevy_ecs::query::Without;
 use bevy_ecs::system::{Commands, Query, Res};
 use rand::seq::IndexedRandom;
 use smallvec::SmallVec;
 
+/// Tag component for eaten ghosts
+#[derive(Component, Debug, Clone, Copy)]
+pub struct Eaten;
+
+/// Tag component for Pac-Man during his death animation.
+/// This is mainly because the Frozen tag would stop both movement and animation, while the Dying tag can signal that the animation should continue despite being frozen.
+#[derive(Component, Debug, Clone, Copy)]
+pub struct Dying;
+
+#[derive(Component, Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum Ghost {
+    Blinky,
+    Pinky,
+    Inky,
+    Clyde,
+}
+
+impl Ghost {
+    /// Returns the ghost type name for atlas lookups.
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Ghost::Blinky => "blinky",
+            Ghost::Pinky => "pinky",
+            Ghost::Inky => "inky",
+            Ghost::Clyde => "clyde",
+        }
+    }
+
+    /// Returns the base movement speed for this ghost type.
+    pub fn base_speed(self) -> f32 {
+        match self {
+            Ghost::Blinky => 1.0,
+            Ghost::Pinky => 0.95,
+            Ghost::Inky => 0.9,
+            Ghost::Clyde => 0.85,
+        }
+    }
+}
+
+#[derive(Component, Debug, Clone, Copy)]
+pub enum GhostState {
+    /// Normal ghost behavior - chasing Pac-Man
+    Normal,
+    /// Frightened state after power pellet - ghost can be eaten
+    Frightened {
+        remaining_ticks: u32,
+        flash: bool,
+        remaining_flash_ticks: u32,
+    },
+    /// Eyes state - ghost has been eaten and is returning to ghost house
+    Eyes,
+}
+
+impl GhostState {
+    /// Creates a new frightened state with the specified duration
+    pub fn new_frightened(total_ticks: u32, flash_start_ticks: u32) -> Self {
+        Self::Frightened {
+            remaining_ticks: total_ticks,
+            flash: false,
+            remaining_flash_ticks: flash_start_ticks, // Time until flashing starts
+        }
+    }
+
+    /// Ticks the ghost state, returning true if the state changed.
+    pub fn tick(&mut self) -> bool {
+        if let GhostState::Frightened {
+            remaining_ticks,
+            flash,
+            remaining_flash_ticks,
+        } = self
+        {
+            // Transition out of frightened state
+            if *remaining_ticks == 0 {
+                *self = GhostState::Normal;
+                return true;
+            }
+
+            *remaining_ticks -= 1;
+
+            if *remaining_flash_ticks > 0 {
+                *remaining_flash_ticks = remaining_flash_ticks.saturating_sub(1);
+                if *remaining_flash_ticks == 0 {
+                    *flash = true;
+                    true
+                } else {
+                    false
+                }
+            } else {
+                false
+            }
+        } else {
+            false
+        }
+    }
+
+    /// Returns the appropriate animation state for this ghost state
+    pub fn animation_state(&self) -> GhostAnimation {
+        match self {
+            GhostState::Normal => GhostAnimation::Normal,
+            GhostState::Eyes => GhostAnimation::Eyes,
+            GhostState::Frightened { flash: false, .. } => GhostAnimation::Frightened { flash: false },
+            GhostState::Frightened { flash: true, .. } => GhostAnimation::Frightened { flash: true },
+        }
+    }
+}
+
+/// Enumeration of different ghost animation states.
+/// Note that this is used in micromap which has a fixed size based on the number of variants,
+/// so extending this should be done with caution, and will require updating the micromap's capacity.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum GhostAnimation {
+    /// Normal ghost appearance with directional movement animations
+    Normal,
+    /// Blue ghost appearance when vulnerable (power pellet active)
+    Frightened { flash: bool },
+    /// Eyes-only animation when ghost has been consumed by Pac-Man (Eaten state)
+    Eyes,
+}
+
+/// Global resource containing pre-loaded animation sets for all ghost types.
+///
+/// This resource is initialized once during game startup and provides O(1) access
+/// to animation sets for each ghost type. The animation system uses this resource
+/// to efficiently switch between different ghost states without runtime asset loading.
+///
+/// The HashMap is keyed by `Ghost` enum variants (Blinky, Pinky, Inky, Clyde) and
+/// contains the normal directional animation for each ghost type.
+#[derive(Resource)]
+pub struct GhostAnimations {
+    pub normal: HashMap<Ghost, DirectionalAnimation>,
+    pub eyes: DirectionalAnimation,
+    pub frightened: LinearAnimation,
+    pub frightened_flashing: LinearAnimation,
+}
+
+impl GhostAnimations {
+    /// Creates a new GhostAnimations resource with the provided data.
+    pub fn new(
+        normal: HashMap<Ghost, DirectionalAnimation>,
+        eyes: DirectionalAnimation,
+        frightened: LinearAnimation,
+        frightened_flashing: LinearAnimation,
+    ) -> Self {
+        Self {
+            normal,
+            eyes,
+            frightened,
+            frightened_flashing,
+        }
+    }
+
+    /// Gets the normal directional animation for the specified ghost type.
+    pub fn get_normal(&self, ghost_type: &Ghost) -> Option<&DirectionalAnimation> {
+        self.normal.get(ghost_type)
+    }
+
+    /// Gets the eyes animation (shared across all ghosts).
+    pub fn eyes(&self) -> &DirectionalAnimation {
+        &self.eyes
+    }
+
+    /// Gets the frightened animations (shared across all ghosts).
+    pub fn frightened(&self, flash: bool) -> &LinearAnimation {
+        if flash {
+            &self.frightened_flashing
+        } else {
+            &self.frightened
+        }
+    }
+}
+
 /// Autonomous ghost AI system implementing randomized movement with backtracking avoidance.
 pub fn ghost_movement_system(
     map: Res<Map>,
@@ -185,6 +357,10 @@ fn find_direction_to_target(
     None
 }
 
+/// Component to track the last animation state for efficient change detection
+#[derive(Component, Debug, Clone, Copy, PartialEq)]
+pub struct LastAnimationState(pub GhostAnimation);
+
 /// Unified system that manages ghost state transitions and animations with component swapping
 pub fn ghost_state_system(
     mut commands: Commands,

src/systems/input.rs

@@ -13,7 +13,7 @@ use sdl2::{
 };
 use smallvec::{smallvec, SmallVec};
 
-use crate::systems::components::DeltaTime;
+use crate::systems::DeltaTime;
 use crate::{
     events::{GameCommand, GameEvent},
     map::direction::Direction,

src/systems/item.rs

@@ -1,50 +1,102 @@
 use bevy_ecs::{
     entity::Entity,
-    event::{EventReader, EventWriter},
+    event::{Event, EventReader, EventWriter},
+    observer::Trigger,
     query::With,
-    system::{Commands, Query, ResMut},
+    system::{Commands, NonSendMut, Query, Res, ResMut, Single},
 };
+use strum_macros::IntoStaticStr;
 use tracing::{debug, trace};
 
+use crate::{
+    constants,
+    map::builder::Map,
+    systems::{common::bundles::ItemBundle, Collider, Position, Renderable, TimeToLive},
+    texture::{
+        sprite::SpriteAtlas,
+        sprites::{EffectSprite, GameSprite},
+    },
+};
+
 use crate::{
     constants::animation::FRIGHTENED_FLASH_START_TICKS,
     events::GameEvent,
-    systems::{AudioEvent, EntityType, GhostCollider, GhostState, ItemCollider, PacmanCollider, ScoreResource},
+    systems::common::components::EntityType,
+    systems::{AudioEvent, GhostCollider, GhostState, ItemCollider, PacmanCollider, ScoreResource},
 };
 
-/// Determines if a collision between two entity types should be handled by the item system.
-///
-/// Returns `true` if one entity is a player and the other is a collectible item.
-#[allow(dead_code)]
-pub fn is_valid_item_collision(entity1: EntityType, entity2: EntityType) -> bool {
-    match (entity1, entity2) {
-        (EntityType::Player, entity) | (entity, EntityType::Player) => entity.is_collectible(),
-        _ => false,
+/// Tracks the number of pellets consumed by the player for fruit spawning mechanics.
+#[derive(bevy_ecs::resource::Resource, Debug, Default)]
+pub struct PelletCount(pub u32);
+
+/// Represents the different fruit sprites that can appear as bonus items.
+#[derive(IntoStaticStr, Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[strum(serialize_all = "snake_case")]
+pub enum FruitType {
+    Cherry,
+    Strawberry,
+    Orange,
+    Apple,
+    Melon,
+    Galaxian,
+    Bell,
+    Key,
+}
+
+impl FruitType {
+    /// Returns the score value for this fruit type.
+    pub fn score_value(self) -> u32 {
+        match self {
+            FruitType::Cherry => 100,
+            FruitType::Strawberry => 300,
+            FruitType::Orange => 500,
+            FruitType::Apple => 700,
+            FruitType::Melon => 1000,
+            FruitType::Galaxian => 2000,
+            FruitType::Bell => 3000,
+            FruitType::Key => 5000,
+        }
+    }
+
+    pub fn from_index(index: u8) -> Self {
+        match index {
+            0 => FruitType::Cherry,
+            1 => FruitType::Strawberry,
+            2 => FruitType::Orange,
+            3 => FruitType::Apple,
+            4 => FruitType::Melon,
+            5 => FruitType::Galaxian,
+            6 => FruitType::Bell,
+            7 => FruitType::Key,
+            _ => panic!("Invalid fruit index: {}", index),
+        }
     }
 }
 
+#[allow(clippy::too_many_arguments)]
 pub fn item_system(
     mut commands: Commands,
     mut collision_events: EventReader<GameEvent>,
     mut score: ResMut<ScoreResource>,
-    pacman_query: Query<Entity, With<PacmanCollider>>,
-    item_query: Query<(Entity, &EntityType), With<ItemCollider>>,
+    mut pellet_count: ResMut<PelletCount>,
+    pacman: Single<Entity, With<PacmanCollider>>,
+    item_query: Query<(Entity, &EntityType, &Position), With<ItemCollider>>,
     mut ghost_query: Query<&mut GhostState, With<GhostCollider>>,
     mut events: EventWriter<AudioEvent>,
 ) {
     for event in collision_events.read() {
         if let GameEvent::Collision(entity1, entity2) = event {
             // Check if one is Pacman and the other is an item
-            let (_pacman_entity, item_entity) = if pacman_query.get(*entity1).is_ok() && item_query.get(*entity2).is_ok() {
-                (*entity1, *entity2)
-            } else if pacman_query.get(*entity2).is_ok() && item_query.get(*entity1).is_ok() {
-                (*entity2, *entity1)
+            let (_, item_entity) = if *pacman == *entity1 && item_query.get(*entity2).is_ok() {
+                (*pacman, *entity2)
+            } else if *pacman == *entity2 && item_query.get(*entity1).is_ok() {
+                (*pacman, *entity1)
             } else {
                 continue;
             };
 
             // Get the item type and update score
-            if let Ok((item_ent, entity_type)) = item_query.get(item_entity) {
+            if let Ok((item_ent, entity_type, position)) = item_query.get(item_entity) {
                 if let Some(score_value) = entity_type.score_value() {
                     trace!(item_entity = ?item_ent, item_type = ?entity_type, score_value, new_score = score.0 + score_value, "Item collected by player");
                     score.0 += score_value;
@@ -52,13 +104,34 @@ pub fn item_system(
                     // Remove the collected item
                     commands.entity(item_ent).despawn();
 
+                    // Track pellet consumption for fruit spawning
+                    if *entity_type == EntityType::Pellet {
+                        pellet_count.0 += 1;
+                        trace!(pellet_count = pellet_count.0, "Pellet consumed");
+
+                        // Check if we should spawn a fruit
+                        if pellet_count.0 == 5 || pellet_count.0 == 170 {
+                            debug!(pellet_count = pellet_count.0, "Fruit spawn milestone reached");
+                            commands.trigger(SpawnTrigger::Fruit);
+                        }
+                    }
+
+                    // Trigger bonus points effect if a fruit is collected
+                    if matches!(*entity_type, EntityType::Fruit(_)) {
+                        commands.trigger(SpawnTrigger::Bonus {
+                            position: *position,
+                            value: entity_type.score_value().unwrap(),
+                            ttl: 60 * 2,
+                        });
+                    }
+
                     // Trigger audio if appropriate
                     if entity_type.is_collectible() {
                         events.write(AudioEvent::PlayEat);
                     }
 
                     // Make ghosts frightened when power pellet is collected
-                    if *entity_type == EntityType::PowerPellet {
+                    if matches!(*entity_type, EntityType::PowerPellet) {
                         // Convert seconds to frames (assumes 60 FPS)
                         let total_ticks = 60 * 5; // 5 seconds total
                         debug!(duration_ticks = total_ticks, "Power pellet collected, frightening ghosts");
@@ -78,3 +151,59 @@ pub fn item_system(
         }
     }
 }
+
+/// Trigger to spawn a fruit
+#[derive(Event, Clone, Copy, Debug)]
+pub enum SpawnTrigger {
+    Fruit,
+    Bonus { position: Position, value: u32, ttl: u32 },
+}
+
+pub fn spawn_fruit_observer(
+    trigger: Trigger<SpawnTrigger>,
+    mut commands: Commands,
+    atlas: NonSendMut<SpriteAtlas>,
+    map: Res<Map>,
+) {
+    let entity = match *trigger {
+        SpawnTrigger::Fruit => {
+            // Use cherry sprite as the default fruit (first fruit in original Pac-Man)
+            let sprite = &atlas
+                .get_tile(&GameSprite::Fruit(FruitType::from_index(0)).to_path())
+                .unwrap();
+            let bundle = ItemBundle {
+                position: map.start_positions.fruit_spawn,
+                sprite: Renderable {
+                    sprite: *sprite,
+                    layer: 1,
+                },
+                entity_type: EntityType::Fruit(FruitType::Cherry),
+                collider: Collider {
+                    size: constants::collider::FRUIT_SIZE,
+                },
+                item_collider: ItemCollider,
+            };
+
+            commands.spawn(bundle)
+        }
+        SpawnTrigger::Bonus { position, value, ttl } => {
+            let sprite = &atlas
+                .get_tile(&GameSprite::Effect(EffectSprite::Bonus(value)).to_path())
+                .unwrap();
+
+            let bundle = (
+                position,
+                TimeToLive::new(ttl),
+                Renderable {
+                    sprite: *sprite,
+                    layer: 1,
+                },
+                EntityType::Effect,
+            );
+
+            commands.spawn(bundle)
+        }
+    };
+
+    debug!(entity = ?entity.id(), "Entity spawned via trigger");
+}

src/systems/lifetime.rs

@@ -4,7 +4,7 @@ use bevy_ecs::{
     system::{Commands, Query, Res},
 };
 
-use crate::systems::components::DeltaTime;
+use crate::systems::DeltaTime;
 
 /// Component for entities that should be automatically deleted after a certain number of ticks
 #[derive(Component, Debug, Clone, Copy)]

src/systems/mod.rs

@@ -1,5 +1,6 @@
 //! This module contains all the systems in the game.
 
+// These modules are excluded from coverage.
 #[cfg_attr(coverage_nightly, coverage(off))]
 pub mod audio;
 #[cfg_attr(coverage_nightly, coverage(off))]
@@ -9,9 +10,10 @@ pub mod profiling;
 #[cfg_attr(coverage_nightly, coverage(off))]
 pub mod render;
 
+pub mod animation;
 pub mod blinking;
 pub mod collision;
-pub mod components;
+pub mod common;
 pub mod ghost;
 pub mod input;
 pub mod item;
@@ -22,10 +24,11 @@ pub mod state;
 
 // Re-export all the modules. Do not fine-tune the exports.
 
+pub use self::animation::*;
 pub use self::audio::*;
 pub use self::blinking::*;
 pub use self::collision::*;
-pub use self::components::*;
+pub use self::common::*;
 pub use self::debug::*;
 pub use self::ghost::*;
 pub use self::input::*;

src/systems/player.rs

@@ -1,4 +1,5 @@
 use bevy_ecs::{
+    component::Component,
     event::EventReader,
     query::{With, Without},
     system::{Query, Res, ResMut, Single},
@@ -9,13 +10,17 @@ use crate::{
     events::{GameCommand, GameEvent},
     map::{builder::Map, graph::Edge},
     systems::{
-        components::{DeltaTime, EntityType, Frozen, GlobalState, MovementModifiers, PlayerControlled},
+        components::{DeltaTime, EntityType, Frozen, GlobalState, MovementModifiers},
         debug::DebugState,
         movement::{BufferedDirection, Position, Velocity},
         AudioState,
     },
 };
 
+/// A tag component for entities that are controlled by the player.
+#[derive(Default, Component)]
+pub struct PlayerControlled;
+
 pub fn can_traverse(entity_type: EntityType, edge: Edge) -> bool {
     let entity_flags = entity_type.traversal_flags();
     edge.traversal_flags.contains(entity_flags)
@@ -27,6 +32,7 @@ pub fn can_traverse(entity_type: EntityType, edge: Edge) -> bool {
 /// toggling, audio muting, and game exit requests. Movement commands are buffered
 /// to allow direction changes before reaching intersections, improving gameplay
 /// responsiveness. Non-movement commands immediately modify global game state.
+#[allow(clippy::type_complexity)]
 pub fn player_control_system(
     mut events: EventReader<GameEvent>,
     mut state: ResMut<GlobalState>,

src/systems/render.rs

@@ -1,12 +1,10 @@
 use crate::map::builder::Map;
 use crate::map::direction::Direction;
-use crate::systems::input::TouchState;
 use crate::systems::{
-    debug_render_system, BatchedLinesResource, Collider, CursorPosition, DebugState, DebugTextureResource, DeltaTime,
-    DirectionalAnimation, Dying, Frozen, GameStage, LinearAnimation, Looping, PlayerLife, PlayerLives, Position, Renderable,
-    ScoreResource, StartupSequence, SystemId, SystemTimings, TtfAtlasResource, Velocity,
+    debug_render_system, BatchedLinesResource, Collider, CursorPosition, DebugState, DebugTextureResource, GameStage, PlayerLife,
+    PlayerLives, Position, ScoreResource, StartupSequence, SystemId, SystemTimings, TouchState, TtfAtlasResource,
 };
-use crate::texture::sprite::SpriteAtlas;
+use crate::texture::sprite::{AtlasTile, SpriteAtlas};
 use crate::texture::sprites::{GameSprite, PacmanSprite};
 use crate::texture::text::TextTexture;
 use crate::{
@@ -16,7 +14,7 @@ use crate::{
 use bevy_ecs::component::Component;
 use bevy_ecs::entity::Entity;
 use bevy_ecs::event::EventWriter;
-use bevy_ecs::query::{Changed, Has, Or, With, Without};
+use bevy_ecs::query::{Changed, Or, With, Without};
 use bevy_ecs::removal_detection::RemovedComponents;
 use bevy_ecs::resource::Resource;
 use bevy_ecs::system::{Commands, NonSendMut, Query, Res, ResMut};
@@ -25,8 +23,18 @@ use sdl2::pixels::Color;
 use sdl2::rect::{Point, Rect};
 use sdl2::render::{BlendMode, Canvas, Texture};
 use sdl2::video::Window;
+use std::cmp::Ordering;
 use std::time::Instant;
 
+/// A component for entities that have a sprite, with a layer for ordering.
+///
+/// This is intended to be modified by other entities allowing animation.
+#[derive(Component)]
+pub struct Renderable {
+    pub sprite: AtlasTile,
+    pub layer: u8,
+}
+
 #[derive(Resource, Default)]
 pub struct RenderDirty(pub bool);
 
@@ -56,77 +64,6 @@ pub fn dirty_render_system(
     }
 }
 
-/// Updates directional animated entities with synchronized timing across directions.
-///
-/// This runs before the render system to update sprites based on current direction and movement state.
-/// All directions share the same frame timing to ensure perfect synchronization.
-pub fn directional_render_system(
-    dt: Res<DeltaTime>,
-    mut query: Query<(&Position, &Velocity, &mut DirectionalAnimation, &mut Renderable), Without<Frozen>>,
-) {
-    let ticks = (dt.seconds * 60.0).round() as u16; // Convert from seconds to ticks at 60 ticks/sec
-
-    for (position, velocity, mut anim, mut renderable) in query.iter_mut() {
-        let stopped = matches!(position, Position::Stopped { .. });
-
-        // Only tick animation when moving to preserve stopped frame
-        if !stopped {
-            // Tick shared animation state
-            anim.time_bank += ticks;
-            while anim.time_bank >= anim.frame_duration {
-                anim.time_bank -= anim.frame_duration;
-                anim.current_frame += 1;
-            }
-        }
-
-        // Get tiles for current direction and movement state
-        let tiles = if stopped {
-            anim.stopped_tiles.get(velocity.direction)
-        } else {
-            anim.moving_tiles.get(velocity.direction)
-        };
-
-        if !tiles.is_empty() {
-            let new_tile = tiles.get_tile(anim.current_frame);
-            if renderable.sprite != new_tile {
-                renderable.sprite = new_tile;
-            }
-        }
-    }
-}
-
-/// System that updates `Renderable` sprites for entities with `LinearAnimation`.
-#[allow(clippy::type_complexity)]
-pub fn linear_render_system(
-    dt: Res<DeltaTime>,
-    mut query: Query<(&mut LinearAnimation, &mut Renderable, Has<Looping>), Or<(Without<Frozen>, With<Dying>)>>,
-) {
-    for (mut anim, mut renderable, looping) in query.iter_mut() {
-        if anim.finished {
-            continue;
-        }
-
-        anim.time_bank += dt.ticks as u16;
-        let frames_to_advance = (anim.time_bank / anim.frame_duration) as usize;
-
-        if frames_to_advance == 0 {
-            continue;
-        }
-
-        let total_frames = anim.tiles.len();
-
-        if !looping && anim.current_frame + frames_to_advance >= total_frames {
-            anim.finished = true;
-            anim.current_frame = total_frames - 1;
-        } else {
-            anim.current_frame += frames_to_advance;
-        }
-
-        anim.time_bank %= anim.frame_duration;
-        renderable.sprite = anim.tiles.get_tile(anim.current_frame);
-    }
-}
-
 /// System that manages player life sprite entities.
 /// Spawns and despawns life sprite entities based on changes to PlayerLives resource.
 /// Each life sprite is positioned based on its index (0, 1, 2, etc. from left to right).
@@ -147,42 +84,47 @@ pub fn player_life_sprite_system(
     // Calculate the difference
     let diff = (displayed_lives as i8) - (current_count as i8);
 
-    if diff > 0 {
+    match diff.cmp(&0) {
+        // Ignore when the number of lives displayed is correct
+        Ordering::Equal => {}
         // Spawn new life sprites
-        let life_sprite = match atlas.get_tile(&GameSprite::Pacman(PacmanSprite::Moving(Direction::Left, 1)).to_path()) {
-            Ok(sprite) => sprite,
-            Err(e) => {
-                errors.write(e.into());
-                return;
+        Ordering::Greater => {
+            let life_sprite = match atlas.get_tile(&GameSprite::Pacman(PacmanSprite::Moving(Direction::Left, 1)).to_path()) {
+                Ok(sprite) => sprite,
+                Err(e) => {
+                    errors.write(e.into());
+                    return;
+                }
+            };
+
+            for i in 0..diff {
+                let position = calculate_life_sprite_position(i as u32);
+
+                commands.spawn((
+                    PlayerLife { index: i as u32 },
+                    Renderable {
+                        sprite: life_sprite,
+                        layer: 255, // High layer to render on top
+                    },
+                    PixelPosition {
+                        pixel_position: position,
+                    },
+                ));
             }
-        };
-
-        for i in 0..diff.abs() {
-            let position = calculate_life_sprite_position(i as u32);
-
-            commands.spawn((
-                PlayerLife { index: i as u32 },
-                Renderable {
-                    sprite: life_sprite,
-                    layer: 255, // High layer to render on top
-                },
-                PixelPosition {
-                    pixel_position: position,
-                },
-            ));
         }
-    } else if diff < 0 {
         // Remove excess life sprites (highest indices first)
-        let to_remove = diff.abs() as usize;
-        let sprites_to_remove: Vec<_> = current_sprites
-            .iter()
-            .rev() // Start from highest index
-            .take(to_remove as usize)
-            .map(|(entity, _)| *entity)
-            .collect();
+        Ordering::Less => {
+            let to_remove = diff.unsigned_abs();
+            let sprites_to_remove: Vec<_> = current_sprites
+                .iter()
+                .rev() // Start from highest index
+                .take(to_remove as usize)
+                .map(|(entity, _)| *entity)
+                .collect();
 
-        for entity in sprites_to_remove {
-            commands.entity(entity).despawn();
+            for entity in sprites_to_remove {
+                commands.entity(entity).despawn();
+            }
         }
     }
 }
@@ -361,6 +303,7 @@ pub fn hud_render_system(
 }
 
 #[allow(clippy::too_many_arguments)]
+#[allow(clippy::type_complexity)]
 pub fn render_system(
     canvas: &mut Canvas<Window>,
     map_texture: &NonSendMut<MapTextureResource>,
@@ -426,6 +369,7 @@ pub fn render_system(
 /// Combined render system that renders to both backbuffer and debug textures in a single
 /// with_multiple_texture_canvas call for reduced overhead
 #[allow(clippy::too_many_arguments)]
+#[allow(clippy::type_complexity)]
 pub fn combined_render_system(
     mut canvas: NonSendMut<&mut Canvas<Window>>,
     map_texture: NonSendMut<MapTextureResource>,

src/systems/state.rs

@@ -2,20 +2,20 @@ use std::mem::discriminant;
 use tracing::{debug, info, warn};
 
 use crate::events::StageTransition;
+use crate::systems::SpawnTrigger;
 use crate::{
     map::builder::Map,
     systems::{
         AudioEvent, Blinking, DirectionalAnimation, Dying, Eaten, Frozen, Ghost, GhostCollider, GhostState, Hidden,
-        LinearAnimation, Looping, NodeId, PlayerControlled, Position, Renderable, TimeToLive,
+        LinearAnimation, Looping, NodeId, PlayerControlled, Position,
     },
-    texture::{animated::TileSequence, sprite::SpriteAtlas},
 };
 use bevy_ecs::{
     entity::Entity,
     event::{EventReader, EventWriter},
     query::{With, Without},
     resource::Resource,
-    system::{Commands, NonSendMut, Query, Res, ResMut, Single},
+    system::{Commands, Query, Res, ResMut, Single},
 };
 
 #[derive(Resource, Clone)]
@@ -92,24 +92,6 @@ impl Default for PlayerLives {
 }
 
 /// Handles startup sequence transitions and component management
-/// Maps sprite index to the corresponding effect sprite path
-fn sprite_index_to_path(index: u8) -> &'static str {
-    match index {
-        0 => "effects/100.png",
-        1 => "effects/200.png",
-        2 => "effects/300.png",
-        3 => "effects/400.png",
-        4 => "effects/700.png",
-        5 => "effects/800.png",
-        6 => "effects/1000.png",
-        7 => "effects/1600.png",
-        8 => "effects/2000.png",
-        9 => "effects/3000.png",
-        10 => "effects/5000.png",
-        _ => "effects/200.png", // fallback to index 1
-    }
-}
-
 #[allow(clippy::too_many_arguments)]
 #[allow(clippy::type_complexity)]
 pub fn stage_system(
@@ -124,7 +106,6 @@ pub fn stage_system(
     mut blinking_query: Query<Entity, With<Blinking>>,
     player: Single<(Entity, &mut Position), With<PlayerControlled>>,
     mut ghost_query: Query<(Entity, &Ghost, &mut Position), (With<GhostCollider>, Without<PlayerControlled>)>,
-    atlas: NonSendMut<SpriteAtlas>,
 ) {
     let old_state = *game_state;
     let mut new_state: Option<GameStage> = None;
@@ -246,23 +227,12 @@ pub fn stage_system(
             commands.entity(ghost_entity).insert(Hidden);
 
             // Spawn bonus points entity at Pac-Man's position
-            let sprite_index = 1; // Index 1 = 200 points (default for ghost eating)
-            let sprite_path = sprite_index_to_path(sprite_index);
-
-            if let Ok(sprite_tile) = SpriteAtlas::get_tile(&atlas, sprite_path) {
-                let tile_sequence = TileSequence::single(sprite_tile);
-                let animation = LinearAnimation::new(tile_sequence, 1);
-
-                commands.spawn((
-                    Position::Stopped { node },
-                    Renderable {
-                        sprite: sprite_tile,
-                        layer: 2, // Above other entities
-                    },
-                    animation,
-                    TimeToLive::new(30),
-                ));
-            }
+            commands.trigger(SpawnTrigger::Bonus {
+                position: Position::Stopped { node },
+                // TODO: Doubling score value for each consecutive ghost eaten
+                value: 200,
+                ttl: 30,
+            });
         }
         (GameStage::GhostEatenPause { ghost_entity, .. }, GameStage::Playing) => {
             // Unfreeze and reveal the player & all ghosts

src/texture/animated.rs

@@ -14,11 +14,6 @@ impl TileSequence {
         Self { tiles: tiles.to_vec() }
     }
 
-    /// Creates a tile sequence with a single tile.
-    pub fn single(tile: AtlasTile) -> Self {
-        Self { tiles: vec![tile] }
-    }
-
     /// Returns the tile at the given frame index, wrapping if necessary
     pub fn get_tile(&self, frame: usize) -> AtlasTile {
         if self.tiles.is_empty() {

src/texture/sprite.rs

@@ -58,19 +58,6 @@ impl AtlasTile {
         canvas.copy(&atlas.texture, src, dest).map_err(TextureError::RenderFailed)?;
         Ok(())
     }
-
-    /// Creates a new atlas tile.
-    #[allow(dead_code)]
-    pub fn new(pos: U16Vec2, size: U16Vec2, color: Option<Color>) -> Self {
-        Self { pos, size, color }
-    }
-
-    /// Sets the color of the tile.
-    #[allow(dead_code)]
-    pub fn with_color(mut self, color: Color) -> Self {
-        self.color = Some(color);
-        self
-    }
 }
 
 /// High-performance sprite atlas providing fast texture region lookups and rendering.
@@ -120,32 +107,4 @@ impl SpriteAtlas {
             color: self.default_color,
         })
     }
-
-    #[allow(dead_code)]
-    pub fn set_color(&mut self, color: Color) {
-        self.default_color = Some(color);
-    }
-
-    #[allow(dead_code)]
-    pub fn texture(&self) -> &Texture {
-        &self.texture
-    }
-
-    /// Returns the number of tiles in the atlas.
-    #[allow(dead_code)]
-    pub fn tiles_count(&self) -> usize {
-        self.tiles.len()
-    }
-
-    /// Returns true if the atlas has a tile with the given name.
-    #[allow(dead_code)]
-    pub fn has_tile(&self, name: &str) -> bool {
-        self.tiles.contains_key(name)
-    }
-
-    /// Returns the default color of the atlas.
-    #[allow(dead_code)]
-    pub fn default_color(&self) -> Option<Color> {
-        self.default_color
-    }
 }

src/texture/sprites.rs

@@ -5,8 +5,10 @@
 //! 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;
+use crate::{
+    map::direction::Direction,
+    systems::{FruitType, Ghost},
+};
 
 /// Represents the different sprites for Pac-Man.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -48,12 +50,20 @@ pub enum MazeSprite {
     Energizer,
 }
 
+/// Represents the different effect sprites that can appear as bonus items.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum EffectSprite {
+    Bonus(u32),
+}
+
 /// 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),
+    Fruit(FruitType),
+    Effect(EffectSprite),
 }
 
 impl GameSprite {
@@ -106,6 +116,18 @@ impl GameSprite {
             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(),
+
+            // Fruit sprites
+            GameSprite::Fruit(fruit) => format!("edible/{}.png", Into::<&'static str>::into(fruit)),
+
+            // Effect sprites
+            GameSprite::Effect(EffectSprite::Bonus(value)) => match value {
+                100 | 200 | 300 | 400 | 700 | 800 | 1000 | 2000 | 3000 | 5000 => format!("effects/{}.png", value),
+                _ => {
+                    tracing::warn!("Invalid bonus value: {}", value);
+                    "effects/100.png".to_string()
+                }
+            },
         }
     }
 }

src/texture/text.rs

@@ -1,5 +1,3 @@
-#![allow(dead_code)]
-
 //! This module provides text rendering using the texture atlas.
 //!
 //! The TextTexture system renders text from the atlas using character mapping.
@@ -109,6 +107,7 @@ impl TextTexture {
         }
     }
 
+    #[allow(dead_code)]
     pub fn get_char_map(&self) -> &HashMap<char, AtlasTile> {
         &self.char_map
     }
@@ -167,26 +166,6 @@ impl TextTexture {
         Ok(())
     }
 
-    /// Sets the default color for text rendering.
-    pub fn set_color(&mut self, color: Color) {
-        self.default_color = Some(color);
-    }
-
-    /// Gets the current default color.
-    pub fn color(&self) -> Option<Color> {
-        self.default_color
-    }
-
-    /// Sets the scale for text rendering.
-    pub fn set_scale(&mut self, scale: f32) {
-        self.scale = scale;
-    }
-
-    /// Gets the current scale.
-    pub fn scale(&self) -> f32 {
-        self.scale
-    }
-
     /// Calculates the width of a string in pixels at the current scale.
     pub fn text_width(&self, text: &str) -> u32 {
         let char_width = (8.0 * self.scale) as u32;

tests/blinking.rs

@@ -1,9 +1,5 @@
 use bevy_ecs::{entity::Entity, system::RunSystemOnce, world::World};
-use pacman::systems::{
-    blinking::{blinking_system, Blinking},
-    components::{DeltaTime, Renderable},
-    Frozen, Hidden,
-};
+use pacman::systems::{blinking_system, Blinking, DeltaTime, Frozen, Hidden, Renderable};
 use speculoos::prelude::*;
 
 mod common;

tests/common.rs

@@ -14,7 +14,8 @@ use pacman::{
     },
     systems::{
         AudioEvent, AudioState, BufferedDirection, Collider, DebugState, DeltaTime, EntityType, Ghost, GhostCollider, GhostState,
-        GlobalState, ItemCollider, MovementModifiers, PacmanCollider, PlayerControlled, Position, ScoreResource, Velocity,
+        GlobalState, ItemCollider, MovementModifiers, PacmanCollider, PelletCount, PlayerControlled, Position, ScoreResource,
+        Velocity,
     },
     texture::sprite::{AtlasMapper, AtlasTile, SpriteAtlas},
 };
@@ -85,6 +86,7 @@ pub fn create_test_world() -> World {
     world.insert_resource(AudioState::default());
     world.insert_resource(GlobalState { exit: false });
     world.insert_resource(DebugState::default());
+    world.insert_resource(PelletCount(0));
     world.insert_resource(DeltaTime {
         seconds: 1.0 / 60.0,
         ticks: 1,

tests/error.rs

@@ -1,66 +0,0 @@
-use pacman::error::{GameError, GameResult, IntoGameError, OptionExt, ResultExt};
-use speculoos::prelude::*;
-use std::io;
-
-#[test]
-fn test_into_game_error_trait() {
-    let result: Result<i32, io::Error> = Err(io::Error::new(io::ErrorKind::Other, "test error"));
-    let game_result: GameResult<i32> = result.into_game_error();
-
-    assert_that(&game_result.is_err()).is_true();
-    if let Err(GameError::InvalidState(msg)) = game_result {
-        assert_that(&msg.contains("test error")).is_true();
-    } else {
-        panic!("Expected InvalidState error");
-    }
-}
-
-#[test]
-fn test_into_game_error_trait_success() {
-    let result: Result<i32, io::Error> = Ok(42);
-    let game_result: GameResult<i32> = result.into_game_error();
-
-    assert_that(&game_result.unwrap()).is_equal_to(42);
-}
-
-#[test]
-fn test_option_ext_some() {
-    let option: Option<i32> = Some(42);
-    let result: GameResult<i32> = option.ok_or_game_error(|| GameError::InvalidState("Not found".to_string()));
-
-    assert_that(&result.unwrap()).is_equal_to(42);
-}
-
-#[test]
-fn test_option_ext_none() {
-    let option: Option<i32> = None;
-    let result: GameResult<i32> = option.ok_or_game_error(|| GameError::InvalidState("Not found".to_string()));
-
-    assert_that(&result.is_err()).is_true();
-    if let Err(GameError::InvalidState(msg)) = result {
-        assert_that(&msg).is_equal_to("Not found".to_string());
-    } else {
-        panic!("Expected InvalidState error");
-    }
-}
-
-#[test]
-fn test_result_ext_success() {
-    let result: Result<i32, io::Error> = Ok(42);
-    let game_result: GameResult<i32> = result.with_context(|_| GameError::InvalidState("Context".to_string()));
-
-    assert_that(&game_result.unwrap()).is_equal_to(42);
-}
-
-#[test]
-fn test_result_ext_error() {
-    let result: Result<i32, io::Error> = Err(io::Error::new(io::ErrorKind::Other, "original error"));
-    let game_result: GameResult<i32> = result.with_context(|_| GameError::InvalidState("Context error".to_string()));
-
-    assert_that(&game_result.is_err()).is_true();
-    if let Err(GameError::InvalidState(msg)) = game_result {
-        assert_that(&msg).is_equal_to("Context error".to_string());
-    } else {
-        panic!("Expected InvalidState error");
-    }
-}

tests/item.rs

@@ -1,5 +1,5 @@
 use bevy_ecs::{entity::Entity, system::RunSystemOnce};
-use pacman::systems::{is_valid_item_collision, item_system, EntityType, GhostState, Position, ScoreResource};
+use pacman::systems::{item_system, EntityType, GhostState, Position, ScoreResource};
 use speculoos::prelude::*;
 
 mod common;
@@ -24,21 +24,6 @@ fn test_is_collectible_item() {
     assert_that(&EntityType::Ghost.is_collectible()).is_false();
 }
 
-#[test]
-fn test_is_valid_item_collision() {
-    // Player-item collisions should be valid
-    assert_that(&is_valid_item_collision(EntityType::Player, EntityType::Pellet)).is_true();
-    assert_that(&is_valid_item_collision(EntityType::Player, EntityType::PowerPellet)).is_true();
-    assert_that(&is_valid_item_collision(EntityType::Pellet, EntityType::Player)).is_true();
-    assert_that(&is_valid_item_collision(EntityType::PowerPellet, EntityType::Player)).is_true();
-
-    // Non-player-item collisions should be invalid
-    assert_that(&is_valid_item_collision(EntityType::Player, EntityType::Ghost)).is_false();
-    assert_that(&is_valid_item_collision(EntityType::Ghost, EntityType::Pellet)).is_false();
-    assert_that(&is_valid_item_collision(EntityType::Pellet, EntityType::PowerPellet)).is_false();
-    assert_that(&is_valid_item_collision(EntityType::Player, EntityType::Player)).is_false();
-}
-
 #[test]
 fn test_item_system_pellet_collection() {
     let mut world = common::create_test_world();

tests/sprite.rs

@@ -1,70 +0,0 @@
-use glam::U16Vec2;
-use pacman::texture::sprite::{AtlasMapper, AtlasTile, MapperFrame};
-use sdl2::pixels::Color;
-use speculoos::prelude::*;
-use std::collections::HashMap;
-
-mod common;
-
-#[test]
-fn test_atlas_mapper_frame_lookup() {
-    let mut frames = HashMap::new();
-    frames.insert(
-        "test".to_string(),
-        MapperFrame {
-            pos: U16Vec2::new(10, 20),
-            size: U16Vec2::new(32, 64),
-        },
-    );
-
-    let mapper = AtlasMapper { frames };
-
-    // Test direct frame lookup
-    let frame = mapper.frames.get("test");
-    assert_that(&frame.is_some()).is_true();
-    let frame = frame.unwrap();
-    assert_that(&frame.pos).is_equal_to(U16Vec2::new(10, 20));
-    assert_that(&frame.size).is_equal_to(U16Vec2::new(32, 64));
-}
-
-#[test]
-fn test_atlas_mapper_multiple_frames() {
-    let mut frames = HashMap::new();
-    frames.insert(
-        "tile1".to_string(),
-        MapperFrame {
-            pos: U16Vec2::new(0, 0),
-            size: U16Vec2::new(32, 32),
-        },
-    );
-    frames.insert(
-        "tile2".to_string(),
-        MapperFrame {
-            pos: U16Vec2::new(32, 0),
-            size: U16Vec2::new(64, 64),
-        },
-    );
-
-    let mapper = AtlasMapper { frames };
-
-    assert_that(&mapper.frames.len()).is_equal_to(2);
-    assert_that(&mapper.frames.contains_key("tile1")).is_true();
-    assert_that(&mapper.frames.contains_key("tile2")).is_true();
-    assert_that(&mapper.frames.contains_key("tile3")).is_false();
-    assert_that(&mapper.frames.contains_key("nonexistent")).is_false();
-}
-
-#[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_that(&tile.pos).is_equal_to(pos);
-    assert_that(&tile.size).is_equal_to(size);
-    assert_that(&tile.color).is_equal_to(None);
-
-    let tile_with_color = tile.with_color(color);
-    assert_that(&tile_with_color.color).is_equal_to(Some(color));
-}

tests/sprites.rs

@@ -2,7 +2,7 @@
 use pacman::{
     game::ATLAS_FRAMES,
     map::direction::Direction,
-    systems::components::Ghost,
+    systems::Ghost,
     texture::sprites::{FrightenedColor, GameSprite, GhostSprite, MazeSprite, PacmanSprite},
 };
 

tests/text.rs

@@ -81,44 +81,20 @@ fn test_text_scale() -> Result<(), String> {
     let string = "ABCDEFG !-/\"";
     let base_width = (string.len() * 8) as u32;
 
-    let mut text_texture = TextTexture::new(0.5);
-
-    assert_that(&text_texture.scale()).is_equal_to(0.5);
+    let text_texture = TextTexture::new(0.5);
     assert_that(&text_texture.text_height()).is_equal_to(4);
     assert_that(&text_texture.text_width("")).is_equal_to(0);
     assert_that(&text_texture.text_width(string)).is_equal_to(base_width / 2);
 
-    text_texture.set_scale(2.0);
-    assert_that(&text_texture.scale()).is_equal_to(2.0);
+    let text_texture = TextTexture::new(2.0);
     assert_that(&text_texture.text_height()).is_equal_to(16);
     assert_that(&text_texture.text_width(string)).is_equal_to(base_width * 2);
     assert_that(&text_texture.text_width("")).is_equal_to(0);
 
-    text_texture.set_scale(1.0);
-    assert_that(&text_texture.scale()).is_equal_to(1.0);
+    let text_texture = TextTexture::new(1.0);
     assert_that(&text_texture.text_height()).is_equal_to(8);
     assert_that(&text_texture.text_width(string)).is_equal_to(base_width);
     assert_that(&text_texture.text_width("")).is_equal_to(0);
 
     Ok(())
 }
-
-#[test]
-fn test_text_color() -> Result<(), String> {
-    let mut text_texture = TextTexture::new(1.0);
-
-    // Test default color (should be None initially)
-    assert_that(&text_texture.color()).is_equal_to(None);
-
-    // Test setting color
-    let test_color = sdl2::pixels::Color::YELLOW;
-    text_texture.set_color(test_color);
-    assert_that(&text_texture.color()).is_equal_to(Some(test_color));
-
-    // Test changing color
-    let new_color = sdl2::pixels::Color::RED;
-    text_texture.set_color(new_color);
-    assert_that(&text_texture.color()).is_equal_to(Some(new_color));
-
-    Ok(())
-}