feat: new edible type for pellet/powerpellet, fruits, separate static/moving entities

src/animation.rs

@@ -1,4 +1,4 @@
-//! This module provides a simple animation system for textures.
+//! This module provides a simple animation and atlas system for textures.
 use sdl2::{
     rect::Rect,
     render::{Canvas, Texture},
@@ -7,144 +7,75 @@ use sdl2::{
 
 use crate::direction::Direction;
 
-/// An animated texture, which is a texture that is rendered as a series of
+/// Trait for drawable atlas-based textures
-/// frames.
+pub trait FrameDrawn {
-///
+    fn render(
-/// This struct manages the state of an animated texture, including the current
+        &self,
-/// frame and the number of frames in the animation.
+        canvas: &mut Canvas<Window>,
-pub struct AnimatedTexture<'a> {
+        position: (i32, i32),
-    // Parameters
+        direction: Direction,
-    raw_texture: Texture<'a>,
+        frame: Option<u32>,
-    offset: (i32, i32),
+    );
-    ticks_per_frame: u32,
-    frame_count: u32,
-    width: u32,
-    height: u32,
-    // State
-    ticker: u32,
-    reversed: bool,
 }
 
-impl<'a> AnimatedTexture<'a> {
+/// A texture atlas abstraction for static (non-animated) rendering.
+pub struct AtlasTexture<'a> {
+    pub raw_texture: Texture<'a>,
+    pub offset: (i32, i32),
+    pub frame_count: u32,
+    pub frame_width: u32,
+    pub frame_height: u32,
+}
+
+impl<'a> AtlasTexture<'a> {
     pub fn new(
         texture: Texture<'a>,
-        ticks_per_frame: u32,
         frame_count: u32,
-        width: u32,
+        frame_width: u32,
-        height: u32,
+        frame_height: u32,
         offset: Option<(i32, i32)>,
     ) -> Self {
-        AnimatedTexture {
+        AtlasTexture {
             raw_texture: texture,
-            ticker: 0,
-            reversed: false,
-            ticks_per_frame,
             frame_count,
-            width,
+            frame_width,
-            height,
+            frame_height,
             offset: offset.unwrap_or((0, 0)),
         }
     }
 
-    fn current_frame(&self) -> u32 {
+    pub fn get_frame_rect(&self, frame: u32) -> Option<Rect> {
-        self.ticker / self.ticks_per_frame
-    }
-
-    /// Advances the animation by one tick.
-    ///
-    /// This method updates the internal ticker that tracks the current frame
-    /// of the animation. The animation automatically reverses direction when
-    /// it reaches the end, creating a ping-pong effect.
-    ///
-    /// When `reversed` is `false`, the ticker increments until it reaches
-    /// the total number of ticks for all frames, then reverses direction.
-    /// When `reversed` is `true`, the ticker decrements until it reaches 0,
-    /// then reverses direction again.
-    pub fn tick(&mut self) {
-        if self.reversed {
-            self.ticker -= 1;
-
-            if self.ticker == 0 {
-                self.reversed = !self.reversed;
-            }
-        } else {
-            self.ticker += 1;
-
-            if self.ticker + 1 == self.ticks_per_frame * self.frame_count {
-                self.reversed = !self.reversed;
-            }
-        }
-    }
-
-    /// Gets the source rectangle for a specific frame of the animated texture.
-    ///
-    /// This method calculates the position and dimensions of a frame within the
-    /// texture atlas. Frames are arranged horizontally in a single row, so the
-    /// rectangle's x-coordinate is calculated by multiplying the frame index
-    /// by the frame width.
-    ///
-    /// # Arguments
-    ///
-    /// * `frame` - The frame index to get the rectangle for (0-based)
-    ///
-    /// # Returns
-    ///
-    /// A `Rect` representing the source rectangle for the specified frame
-    fn get_frame_rect(&self, frame: u32) -> Option<Rect> {
         if frame >= self.frame_count {
             return None;
         }
-
         Some(Rect::new(
-            frame as i32 * self.width as i32,
+            frame as i32 * self.frame_width as i32,
             0,
-            self.width,
+            self.frame_width,
-            self.height,
+            self.frame_height,
         ))
     }
 
-    pub fn render(
+    pub fn set_color_modulation(&mut self, r: u8, g: u8, b: u8) {
-        &mut self,
+        self.raw_texture.set_color_mod(r, g, b);
-        canvas: &mut Canvas<Window>,
-        position: (i32, i32),
-        direction: Direction,
-    ) {
-        self.render_static(canvas, position, direction, Some(self.current_frame()));
-        self.tick();
     }
+}
 
-    /// Renders a specific frame of the animated texture to the canvas.
+impl<'a> FrameDrawn for AtlasTexture<'a> {
-    ///
+    fn render(
-    /// This method renders a static frame without advancing the animation ticker.
+        &self,
-    /// It's useful for displaying a specific frame, such as when an entity is stopped
-    /// or when you want to manually control which frame is displayed.
-    ///
-    /// # Arguments
-    ///
-    /// * `canvas` - The SDL canvas to render to
-    /// * `position` - The pixel position where the texture should be rendered
-    /// * `direction` - The direction to rotate the texture based on entity facing
-    /// * `frame` - Optional specific frame to render. If `None`, uses the current frame
-    ///
-    /// # Panics
-    ///
-    /// Panics if the specified frame is out of bounds for this texture.
-    pub fn render_static(
-        &mut self,
         canvas: &mut Canvas<Window>,
         position: (i32, i32),
         direction: Direction,
         frame: Option<u32>,
     ) {
-        let texture_source_frame_rect =
+        let texture_source_frame_rect = self.get_frame_rect(frame.unwrap_or(0));
-            self.get_frame_rect(frame.unwrap_or_else(|| self.current_frame()));
         let canvas_destination_rect = Rect::new(
             position.0 + self.offset.0,
             position.1 + self.offset.1,
-            self.width,
+            self.frame_width,
-            self.height,
+            self.frame_height,
         );
-
         canvas
             .copy_ex(
                 &self.raw_texture,
@@ -157,9 +88,83 @@ impl<'a> AnimatedTexture<'a> {
             )
             .expect("Could not render texture on canvas");
     }
+}
+
+/// An animated texture using a texture atlas.
+pub struct AnimatedAtlasTexture<'a> {
+    pub atlas: AtlasTexture<'a>,
+    pub ticks_per_frame: u32,
+    pub ticker: u32,
+    pub reversed: bool,
+    pub paused: bool,
+}
+
+impl<'a> AnimatedAtlasTexture<'a> {
+    pub fn new(
+        texture: Texture<'a>,
+        ticks_per_frame: u32,
+        frame_count: u32,
+        width: u32,
+        height: u32,
+        offset: Option<(i32, i32)>,
+    ) -> Self {
+        AnimatedAtlasTexture {
+            atlas: AtlasTexture::new(texture, frame_count, width, height, offset),
+            ticks_per_frame,
+            ticker: 0,
+            reversed: false,
+            paused: false,
+        }
+    }
+
+    fn current_frame(&self) -> u32 {
+        self.ticker / self.ticks_per_frame
+    }
+
+    /// Advances the animation by one tick, unless paused.
+    pub fn tick(&mut self) {
+        if self.paused {
+            return;
+        }
+        if self.reversed {
+            if self.ticker > 0 {
+                self.ticker -= 1;
+            }
+            if self.ticker == 0 {
+                self.reversed = !self.reversed;
+            }
+        } else {
+            self.ticker += 1;
+            if self.ticker + 1 == self.ticks_per_frame * self.atlas.frame_count {
+                self.reversed = !self.reversed;
+            }
+        }
+    }
+
+    pub fn pause(&mut self) {
+        self.paused = true;
+    }
+    pub fn resume(&mut self) {
+        self.paused = false;
+    }
+    pub fn is_paused(&self) -> bool {
+        self.paused
+    }
 
-    /// Sets the color modulation for the texture.
     pub fn set_color_modulation(&mut self, r: u8, g: u8, b: u8) {
-        self.raw_texture.set_color_mod(r, g, b);
+        self.atlas.set_color_modulation(r, g, b);
+    }
+}
+
+impl<'a> FrameDrawn for AnimatedAtlasTexture<'a> {
+    fn render(
+        &self,
+        canvas: &mut Canvas<Window>,
+        position: (i32, i32),
+        direction: Direction,
+        frame: Option<u32>,
+    ) {
+        let frame = frame.unwrap_or_else(|| self.current_frame());
+        self.atlas.render(canvas, position, direction, Some(frame));
     }
 }

src/constants.rs

@@ -36,6 +36,45 @@ pub enum MapTile {
     Tunnel,
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[repr(u8)]
+pub enum FruitType {
+    Cherry,
+    Strawberry,
+    Orange,
+    Apple,
+    Melon,
+    Galaxian,
+    Bell,
+    Key,
+}
+
+impl FruitType {
+    pub const ALL: [FruitType; 8] = [
+        FruitType::Cherry,
+        FruitType::Strawberry,
+        FruitType::Orange,
+        FruitType::Apple,
+        FruitType::Melon,
+        FruitType::Galaxian,
+        FruitType::Bell,
+        FruitType::Key,
+    ];
+
+    pub fn score(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,
+        }
+    }
+}
+
 /// The raw layout of the game board, as a 2D array of characters.
 pub const RAW_BOARD: [&str; BOARD_HEIGHT as usize] = [
     "############################",

src/debug.rs

@@ -0,0 +1,80 @@
+//! Debug rendering utilities for Pac-Man.
+use crate::{
+    constants::{MapTile, BOARD_HEIGHT, BOARD_WIDTH},
+    direction::Direction,
+    ghosts::blinky::Blinky,
+    map::Map,
+};
+use sdl2::{pixels::Color, render::Canvas, video::Window};
+
+#[derive(PartialEq, Eq, Clone, Copy)]
+pub enum DebugMode {
+    None,
+    Grid,
+    Pathfinding,
+    ValidPositions,
+}
+
+pub struct DebugRenderer;
+
+impl DebugRenderer {
+    pub fn draw_cell(canvas: &mut Canvas<Window>, map: &Map, cell: (u32, u32), color: Color) {
+        let position = Map::cell_to_pixel(cell);
+        canvas.set_draw_color(color);
+        canvas
+            .draw_rect(sdl2::rect::Rect::new(
+                position.0 as i32,
+                position.1 as i32,
+                24,
+                24,
+            ))
+            .expect("Could not draw rectangle");
+    }
+
+    pub fn draw_debug_grid(canvas: &mut Canvas<Window>, map: &Map, pacman_cell: (u32, u32)) {
+        for x in 0..BOARD_WIDTH {
+            for y in 0..BOARD_HEIGHT {
+                let tile = map.get_tile((x as i32, y as i32)).unwrap_or(MapTile::Empty);
+                let mut color = None;
+                if (x, y) == pacman_cell {
+                    Self::draw_cell(canvas, map, (x, y), Color::CYAN);
+                } else {
+                    color = match tile {
+                        MapTile::Empty => None,
+                        MapTile::Wall => Some(Color::BLUE),
+                        MapTile::Pellet => Some(Color::RED),
+                        MapTile::PowerPellet => Some(Color::MAGENTA),
+                        MapTile::StartingPosition(_) => Some(Color::GREEN),
+                        MapTile::Tunnel => Some(Color::CYAN),
+                    };
+                }
+                if let Some(color) = color {
+                    Self::draw_cell(canvas, map, (x, y), color);
+                }
+            }
+        }
+    }
+
+    pub fn draw_next_cell(canvas: &mut Canvas<Window>, map: &Map, next_cell: (u32, u32)) {
+        Self::draw_cell(canvas, map, next_cell, Color::YELLOW);
+    }
+
+    pub fn draw_valid_positions(canvas: &mut Canvas<Window>, map: &mut Map) {
+        let valid_positions_vec = map.get_valid_playable_positions().clone();
+        for &pos in &valid_positions_vec {
+            Self::draw_cell(canvas, map, (pos.x, pos.y), Color::RGB(255, 140, 0));
+            // ORANGE
+        }
+    }
+
+    pub fn draw_pathfinding(canvas: &mut Canvas<Window>, blinky: &Blinky, map: &Map) {
+        if let Some((path, _)) = blinky.get_path_to_target({
+            let (tx, ty) = blinky.get_target_tile();
+            (tx as u32, ty as u32)
+        }) {
+            for &(x, y) in &path {
+                Self::draw_cell(canvas, map, (x, y), Color::YELLOW);
+            }
+        }
+    }
+}

src/edible.rs

@@ -0,0 +1,90 @@
+//! Edible entity for Pac-Man: pellets, power pellets, and fruits.
+use crate::animation::{AtlasTexture, FrameDrawn};
+use crate::constants::{FruitType, MapTile, BOARD_HEIGHT, BOARD_WIDTH};
+use crate::direction::Direction;
+use crate::entity::{Entity, Renderable};
+use crate::map::Map;
+use sdl2::{render::Canvas, video::Window};
+use std::cell::RefCell;
+use std::rc::Rc;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum EdibleKind {
+    Pellet,
+    PowerPellet,
+    Fruit(FruitType),
+}
+
+pub struct Edible<'a> {
+    pub base: crate::entity::StaticEntity,
+    pub kind: EdibleKind,
+    pub sprite: std::rc::Rc<AtlasTexture<'a>>,
+}
+
+impl<'a> Edible<'a> {
+    pub fn new(
+        kind: EdibleKind,
+        cell_position: (u32, u32),
+        sprite: std::rc::Rc<AtlasTexture<'a>>,
+    ) -> Self {
+        let pixel_position = crate::map::Map::cell_to_pixel(cell_position);
+        Edible {
+            base: crate::entity::StaticEntity::new(pixel_position, cell_position),
+            kind,
+            sprite,
+        }
+    }
+
+    /// Checks collision with Pac-Man (or any entity)
+    pub fn collide(&self, pacman: &dyn crate::entity::Entity) -> bool {
+        self.base.is_colliding(pacman)
+    }
+}
+
+impl<'a> Entity for Edible<'a> {
+    fn base(&self) -> &crate::entity::StaticEntity {
+        &self.base
+    }
+}
+
+impl<'a> Renderable for Edible<'a> {
+    fn render(&self, canvas: &mut Canvas<Window>) {
+        self.sprite
+            .render(canvas, self.base.pixel_position, Direction::Right, Some(0));
+    }
+}
+
+/// Reconstruct all edibles from the original map layout
+pub fn reconstruct_edibles<'a>(
+    map: Rc<RefCell<Map>>,
+    pellet_sprite: std::rc::Rc<AtlasTexture<'a>>,
+    power_pellet_sprite: std::rc::Rc<AtlasTexture<'a>>,
+    fruit_sprite: std::rc::Rc<AtlasTexture<'a>>,
+) -> Vec<Edible<'a>> {
+    let mut edibles = Vec::new();
+    for x in 0..BOARD_WIDTH {
+        for y in 0..BOARD_HEIGHT {
+            let tile = map.borrow().get_tile((x as i32, y as i32));
+            let cell = (x, y);
+            match tile {
+                Some(MapTile::Pellet) => {
+                    edibles.push(Edible::new(
+                        EdibleKind::Pellet,
+                        cell,
+                        Rc::clone(&pellet_sprite),
+                    ));
+                }
+                Some(MapTile::PowerPellet) => {
+                    edibles.push(Edible::new(
+                        EdibleKind::PowerPellet,
+                        cell,
+                        Rc::clone(&power_pellet_sprite),
+                    ));
+                }
+                // Fruits can be added here if you have fruit positions
+                _ => {}
+            }
+        }
+    }
+    edibles
+}

src/entity.rs

@@ -9,8 +9,8 @@ use std::rc::Rc;
 
 /// A trait for game objects that can be moved and rendered.
 pub trait Entity {
-    /// Returns a reference to the base MovableEntity.
+    /// Returns a reference to the base entity (position, etc).
-    fn base(&self) -> &MovableEntity;
+    fn base(&self) -> &StaticEntity;
 
     /// Returns true if the entity is colliding with the other entity.
     fn is_colliding(&self, other: &dyn Entity) -> bool {
@@ -18,31 +18,45 @@ pub trait Entity {
         let (other_x, other_y) = other.base().pixel_position;
         x == other_x && y == other_y
     }
+}
 
-    /// Ticks the entity, which updates its state and position.
+/// A trait for entities that can move and interact with the map.
-    fn tick(&mut self);
+pub trait Moving {
+    fn move_forward(&mut self);
+    fn update_cell_position(&mut self);
+    fn next_cell(&self, direction: Option<Direction>) -> (i32, i32);
+    fn is_wall_ahead(&self, direction: Option<Direction>) -> bool;
+    fn handle_tunnel(&mut self) -> bool;
+    fn is_grid_aligned(&self) -> bool;
+    fn set_direction_if_valid(&mut self, new_direction: Direction) -> bool;
+}
+
+/// A struct for static (non-moving) entities with position only.
+pub struct StaticEntity {
+    pub pixel_position: (i32, i32),
+    pub cell_position: (u32, u32),
+}
+
+impl StaticEntity {
+    pub fn new(pixel_position: (i32, i32), cell_position: (u32, u32)) -> Self {
+        Self {
+            pixel_position,
+            cell_position,
+        }
+    }
 }
 
 /// A struct for movable game entities with position, direction, speed, and modulation.
 pub struct MovableEntity {
-    /// The absolute position of the entity on the board, in pixels.
+    pub base: StaticEntity,
-    pub pixel_position: (i32, i32),
-    /// The position of the entity on the board, in grid coordinates.
-    pub cell_position: (u32, u32),
-    /// The current direction of the entity.
     pub direction: Direction,
-    /// Movement speed (pixels per tick).
     pub speed: u32,
-    /// Movement modulator for controlling speed.
     pub modulation: SimpleTickModulator,
-    /// Whether the entity is currently in a tunnel.
     pub in_tunnel: bool,
-    /// Reference to the game map.
     pub map: Rc<RefCell<Map>>,
 }
 
 impl MovableEntity {
-    /// Creates a new MovableEntity.
     pub fn new(
         pixel_position: (i32, i32),
         cell_position: (u32, u32),
@@ -52,8 +66,7 @@ impl MovableEntity {
         map: Rc<RefCell<Map>>,
     ) -> Self {
         Self {
-            pixel_position,
+            base: StaticEntity::new(pixel_position, cell_position),
-            cell_position,
             direction,
             speed,
             modulation,
@@ -65,89 +78,79 @@ impl MovableEntity {
     /// Returns the position within the current cell, in pixels.
     pub fn internal_position(&self) -> (u32, u32) {
         (
-            self.pixel_position.0 as u32 % CELL_SIZE,
+            self.base.pixel_position.0 as u32 % CELL_SIZE,
-            self.pixel_position.1 as u32 % CELL_SIZE,
+            self.base.pixel_position.1 as u32 % CELL_SIZE,
         )
     }
+}
 
-    /// Move the entity in its current direction by its speed.
+impl Entity for MovableEntity {
-    pub fn move_forward(&mut self) {
+    fn base(&self) -> &StaticEntity {
+        &self.base
+    }
+}
+
+impl Moving for MovableEntity {
+    fn move_forward(&mut self) {
         let speed = self.speed as i32;
         match self.direction {
-            Direction::Right => self.pixel_position.0 += speed,
+            Direction::Right => self.base.pixel_position.0 += speed,
-            Direction::Left => self.pixel_position.0 -= speed,
+            Direction::Left => self.base.pixel_position.0 -= speed,
-            Direction::Up => self.pixel_position.1 -= speed,
+            Direction::Up => self.base.pixel_position.1 -= speed,
-            Direction::Down => self.pixel_position.1 += speed,
+            Direction::Down => self.base.pixel_position.1 += speed,
         }
     }
-
+    fn update_cell_position(&mut self) {
-    /// Updates the cell position based on the current pixel position.
+        self.base.cell_position = (
-    pub fn update_cell_position(&mut self) {
+            (self.base.pixel_position.0 as u32 / CELL_SIZE) - BOARD_OFFSET.0,
-        self.cell_position = (
+            (self.base.pixel_position.1 as u32 / CELL_SIZE) - BOARD_OFFSET.1,
-            (self.pixel_position.0 as u32 / CELL_SIZE) - BOARD_OFFSET.0,
-            (self.pixel_position.1 as u32 / CELL_SIZE) - BOARD_OFFSET.1,
         );
     }
-
+    fn next_cell(&self, direction: Option<Direction>) -> (i32, i32) {
-    /// Calculates the next cell in the given direction.
-    pub fn next_cell(&self, direction: Option<Direction>) -> (i32, i32) {
         let (x, y) = direction.unwrap_or(self.direction).offset();
         (
-            self.cell_position.0 as i32 + x,
+            self.base.cell_position.0 as i32 + x,
-            self.cell_position.1 as i32 + y,
+            self.base.cell_position.1 as i32 + y,
         )
     }
-
+    fn is_wall_ahead(&self, direction: Option<Direction>) -> bool {
-    /// Returns true if the next cell in the given direction is a wall.
-    pub fn is_wall_ahead(&self, direction: Option<Direction>) -> bool {
         let next_cell = self.next_cell(direction);
         matches!(self.map.borrow().get_tile(next_cell), Some(MapTile::Wall))
     }
-
+    fn handle_tunnel(&mut self) -> bool {
-    /// Handles tunnel movement and wrapping.
-    /// Returns true if the entity is in a tunnel and was handled.
-    pub fn handle_tunnel(&mut self) -> bool {
         if !self.in_tunnel {
-            let current_tile = self
+            let current_tile = self.map.borrow().get_tile((
-                .map
+                self.base.cell_position.0 as i32,
-                .borrow()
+                self.base.cell_position.1 as i32,
-                .get_tile((self.cell_position.0 as i32, self.cell_position.1 as i32));
+            ));
             if matches!(current_tile, Some(MapTile::Tunnel)) {
                 self.in_tunnel = true;
             }
         }
-
         if self.in_tunnel {
-            // If out of bounds, teleport to the opposite side and exit tunnel
+            if self.base.cell_position.0 == 0 {
-            if self.cell_position.0 == 0 {
+                self.base.cell_position.0 = BOARD_WIDTH - 2;
-                self.cell_position.0 = BOARD_WIDTH - 2;
+                self.base.pixel_position =
-                self.pixel_position =
+                    Map::cell_to_pixel((self.base.cell_position.0, self.base.cell_position.1));
-                    Map::cell_to_pixel((self.cell_position.0, self.cell_position.1));
                 self.in_tunnel = false;
                 true
-            } else if self.cell_position.0 == BOARD_WIDTH - 1 {
+            } else if self.base.cell_position.0 == BOARD_WIDTH - 1 {
-                self.cell_position.0 = 1;
+                self.base.cell_position.0 = 1;
-                self.pixel_position =
+                self.base.pixel_position =
-                    Map::cell_to_pixel((self.cell_position.0, self.cell_position.1));
+                    Map::cell_to_pixel((self.base.cell_position.0, self.base.cell_position.1));
                 self.in_tunnel = false;
                 true
             } else {
-                // Still in tunnel, keep moving
                 true
             }
         } else {
             false
         }
     }
-
+    fn is_grid_aligned(&self) -> bool {
-    /// Returns true if the entity is aligned with the grid.
-    pub fn is_grid_aligned(&self) -> bool {
         self.internal_position() == (0, 0)
     }
-
+    fn set_direction_if_valid(&mut self, new_direction: Direction) -> bool {
-    /// Attempts to set the direction if the next cell is not a wall.
-    /// Returns true if the direction was changed.
-    pub fn set_direction_if_valid(&mut self, new_direction: Direction) -> bool {
         if new_direction == self.direction {
             return false;
         }
@@ -159,8 +162,13 @@ impl MovableEntity {
     }
 }
 
+impl Entity for StaticEntity {
+    fn base(&self) -> &StaticEntity {
+        self
+    }
+}
+
 /// A trait for entities that can be rendered to the screen.
 pub trait Renderable {
-    /// Renders the entity to the canvas.
+    fn render(&self, canvas: &mut sdl2::render::Canvas<sdl2::video::Window>);
-    fn render(&mut self, canvas: &mut sdl2::render::Canvas<sdl2::video::Window>);
 }

src/game.rs

@@ -14,6 +14,7 @@ use tracing::event;
 
 use crate::audio::Audio;
 use crate::{
+    animation::{AtlasTexture, FrameDrawn},
     constants::{MapTile, BOARD_HEIGHT, BOARD_WIDTH, RAW_BOARD},
     direction::Direction,
     entity::{Entity, Renderable},
@@ -22,6 +23,9 @@ use crate::{
     pacman::Pacman,
 };
 
+use crate::debug::{DebugMode, DebugRenderer};
+use crate::edible::{reconstruct_edibles, Edible, EdibleKind};
+
 // Embed texture data directly into the executable
 static PACMAN_TEXTURE_DATA: &[u8] = include_bytes!("../assets/32/pacman.png");
 static PELLET_TEXTURE_DATA: &[u8] = include_bytes!("../assets/24/pellet.png");
@@ -37,27 +41,19 @@ static GHOST_EYES_TEXTURE_DATA: &[u8] = include_bytes!("../assets/32/ghost_eyes.
 ///
 /// This struct contains all the information necessary to run the game, including
 /// the canvas, textures, fonts, game objects, and the current score.
-#[derive(PartialEq, Eq, Clone, Copy)]
-pub enum DebugMode {
-    None,
-    Grid,
-    Pathfinding,
-    ValidPositions,
-}
-
 pub struct Game<'a> {
     canvas: &'a mut Canvas<Window>,
     map_texture: Texture<'a>,
-    pellet_texture: Texture<'a>,
+    pellet_texture: Rc<AtlasTexture<'a>>,
-    power_pellet_texture: Texture<'a>,
+    power_pellet_texture: Rc<AtlasTexture<'a>>,
     font: Font<'a, 'static>,
     pacman: Rc<RefCell<Pacman<'a>>>,
     map: Rc<std::cell::RefCell<Map>>,
     debug_mode: DebugMode,
     score: u32,
     audio: crate::audio::Audio,
-    // Add ghost
     blinky: Blinky<'a>,
+    edibles: Vec<Edible<'a>>,
 }
 
 impl Game<'_> {
@@ -105,14 +101,24 @@ impl Game<'_> {
         );
 
         // Load pellet texture from embedded data
-        let pellet_texture = texture_creator
+        let pellet_texture = Rc::new(AtlasTexture::new(
-            .load_texture_bytes(PELLET_TEXTURE_DATA)
+            texture_creator
-            .expect("Could not load pellet texture from embedded data");
+                .load_texture_bytes(PELLET_TEXTURE_DATA)
-
+                .expect("Could not load pellet texture from embedded data"),
-        // Load power pellet texture from embedded data
+            1,
-        let power_pellet_texture = texture_creator
+            24,
-            .load_texture_bytes(POWER_PELLET_TEXTURE_DATA)
+            24,
-            .expect("Could not load power pellet texture from embedded data");
+            None,
+        ));
+        let power_pellet_texture = Rc::new(AtlasTexture::new(
+            texture_creator
+                .load_texture_bytes(POWER_PELLET_TEXTURE_DATA)
+                .expect("Could not load power pellet texture from embedded data"),
+            1,
+            24,
+            24,
+            None,
+        ));
 
         // Load font from embedded data
         let font_rwops = RWops::from_bytes(FONT_DATA).expect("Failed to create RWops for font");
@@ -128,6 +134,13 @@ impl Game<'_> {
             .expect("Could not load map texture from embedded data");
         map_texture.set_color_mod(0, 0, 255);
 
+        let edibles = reconstruct_edibles(
+            Rc::clone(&map),
+            Rc::clone(&pellet_texture),
+            Rc::clone(&power_pellet_texture),
+            Rc::clone(&pellet_texture), // placeholder for fruit sprite
+        );
+
         Game {
             canvas,
             pacman,
@@ -140,6 +153,7 @@ impl Game<'_> {
             score: 0,
             audio,
             blinky,
+            edibles,
         }
     }
 
@@ -151,7 +165,10 @@ impl Game<'_> {
     pub fn keyboard_event(&mut self, keycode: Keycode) {
         // Change direction
         let direction = Direction::from_keycode(keycode);
-        self.pacman.borrow_mut().next_direction = direction;
+        if direction.is_some() {
+            self.pacman.borrow_mut().next_direction = direction;
+            return;
+        }
 
         // Toggle debug mode
         if keycode == Keycode::Space {
@@ -161,11 +178,13 @@ impl Game<'_> {
                 DebugMode::Pathfinding => DebugMode::ValidPositions,
                 DebugMode::ValidPositions => DebugMode::None,
             };
+            return;
         }
 
         // Reset game
         if keycode == Keycode::R {
             self.reset();
+            return;
         }
     }
 
@@ -197,8 +216,8 @@ impl Game<'_> {
         // Randomize Pac-Man position
         if let Some(pos) = valid_positions.iter().choose(&mut rng) {
             let mut pacman = self.pacman.borrow_mut();
-            pacman.base.pixel_position = Map::cell_to_pixel((pos.x, pos.y));
+            pacman.base.base.pixel_position = Map::cell_to_pixel((pos.x, pos.y));
-            pacman.base.cell_position = (pos.x, pos.y);
+            pacman.base.base.cell_position = (pos.x, pos.y);
             pacman.base.in_tunnel = false;
             pacman.base.direction = Direction::Right;
             pacman.next_direction = None;
@@ -207,54 +226,56 @@ impl Game<'_> {
 
         // Randomize ghost position
         if let Some(pos) = valid_positions.iter().choose(&mut rng) {
-            self.blinky.base.pixel_position = Map::cell_to_pixel((pos.x, pos.y));
+            self.blinky.base.base.pixel_position = Map::cell_to_pixel((pos.x, pos.y));
-            self.blinky.base.cell_position = (pos.x, pos.y);
+            self.blinky.base.base.cell_position = (pos.x, pos.y);
             self.blinky.base.in_tunnel = false;
             self.blinky.base.direction = Direction::Left;
             self.blinky.mode = crate::ghost::GhostMode::Chase;
         }
+
+        self.edibles = reconstruct_edibles(
+            Rc::clone(&self.map),
+            Rc::clone(&self.pellet_texture),
+            Rc::clone(&self.power_pellet_texture),
+            Rc::clone(&self.pellet_texture), // placeholder for fruit sprite
+        );
     }
 
     /// Advances the game by one tick.
     pub fn tick(&mut self) {
-        self.check_pellet_eating();
+        // Advance animation frames for Pacman and Blinky
-        self.pacman.borrow_mut().tick();
+        self.pacman.borrow_mut().sprite.tick();
-        self.blinky.tick();
+        self.blinky.body_sprite.tick();
-    }
+        self.blinky.eyes_sprite.tick();
 
-    /// Checks if Pac-Man is currently eating a pellet and updates the game state
+        let pacman = self.pacman.borrow();
-    /// accordingly.
+        let mut eaten_indices = vec![];
-    fn check_pellet_eating(&mut self) {
+        for (i, edible) in self.edibles.iter().enumerate() {
-        let cell_pos = self.pacman.borrow().base.cell_position;
+            if edible.collide(&*pacman) {
-
+                eaten_indices.push(i);
-        // Check if there's a pellet at the current position
-        let tile = {
-            let map = self.map.borrow();
-            map.get_tile((cell_pos.0 as i32, cell_pos.1 as i32))
-        };
-
-        if let Some(tile) = tile {
-            let pellet_value = match tile {
-                MapTile::Pellet => Some(10),
-                MapTile::PowerPellet => Some(50),
-                _ => None,
-            };
-
-            if let Some(value) = pellet_value {
-                {
-                    let mut map = self.map.borrow_mut();
-                    map.set_tile((cell_pos.0 as i32, cell_pos.1 as i32), MapTile::Empty);
-                }
-                self.add_score(value);
-                self.audio.eat();
-                event!(
-                    tracing::Level::DEBUG,
-                    "Pellet eaten at ({}, {})",
-                    cell_pos.0,
-                    cell_pos.1
-                );
             }
         }
+        drop(pacman); // Release immutable borrow before mutably borrowing self
+        for &i in eaten_indices.iter().rev() {
+            let edible = &self.edibles[i];
+            match edible.kind {
+                EdibleKind::Pellet => {
+                    self.add_score(10);
+                    self.audio.eat();
+                }
+                EdibleKind::PowerPellet => {
+                    self.add_score(50);
+                    self.audio.eat();
+                }
+                EdibleKind::Fruit(_fruit) => {
+                    self.add_score(100);
+                    self.audio.eat();
+                }
+            }
+            self.edibles.remove(i);
+        }
+        self.pacman.borrow_mut().tick();
+        self.blinky.tick();
     }
 
     /// Draws the entire game to the canvas.
@@ -268,33 +289,14 @@ impl Game<'_> {
             .copy(&self.map_texture, None, None)
             .expect("Could not render texture on canvas");
 
-        // Render pellets
+        // Remove old pellet rendering
-        for x in 0..BOARD_WIDTH {
+        // Instead, render all edibles
-            for y in 0..BOARD_HEIGHT {
+        for edible in &self.edibles {
-                let tile = self
+            edible.render(self.canvas);
-                    .map
-                    .borrow()
-                    .get_tile((x as i32, y as i32))
-                    .unwrap_or(MapTile::Empty);
-
-                let texture = match tile {
-                    MapTile::Pellet => Some(&self.pellet_texture),
-                    MapTile::PowerPellet => Some(&self.power_pellet_texture),
-                    _ => None,
-                };
-
-                if let Some(texture) = texture {
-                    let position = Map::cell_to_pixel((x, y));
-                    let dst_rect = sdl2::rect::Rect::new(position.0, position.1, 24, 24);
-                    self.canvas
-                        .copy(texture, None, Some(dst_rect))
-                        .expect("Could not render pellet");
-                }
-            }
         }
 
         // Render Pac-Man
-        self.pacman.borrow_mut().render(self.canvas);
+        self.pacman.borrow().render(self.canvas);
 
         // Render ghost
         self.blinky.render(self.canvas);
@@ -303,88 +305,34 @@ impl Game<'_> {
         self.render_ui();
 
         // Draw the debug grid
-        if self.debug_mode == DebugMode::Grid {
+        match self.debug_mode {
-            for x in 0..BOARD_WIDTH {
+            DebugMode::Grid => {
-                for y in 0..BOARD_HEIGHT {
+                DebugRenderer::draw_debug_grid(
-                    let tile = self
+                    self.canvas,
-                        .map
+                    &self.map.borrow(),
-                        .borrow()
+                    self.pacman.borrow().base.base.cell_position,
-                        .get_tile((x as i32, y as i32))
+                );
-                        .unwrap_or(MapTile::Empty);
+                let next_cell =
-                    let mut color = None;
+                    <Pacman as crate::entity::Moving>::next_cell(&*self.pacman.borrow(), None);
-
+                DebugRenderer::draw_next_cell(
-                    if (x, y) == self.pacman.borrow().base.cell_position {
+                    self.canvas,
-                        self.draw_cell((x, y), Color::CYAN);
+                    &self.map.borrow(),
-                    } else {
+                    (next_cell.0 as u32, next_cell.1 as u32),
-                        color = match tile {
+                );
-                            MapTile::Empty => None,
-                            MapTile::Wall => Some(Color::BLUE),
-                            MapTile::Pellet => Some(Color::RED),
-                            MapTile::PowerPellet => Some(Color::MAGENTA),
-                            MapTile::StartingPosition(_) => Some(Color::GREEN),
-                            MapTile::Tunnel => Some(Color::CYAN),
-                        };
-                    }
-
-                    if let Some(color) = color {
-                        self.draw_cell((x, y), color);
-                    }
-                }
             }
-
+            DebugMode::ValidPositions => {
-            // Draw the next cell
+                DebugRenderer::draw_valid_positions(self.canvas, &mut self.map.borrow_mut());
-            let next_cell = self.pacman.borrow().base.next_cell(None);
-            self.draw_cell((next_cell.0 as u32, next_cell.1 as u32), Color::YELLOW);
-        }
-
-        // Show valid playable positions
-        if self.debug_mode == DebugMode::ValidPositions {
-            let valid_positions_vec = {
-                let mut map = self.map.borrow_mut();
-                map.get_valid_playable_positions().clone()
-            };
-            for &pos in &valid_positions_vec {
-                self.draw_cell((pos.x, pos.y), Color::RGB(255, 140, 0)); // ORANGE
             }
-        }
+            DebugMode::Pathfinding => {
-
+                DebugRenderer::draw_pathfinding(self.canvas, &self.blinky, &self.map.borrow());
-        // Pathfinding debug mode
-        if self.debug_mode == DebugMode::Pathfinding {
-            // Show the current path for Blinky
-            if let Some((path, _)) = self.blinky.get_path_to_target({
-                let (tx, ty) = self.blinky.get_target_tile();
-                (tx as u32, ty as u32)
-            }) {
-                for &(x, y) in &path {
-                    self.draw_cell((x, y), Color::YELLOW);
-                }
             }
+            DebugMode::None => {}
         }
 
         // Present the canvas
         self.canvas.present();
     }
 
-    /// Draws a single cell to the canvas with the given color.
-    ///
-    /// # Arguments
-    ///
-    /// * `cell` - The cell to draw, in grid coordinates.
-    /// * `color` - The color to draw the cell with.
-    fn draw_cell(&mut self, cell: (u32, u32), color: Color) {
-        let position = Map::cell_to_pixel(cell);
-
-        self.canvas.set_draw_color(color);
-        self.canvas
-            .draw_rect(sdl2::rect::Rect::new(
-                position.0 as i32,
-                position.1 as i32,
-                24,
-                24,
-            ))
-            .expect("Could not draw rectangle");
-    }
-
     /// Renders the user interface, including the score and lives.
     fn render_ui(&mut self) {
         let lives = 3;

src/ghost.rs

@@ -2,10 +2,10 @@ use pathfinding::prelude::dijkstra;
 use rand::Rng;
 
 use crate::{
-    animation::AnimatedTexture,
+    animation::{AnimatedAtlasTexture, FrameDrawn},
     constants::{MapTile, BOARD_WIDTH},
     direction::Direction,
-    entity::{Entity, MovableEntity, Renderable},
+    entity::{Entity, MovableEntity, Moving, Renderable, StaticEntity},
     map::Map,
     modulation::{SimpleTickModulator, TickModulator},
     pacman::Pacman,
@@ -57,10 +57,8 @@ pub struct Ghost<'a> {
     pub ghost_type: GhostType,
     /// Reference to Pac-Man for targeting
     pub pacman: std::rc::Rc<std::cell::RefCell<Pacman<'a>>>,
-    /// Ghost body sprite
+    pub body_sprite: AnimatedAtlasTexture<'a>,
-    body_sprite: AnimatedTexture<'a>,
+    pub eyes_sprite: AnimatedAtlasTexture<'a>,
-    /// Ghost eyes sprite
-    eyes_sprite: AnimatedTexture<'a>,
 }
 
 impl Ghost<'_> {
@@ -74,7 +72,7 @@ impl Ghost<'_> {
         pacman: std::rc::Rc<std::cell::RefCell<Pacman<'a>>>,
     ) -> Ghost<'a> {
         let color = ghost_type.color();
-        let mut body_sprite = AnimatedTexture::new(body_texture, 8, 2, 32, 32, Some((-4, -4)));
+        let mut body_sprite = AnimatedAtlasTexture::new(body_texture, 8, 2, 32, 32, Some((-4, -4)));
         body_sprite.set_color_modulation(color.r, color.g, color.b);
         let pixel_position = Map::cell_to_pixel(starting_position);
         Ghost {
@@ -90,7 +88,7 @@ impl Ghost<'_> {
             ghost_type,
             pacman,
             body_sprite,
-            eyes_sprite: AnimatedTexture::new(eyes_texture, 1, 4, 32, 32, Some((-4, -4))),
+            eyes_sprite: AnimatedAtlasTexture::new(eyes_texture, 1, 4, 32, 32, Some((-4, -4))),
         }
     }
 
@@ -162,7 +160,6 @@ impl Ghost<'_> {
 
     /// Gets this ghost's chase mode target (to be implemented by each ghost type)
     fn get_chase_target(&self) -> (i32, i32) {
-        // Default implementation just targets Pac-Man directly
         let pacman = self.pacman.borrow();
         let cell = pacman.base().cell_position;
         (cell.0 as i32, cell.1 as i32)
@@ -170,7 +167,7 @@ impl Ghost<'_> {
 
     /// Calculates the path to the target tile using the A* algorithm.
     pub fn get_path_to_target(&self, target: (u32, u32)) -> Option<(Vec<(u32, u32)>, u32)> {
-        let start = self.base.cell_position;
+        let start = self.base.base.cell_position;
         let map = self.base.map.borrow();
 
         dijkstra(
@@ -229,14 +226,8 @@ impl Ghost<'_> {
                 .set_direction_if_valid(self.base.direction.opposite());
         }
     }
-}
 
-impl Entity for Ghost<'_> {
+    pub fn tick(&mut self) {
-    fn base(&self) -> &MovableEntity {
-        &self.base
-    }
-
-    fn tick(&mut self) {
         if self.mode == GhostMode::House {
             // For now, do nothing in the house
             return;
@@ -253,7 +244,7 @@ impl Entity for Ghost<'_> {
                 {
                     if path.len() > 1 {
                         let next_move = path[1];
-                        let (x, y) = self.base.cell_position;
+                        let (x, y) = self.base.base.cell_position;
                         let dx = next_move.0 as i32 - x as i32;
                         let dy = next_move.1 as i32 - y as i32;
                         let new_direction = if dx > 0 {
@@ -286,23 +277,35 @@ impl Entity for Ghost<'_> {
     }
 }
 
+impl<'a> Moving for Ghost<'a> {
+    fn move_forward(&mut self) {
+        self.base.move_forward();
+    }
+    fn update_cell_position(&mut self) {
+        self.base.update_cell_position();
+    }
+    fn next_cell(&self, direction: Option<Direction>) -> (i32, i32) {
+        self.base.next_cell(direction)
+    }
+    fn is_wall_ahead(&self, direction: Option<Direction>) -> bool {
+        self.base.is_wall_ahead(direction)
+    }
+    fn handle_tunnel(&mut self) -> bool {
+        self.base.handle_tunnel()
+    }
+    fn is_grid_aligned(&self) -> bool {
+        self.base.is_grid_aligned()
+    }
+    fn set_direction_if_valid(&mut self, new_direction: Direction) -> bool {
+        self.base.set_direction_if_valid(new_direction)
+    }
+}
+
 impl Renderable for Ghost<'_> {
-    fn render(&mut self, canvas: &mut sdl2::render::Canvas<sdl2::video::Window>) {
+    fn render(&self, canvas: &mut sdl2::render::Canvas<sdl2::video::Window>) {
-        // Render body
+        let pos = self.base.base.pixel_position;
-        if self.mode != GhostMode::Eyes {
+        self.body_sprite.render(canvas, pos, Direction::Right, None);
-            let color = if self.mode == GhostMode::Frightened {
+        // Inline the eye_frame logic here
-                sdl2::pixels::Color::RGB(0, 0, 255)
-            } else {
-                self.ghost_type.color()
-            };
-
-            self.body_sprite
-                .set_color_modulation(color.r, color.g, color.b);
-            self.body_sprite
-                .render(canvas, self.base.pixel_position, Direction::Right);
-        }
-
-        // Always render eyes on top
         let eye_frame = if self.mode == GhostMode::Frightened {
             4 // Frightened frame
         } else {
@@ -313,12 +316,7 @@ impl Renderable for Ghost<'_> {
                 Direction::Down => 3,
             }
         };
-
+        self.eyes_sprite
-        self.eyes_sprite.render_static(
+            .render(canvas, pos, Direction::Right, Some(eye_frame));
-            canvas,
-            self.base.pixel_position,
-            Direction::Right,
-            Some(eye_frame),
-        );
     }
 }

src/ghosts/blinky.rs

@@ -46,22 +46,44 @@ impl<'a> Blinky<'a> {
         self.ghost.set_mode(mode);
     }
 
-    pub fn render(&mut self, canvas: &mut Canvas<Window>) {
+    pub fn tick(&mut self) {
-        Renderable::render(&mut self.ghost, canvas);
+        self.ghost.tick();
     }
 }
 
-impl<'a> Entity for Blinky<'a> {
+impl<'a> crate::entity::Entity for Blinky<'a> {
-    fn base(&self) -> &MovableEntity {
+    fn base(&self) -> &crate::entity::StaticEntity {
-        self.ghost.base()
+        self.ghost.base.base()
     }
+}
 
-    fn is_colliding(&self, other: &dyn Entity) -> bool {
+impl<'a> crate::entity::Renderable for Blinky<'a> {
-        self.ghost.is_colliding(other)
+    fn render(&self, canvas: &mut Canvas<Window>) {
+        self.ghost.render(canvas);
     }
+}
 
-    fn tick(&mut self) {
+impl<'a> crate::entity::Moving for Blinky<'a> {
-        self.ghost.tick()
+    fn move_forward(&mut self) {
+        self.ghost.move_forward();
+    }
+    fn update_cell_position(&mut self) {
+        self.ghost.update_cell_position();
+    }
+    fn next_cell(&self, direction: Option<crate::direction::Direction>) -> (i32, i32) {
+        self.ghost.next_cell(direction)
+    }
+    fn is_wall_ahead(&self, direction: Option<crate::direction::Direction>) -> bool {
+        self.ghost.is_wall_ahead(direction)
+    }
+    fn handle_tunnel(&mut self) -> bool {
+        self.ghost.handle_tunnel()
+    }
+    fn is_grid_aligned(&self) -> bool {
+        self.ghost.is_grid_aligned()
+    }
+    fn set_direction_if_valid(&mut self, new_direction: crate::direction::Direction) -> bool {
+        self.ghost.set_direction_if_valid(new_direction)
     }
 }
 

src/main.rs

@@ -64,6 +64,8 @@ mod helper;
 mod map;
 mod modulation;
 mod pacman;
+mod debug;
+mod edible;
 
 /// The main entry point of the application.
 ///

src/map.rs

@@ -28,6 +28,12 @@ impl Add<SignedPosition> for Position {
     }
 }
 
+impl PartialEq<(u32, u32)> for Position {
+    fn eq(&self, other: &(u32, u32)) -> bool {
+        self.x == other.0 && self.y == other.1
+    }
+}
+
 impl Position {
     pub fn as_i32(&self) -> (i32, i32) {
         (self.x as i32, self.y as i32)

src/pacman.rs

@@ -9,9 +9,9 @@ use sdl2::{
 use tracing::event;
 
 use crate::{
-    animation::AnimatedTexture,
+    animation::{AnimatedAtlasTexture, FrameDrawn},
     direction::Direction,
-    entity::{Entity, MovableEntity, Renderable},
+    entity::{Entity, MovableEntity, Moving, Renderable, StaticEntity},
     map::Map,
     modulation::{SimpleTickModulator, TickModulator},
 };
@@ -24,7 +24,37 @@ pub struct Pacman<'a> {
     pub next_direction: Option<Direction>,
     /// Whether Pac-Man is currently stopped.
     pub stopped: bool,
-    sprite: AnimatedTexture<'a>,
+    pub sprite: AnimatedAtlasTexture<'a>,
+}
+
+impl<'a> Entity for Pacman<'a> {
+    fn base(&self) -> &StaticEntity {
+        &self.base.base
+    }
+}
+
+impl<'a> Moving for Pacman<'a> {
+    fn move_forward(&mut self) {
+        self.base.move_forward();
+    }
+    fn update_cell_position(&mut self) {
+        self.base.update_cell_position();
+    }
+    fn next_cell(&self, direction: Option<Direction>) -> (i32, i32) {
+        self.base.next_cell(direction)
+    }
+    fn is_wall_ahead(&self, direction: Option<Direction>) -> bool {
+        self.base.is_wall_ahead(direction)
+    }
+    fn handle_tunnel(&mut self) -> bool {
+        self.base.handle_tunnel()
+    }
+    fn is_grid_aligned(&self) -> bool {
+        self.base.is_grid_aligned()
+    }
+    fn set_direction_if_valid(&mut self, new_direction: Direction) -> bool {
+        self.base.set_direction_if_valid(new_direction)
+    }
 }
 
 impl Pacman<'_> {
@@ -46,7 +76,7 @@ impl Pacman<'_> {
             ),
             next_direction: None,
             stopped: false,
-            sprite: AnimatedTexture::new(atlas, 2, 3, 32, 32, Some((-4, -4))),
+            sprite: AnimatedAtlasTexture::new(atlas, 2, 3, 32, 32, Some((-4, -4))),
         }
     }
 
@@ -55,7 +85,7 @@ impl Pacman<'_> {
         match self.next_direction {
             None => return false,
             Some(next_direction) => {
-                if self.base.set_direction_if_valid(next_direction) {
+                if <Pacman as Moving>::set_direction_if_valid(self, next_direction) {
                     self.next_direction = None;
                     return true;
                 }
@@ -69,53 +99,37 @@ impl Pacman<'_> {
         let (x, y) = self.base.internal_position();
         ((x / 2u32) * 2u32, (y / 2u32) * 2u32)
     }
-}
 
-impl Entity for Pacman<'_> {
+    pub fn tick(&mut self) {
-    fn base(&self) -> &MovableEntity {
-        &self.base
-    }
-
-    fn tick(&mut self) {
         let can_change = self.internal_position_even() == (0, 0);
-
         if can_change {
-            self.base.update_cell_position();
+            <Pacman as Moving>::update_cell_position(self);
-
+            if !<Pacman as Moving>::handle_tunnel(self) {
-            if !self.base.handle_tunnel() {
-                // Handle direction change as normal if not in tunnel
                 self.handle_direction_change();
-
+                if !self.stopped && <Pacman as Moving>::is_wall_ahead(self, None) {
-                // Check if the next tile in the current direction is a wall
-                if !self.stopped && self.base.is_wall_ahead(None) {
                     self.stopped = true;
-                } else if self.stopped && !self.base.is_wall_ahead(None) {
+                } else if self.stopped && !<Pacman as Moving>::is_wall_ahead(self, None) {
                     self.stopped = false;
                 }
             }
         }
-
         if !self.stopped && self.base.modulation.next() {
-            self.base.move_forward();
+            <Pacman as Moving>::move_forward(self);
             if self.internal_position_even() == (0, 0) {
-                self.base.update_cell_position();
+                <Pacman as Moving>::update_cell_position(self);
             }
         }
     }
 }
 
 impl Renderable for Pacman<'_> {
-    fn render(&mut self, canvas: &mut Canvas<Window>) {
+    fn render(&self, canvas: &mut Canvas<Window>) {
+        let pos = self.base.base.pixel_position;
+        let dir = self.base.direction;
         if self.stopped {
-            self.sprite.render_static(
+            self.sprite.render(canvas, pos, dir, Some(2));
-                canvas,
-                self.base.pixel_position,
-                self.base.direction,
-                Some(2),
-            );
         } else {
-            self.sprite
+            self.sprite.render(canvas, pos, dir, None);
-                .render(canvas, self.base.pixel_position, self.base.direction);
         }
     }
 }