feat: split animated texture away from atlas texture details

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
-/// frame and the number of frames in the animation.
-pub struct AnimatedTexture<'a> {
-    // Parameters
-    raw_texture: Texture<'a>,
-    offset: (i32, i32),
-    ticks_per_frame: u32,
-    frame_count: u32,
-    width: u32,
-    height: u32,
-    // State
-    ticker: u32,
-    reversed: bool,
-}
-
-impl<'a> AnimatedTexture<'a> {
-    pub fn new(
-        texture: Texture<'a>,
-        ticks_per_frame: u32,
-        frame_count: u32,
-        width: u32,
-        height: u32,
-        offset: Option<(i32, i32)>,
-    ) -> Self {
-        AnimatedTexture {
-            raw_texture: texture,
-            ticker: 0,
-            reversed: false,
-            ticks_per_frame,
-            frame_count,
-            width,
-            height,
-            offset: offset.unwrap_or((0, 0)),
-        }
-    }
-
-    fn current_frame(&self) -> u32 {
-        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,
-            0,
-            self.width,
-            self.height,
-        ))
-    }
-
-    pub fn render(
         &mut self,
         canvas: &mut Canvas<Window>,
         position: (i32, i32),
         direction: Direction,
-    ) {
+        frame: Option<u32>,
-        self.render_static(canvas, position, direction, Some(self.current_frame()));
+    );
-        self.tick();
+}
+
+/// 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>,
+        frame_count: u32,
+        frame_width: u32,
+        frame_height: u32,
+        offset: Option<(i32, i32)>,
+    ) -> Self {
+        AtlasTexture {
+            raw_texture: texture,
+            frame_count,
+            frame_width,
+            frame_height,
+            offset: offset.unwrap_or((0, 0)),
+        }
     }
 
-    /// Renders a specific frame of the animated texture to the canvas.
+    pub fn get_frame_rect(&self, frame: u32) -> Option<Rect> {
-    ///
+        if frame >= self.frame_count {
-    /// This method renders a static frame without advancing the animation ticker.
+            return None;
-    /// 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.
+        Some(Rect::new(
-    ///
+            frame as i32 * self.frame_width as i32,
-    /// # Arguments
+            0,
-    ///
+            self.frame_width,
-    /// * `canvas` - The SDL canvas to render to
+            self.frame_height,
-    /// * `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
+
-    ///
+    pub fn set_color_modulation(&mut self, r: u8, g: u8, b: u8) {
-    /// # Panics
+        self.raw_texture.set_color_mod(r, g, b);
-    ///
+    }
-    /// Panics if the specified frame is out of bounds for this texture.
+}
-    pub fn render_static(
+
+impl<'a> FrameDrawn for AtlasTexture<'a> {
+    fn render(
         &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,88 @@ 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(
+        &mut self,
+        canvas: &mut Canvas<Window>,
+        position: (i32, i32),
+        direction: Direction,
+        frame: Option<u32>,
+    ) {
+        self.atlas.render(
+            canvas,
+            position,
+            direction,
+            frame.or(Some(self.current_frame())),
+        );
+        self.tick();
     }
 }

src/entity.rs

@@ -1,16 +1,166 @@
-//! This module defines the `Entity` trait, which is implemented by all game
+use crate::{
-//! objects that can be moved and rendered.
+    constants::{MapTile, BOARD_OFFSET, BOARD_WIDTH, CELL_SIZE},
+    direction::Direction,
+    map::Map,
+    modulation::SimpleTickModulator,
+};
+use std::cell::RefCell;
+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.
+    fn base(&self) -> &MovableEntity;
+
     /// Returns true if the entity is colliding with the other entity.
-    fn is_colliding(&self, other: &dyn Entity) -> bool;
+    fn is_colliding(&self, other: &dyn Entity) -> bool {
-    /// Returns the absolute position of the entity, in pixels.
+        let (x, y) = self.base().pixel_position;
-    fn position(&self) -> (i32, i32);
+        let (other_x, other_y) = other.base().pixel_position;
-    /// Returns the cell position of the entity, in grid coordinates.
+        x == other_x && y == other_y
-    fn cell_position(&self) -> (u32, u32);
+    }
-    /// Returns the position of the entity within its current cell, in pixels.
+
-    fn internal_position(&self) -> (u32, u32);
     /// Ticks the entity, which updates its state and position.
     fn tick(&mut self);
 }
+
+/// 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 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),
+        direction: Direction,
+        speed: u32,
+        modulation: SimpleTickModulator,
+        map: Rc<RefCell<Map>>,
+    ) -> Self {
+        Self {
+            pixel_position,
+            cell_position,
+            direction,
+            speed,
+            modulation,
+            in_tunnel: false,
+            map,
+        }
+    }
+
+    /// 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.pixel_position.1 as u32 % CELL_SIZE,
+        )
+    }
+
+    /// Move the entity in its current direction by its speed.
+    pub fn move_forward(&mut self) {
+        let speed = self.speed as i32;
+        match self.direction {
+            Direction::Right => self.pixel_position.0 += speed,
+            Direction::Left => self.pixel_position.0 -= speed,
+            Direction::Up => self.pixel_position.1 -= speed,
+            Direction::Down => self.pixel_position.1 += speed,
+        }
+    }
+
+    /// Updates the cell position based on the current pixel position.
+    pub fn update_cell_position(&mut self) {
+        self.cell_position = (
+            (self.pixel_position.0 as u32 / CELL_SIZE) - BOARD_OFFSET.0,
+            (self.pixel_position.1 as u32 / CELL_SIZE) - BOARD_OFFSET.1,
+        );
+    }
+
+    /// 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.cell_position.1 as i32 + y,
+        )
+    }
+
+    /// 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))
+    }
+
+    /// 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
+                .map
+                .borrow()
+                .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.cell_position.0 == 0 {
+                self.cell_position.0 = BOARD_WIDTH - 2;
+                self.pixel_position =
+                    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 {
+                self.cell_position.0 = 1;
+                self.pixel_position =
+                    Map::cell_to_pixel((self.cell_position.0, self.cell_position.1));
+                self.in_tunnel = false;
+                true
+            } else {
+                // Still in tunnel, keep moving
+                true
+            }
+        } else {
+            false
+        }
+    }
+
+    /// Returns true if the entity is aligned with the grid.
+    pub fn is_grid_aligned(&self) -> bool {
+        self.internal_position() == (0, 0)
+    }
+
+    /// 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;
+        }
+        if self.is_wall_ahead(Some(new_direction)) {
+            return false;
+        }
+        self.direction = new_direction;
+        true
+    }
+}
+
+/// A trait for entities that can be rendered to the screen.
+pub trait Renderable {
+    /// Renders the entity to the canvas.
+    fn render(&mut self, canvas: &mut sdl2::render::Canvas<sdl2::video::Window>);
+}

src/game.rs

@@ -13,12 +13,15 @@ use sdl2::{pixels::Color, render::Canvas, video::Window};
 use tracing::event;
 
 use crate::audio::Audio;
-use crate::constants::{MapTile, BOARD_HEIGHT, BOARD_WIDTH, RAW_BOARD};
+use crate::{
-use crate::direction::Direction;
+    animation::{AtlasTexture, FrameDrawn},
-use crate::entity::Entity;
+    constants::{MapTile, BOARD_HEIGHT, BOARD_WIDTH, RAW_BOARD},
-use crate::ghosts::Blinky;
+    direction::Direction,
-use crate::map::Map;
+    entity::{Entity, Renderable},
-use crate::pacman::Pacman;
+    ghosts::blinky::Blinky,
+    map::Map,
+    pacman::Pacman,
+};
 
 // Embed texture data directly into the executable
 static PACMAN_TEXTURE_DATA: &[u8] = include_bytes!("../assets/32/pacman.png");
@@ -40,19 +43,20 @@ 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: AtlasTexture<'a>,
-    power_pellet_texture: Texture<'a>,
+    power_pellet_texture: AtlasTexture<'a>,
     font: Font<'a, 'static>,
     pacman: Rc<RefCell<Pacman<'a>>>,
     map: Rc<std::cell::RefCell<Map>>,
     debug_mode: DebugMode,
     score: u32,
-    audio: Audio,
+    audio: crate::audio::Audio,
     // Add ghost
     blinky: Blinky<'a>,
 }
@@ -102,14 +106,24 @@ impl Game<'_> {
         );
 
         // Load pellet texture from embedded data
-        let pellet_texture = texture_creator
+        let pellet_texture = 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 = 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");
@@ -155,7 +169,8 @@ impl Game<'_> {
             self.debug_mode = match self.debug_mode {
                 DebugMode::None => DebugMode::Grid,
                 DebugMode::Grid => DebugMode::Pathfinding,
-                DebugMode::Pathfinding => DebugMode::None,
+                DebugMode::Pathfinding => DebugMode::ValidPositions,
+                DebugMode::ValidPositions => DebugMode::None,
             };
         }
 
@@ -185,38 +200,28 @@ impl Game<'_> {
         // Reset the score
         self.score = 0;
 
-        // Reset Pacman position
+        // Get valid positions from the cached flood fill
-        let mut pacman = self.pacman.borrow_mut();
+        let mut map = self.map.borrow_mut();
-        pacman.pixel_position = Map::cell_to_pixel((1, 1));
+        let valid_positions = map.get_valid_playable_positions();
-        pacman.cell_position = (1, 1);
-        pacman.in_tunnel = false;
-        pacman.direction = Direction::Right;
-        pacman.next_direction = None;
-        pacman.stopped = false;
-
-        // Reset ghost positions and mode
         let mut rng = rand::rng();
-        let map = self.map.borrow();
-        let mut valid_positions = vec![];
-        for x in 1..(crate::constants::BOARD_WIDTH - 1) {
-            for y in 1..(crate::constants::BOARD_HEIGHT - 1) {
-                let tile_option = map.get_tile((x as i32, y as i32));
 
-                if let Some(tile) = tile_option {
+        // Randomize Pac-Man position
-                    match tile {
+        if let Some(pos) = valid_positions.iter().choose(&mut rng) {
-                        MapTile::Empty | MapTile::Pellet | MapTile::PowerPellet => {
+            let mut pacman = self.pacman.borrow_mut();
-                            valid_positions.push((x, y));
+            pacman.base.pixel_position = Map::cell_to_pixel((pos.x, pos.y));
-                        }
+            pacman.base.cell_position = (pos.x, pos.y);
-                        _ => {}
+            pacman.base.in_tunnel = false;
-                    }
+            pacman.base.direction = Direction::Right;
-                }
+            pacman.next_direction = None;
-            }
+            pacman.stopped = false;
         }
-        if let Some(&(gx, gy)) = valid_positions.iter().choose(&mut rng) {
+
-            self.blinky.pixel_position = Map::cell_to_pixel((gx, gy));
+        // Randomize ghost position
-            self.blinky.cell_position = (gx, gy);
+        if let Some(pos) = valid_positions.iter().choose(&mut rng) {
-            self.blinky.in_tunnel = false;
+            self.blinky.base.pixel_position = Map::cell_to_pixel((pos.x, pos.y));
-            self.blinky.direction = Direction::Left;
+            self.blinky.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;
         }
     }
@@ -231,7 +236,7 @@ impl Game<'_> {
     /// Checks if Pac-Man is currently eating a pellet and updates the game state
     /// accordingly.
     fn check_pellet_eating(&mut self) {
-        let cell_pos = self.pacman.borrow().cell_position();
+        let cell_pos = self.pacman.borrow().base.cell_position;
 
         // Check if there's a pellet at the current position
         let tile = {
@@ -283,18 +288,26 @@ impl Game<'_> {
                     .get_tile((x as i32, y as i32))
                     .unwrap_or(MapTile::Empty);
 
-                let texture = match tile {
+                match tile {
-                    MapTile::Pellet => Some(&self.pellet_texture),
+                    MapTile::Pellet => {
-                    MapTile::PowerPellet => Some(&self.power_pellet_texture),
+                        let position = Map::cell_to_pixel((x, y));
-                    _ => None,
+                        self.pellet_texture.render(
-                };
+                            self.canvas,
-
+                            position,
-                if let Some(texture) = texture {
+                            Direction::Right,
-                    let position = Map::cell_to_pixel((x, y));
+                            Some(0),
-                    let dst_rect = sdl2::rect::Rect::new(position.0, position.1, 24, 24);
+                        );
-                    self.canvas
+                    }
-                        .copy(texture, None, Some(dst_rect))
+                    MapTile::PowerPellet => {
-                        .expect("Could not render pellet");
+                        let position = Map::cell_to_pixel((x, y));
+                        self.power_pellet_texture.render(
+                            self.canvas,
+                            position,
+                            Direction::Right,
+                            Some(0),
+                        );
+                    }
+                    _ => {}
                 }
             }
         }
@@ -319,7 +332,7 @@ impl Game<'_> {
                         .unwrap_or(MapTile::Empty);
                     let mut color = None;
 
-                    if (x, y) == self.pacman.borrow().cell_position() {
+                    if (x, y) == self.pacman.borrow().base.cell_position {
                         self.draw_cell((x, y), Color::CYAN);
                     } else {
                         color = match tile {
@@ -339,10 +352,21 @@ impl Game<'_> {
             }
 
             // Draw the next cell
-            let next_cell = self.pacman.borrow().next_cell(None);
+            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
+            }
+        }
+
         // Pathfinding debug mode
         if self.debug_mode == DebugMode::Pathfinding {
             // Show the current path for Blinky

src/ghost.rs

@@ -1,19 +1,11 @@
 use pathfinding::prelude::dijkstra;
-use sdl2::{
-    pixels::Color,
-    render::{Canvas, Texture},
-    video::Window,
-};
-use std::cell::RefCell;
-use std::rc::Rc;
-
 use rand::Rng;
 
 use crate::{
-    animation::AnimatedTexture,
+    animation::{AnimatedAtlasTexture, FrameDrawn},
-    constants::{MapTile, BOARD_OFFSET, BOARD_WIDTH, CELL_SIZE},
+    constants::{MapTile, BOARD_WIDTH},
     direction::Direction,
-    entity::Entity,
+    entity::{Entity, MovableEntity, Renderable},
     map::Map,
     modulation::{SimpleTickModulator, TickModulator},
     pacman::Pacman,
@@ -45,42 +37,30 @@ pub enum GhostType {
 
 impl GhostType {
     /// Returns the color of the ghost.
-    pub fn color(&self) -> Color {
+    pub fn color(&self) -> sdl2::pixels::Color {
         match self {
-            GhostType::Blinky => Color::RGB(255, 0, 0),
+            GhostType::Blinky => sdl2::pixels::Color::RGB(255, 0, 0),
-            GhostType::Pinky => Color::RGB(255, 184, 255),
+            GhostType::Pinky => sdl2::pixels::Color::RGB(255, 184, 255),
-            GhostType::Inky => Color::RGB(0, 255, 255),
+            GhostType::Inky => sdl2::pixels::Color::RGB(0, 255, 255),
-            GhostType::Clyde => Color::RGB(255, 184, 82),
+            GhostType::Clyde => sdl2::pixels::Color::RGB(255, 184, 82),
         }
     }
 }
 
 /// Base ghost struct that contains common functionality
 pub struct Ghost<'a> {
-    /// The absolute position of the ghost on the board, in pixels
+    /// Shared movement and position fields.
-    pub pixel_position: (i32, i32),
+    pub base: MovableEntity,
-    /// The position of the ghost on the board, in grid coordinates
-    pub cell_position: (u32, u32),
-    /// The current direction of the ghost
-    pub direction: Direction,
     /// The current mode of the ghost
     pub mode: GhostMode,
     /// The type/personality of this ghost
     pub ghost_type: GhostType,
-    /// Reference to the game map
-    pub map: Rc<RefCell<Map>>,
     /// Reference to Pac-Man for targeting
-    pub pacman: Rc<RefCell<Pacman<'a>>>,
+    pub pacman: std::rc::Rc<std::cell::RefCell<Pacman<'a>>>,
-    /// Movement speed
-    speed: u32,
-    /// Movement modulator
-    modulation: SimpleTickModulator,
     /// Ghost body sprite
-    body_sprite: AnimatedTexture<'a>,
+    body_sprite: AnimatedAtlasTexture<'a>,
     /// Ghost eyes sprite
-    eyes_sprite: AnimatedTexture<'a>,
+    eyes_sprite: AnimatedAtlasTexture<'a>,
-    /// Whether the ghost is currently in a tunnel
-    pub in_tunnel: bool,
 }
 
 impl Ghost<'_> {
@@ -88,71 +68,110 @@ impl Ghost<'_> {
     pub fn new<'a>(
         ghost_type: GhostType,
         starting_position: (u32, u32),
-        body_texture: Texture<'a>,
+        body_texture: sdl2::render::Texture<'a>,
-        eyes_texture: Texture<'a>,
+        eyes_texture: sdl2::render::Texture<'a>,
-        map: Rc<RefCell<Map>>,
+        map: std::rc::Rc<std::cell::RefCell<Map>>,
-        pacman: Rc<RefCell<Pacman<'a>>>,
+        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 {
-            pixel_position: Map::cell_to_pixel(starting_position),
+            base: MovableEntity::new(
-            cell_position: starting_position,
+                pixel_position,
-            direction: Direction::Left,
+                starting_position,
+                Direction::Left,
+                3,
+                SimpleTickModulator::new(1.0),
+                map,
+            ),
             mode: GhostMode::Chase,
             ghost_type,
-            map,
             pacman,
-            speed: 3,
-            modulation: SimpleTickModulator::new(1.0),
             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))),
-            in_tunnel: false,
         }
     }
 
-    /// Renders the ghost to the canvas
+    /// Gets the target tile for this ghost based on its current mode
-    pub fn render(&mut self, canvas: &mut Canvas<Window>) {
+    pub fn get_target_tile(&self) -> (i32, i32) {
-        // Render body
+        match self.mode {
-        if self.mode != GhostMode::Eyes {
+            GhostMode::Scatter => self.get_scatter_target(),
-            let color = if self.mode == GhostMode::Frightened {
+            GhostMode::Chase => self.get_chase_target(),
-                Color::RGB(0, 0, 255)
+            GhostMode::Frightened => self.get_random_target(),
-            } else {
+            GhostMode::Eyes => self.get_house_target(),
-                self.ghost_type.color()
+            GhostMode::House => self.get_house_exit_target(),
-            };
+        }
+    }
 
-            self.body_sprite
+    /// Gets this ghost's home corner target for scatter mode
-                .set_color_modulation(color.r, color.g, color.b);
+    fn get_scatter_target(&self) -> (i32, i32) {
-            self.body_sprite
+        match self.ghost_type {
-                .render(canvas, self.pixel_position, Direction::Right);
+            GhostType::Blinky => (25, 0), // Top right
+            GhostType::Pinky => (2, 0),   // Top left
+            GhostType::Inky => (27, 35),  // Bottom right
+            GhostType::Clyde => (0, 35),  // Bottom left
+        }
+    }
+
+    /// Gets a random adjacent tile for frightened mode
+    fn get_random_target(&self) -> (i32, i32) {
+        let mut rng = rand::rng();
+        let mut possible_moves = Vec::new();
+
+        // Check all four directions
+        for dir in &[
+            Direction::Up,
+            Direction::Down,
+            Direction::Left,
+            Direction::Right,
+        ] {
+            // Don't allow reversing direction
+            if *dir == self.base.direction.opposite() {
+                continue;
+            }
+
+            let next_cell = self.base.next_cell(Some(*dir));
+            if !matches!(
+                self.base.map.borrow().get_tile(next_cell),
+                Some(MapTile::Wall)
+            ) {
+                possible_moves.push(next_cell);
+            }
         }
 
-        // Always render eyes on top
+        if possible_moves.is_empty() {
-        let eye_frame = if self.mode == GhostMode::Frightened {
+            // No valid moves, must reverse
-            4 // Frightened frame
+            self.base.next_cell(Some(self.base.direction.opposite()))
         } else {
-            match self.direction {
+            // Choose a random valid move
-                Direction::Right => 0,
+            possible_moves[rng.random_range(0..possible_moves.len())]
-                Direction::Up => 1,
+        }
-                Direction::Left => 2,
+    }
-                Direction::Down => 3,
-            }
-        };
 
-        self.eyes_sprite.render_static(
+    /// Gets the ghost house target for returning eyes
-            canvas,
+    fn get_house_target(&self) -> (i32, i32) {
-            self.pixel_position,
+        (13, 14) // Center of ghost house
-            Direction::Right,
+    }
-            Some(eye_frame),
+
-        );
+    /// Gets the exit point target when leaving house
+    fn get_house_exit_target(&self) -> (i32, i32) {
+        (13, 11) // Just above ghost house
+    }
+
+    /// 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)
     }
 
     /// 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.cell_position;
+        let start = self.base.cell_position;
-        let map = self.map.borrow();
+        let map = self.base.map.borrow();
 
         dijkstra(
             &start,
@@ -188,82 +207,6 @@ impl Ghost<'_> {
         )
     }
 
-    /// Gets the target tile for this ghost based on its current mode
-    pub fn get_target_tile(&self) -> (i32, i32) {
-        match self.mode {
-            GhostMode::Scatter => self.get_scatter_target(),
-            GhostMode::Chase => self.get_chase_target(),
-            GhostMode::Frightened => self.get_random_target(),
-            GhostMode::Eyes => self.get_house_target(),
-            GhostMode::House => self.get_house_exit_target(),
-        }
-    }
-
-    /// Gets this ghost's home corner target for scatter mode
-    fn get_scatter_target(&self) -> (i32, i32) {
-        match self.ghost_type {
-            GhostType::Blinky => (25, 0), // Top right
-            GhostType::Pinky => (2, 0),   // Top left
-            GhostType::Inky => (27, 35),  // Bottom right
-            GhostType::Clyde => (0, 35),  // Bottom left
-        }
-    }
-
-    /// Gets a random adjacent tile for frightened mode
-    fn get_random_target(&self) -> (i32, i32) {
-        let mut rng = rand::thread_rng();
-        let (x, y) = self.cell_position;
-        let mut possible_moves = Vec::new();
-
-        // Check all four directions
-        for dir in &[
-            Direction::Up,
-            Direction::Down,
-            Direction::Left,
-            Direction::Right,
-        ] {
-            // Don't allow reversing direction
-            if *dir == self.direction.opposite() {
-                continue;
-            }
-
-            let (dx, dy) = dir.offset();
-            let next_cell = (x as i32 + dx, y as i32 + dy);
-            let tile = self.map.borrow().get_tile(next_cell);
-            if let Some(MapTile::Wall) = tile {
-                // It's a wall, not a valid move
-            } else {
-                possible_moves.push(next_cell);
-            }
-        }
-
-        if possible_moves.is_empty() {
-            // No valid moves, must reverse
-            let (dx, dy) = self.direction.opposite().offset();
-            return (x as i32 + dx, y as i32 + dy);
-        }
-
-        // Choose a random valid move
-        possible_moves[rng.gen_range(0..possible_moves.len())]
-    }
-
-    /// Gets the ghost house target for returning eyes
-    fn get_house_target(&self) -> (i32, i32) {
-        (13, 14) // Center of ghost house
-    }
-
-    /// Gets the exit point target when leaving house
-    fn get_house_exit_target(&self) -> (i32, i32) {
-        (13, 11) // Just above ghost house
-    }
-
-    /// 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();
-        (pacman.cell_position.0 as i32, pacman.cell_position.1 as i32)
-    }
-
     /// Changes the ghost's mode and handles direction reversal
     pub fn set_mode(&mut self, new_mode: GhostMode) {
         // Don't reverse if going to/from frightened or if in house
@@ -273,30 +216,24 @@ impl Ghost<'_> {
 
         self.mode = new_mode;
 
+        self.base.speed = match new_mode {
+            GhostMode::Chase => 3,
+            GhostMode::Scatter => 2,
+            GhostMode::Frightened => 2,
+            GhostMode::Eyes => 7,
+            GhostMode::House => 0,
+        };
+
         if should_reverse {
-            self.direction = self.direction.opposite();
+            self.base
+                .set_direction_if_valid(self.base.direction.opposite());
         }
     }
 }
 
 impl Entity for Ghost<'_> {
-    fn position(&self) -> (i32, i32) {
+    fn base(&self) -> &MovableEntity {
-        self.pixel_position
+        &self.base
-    }
-
-    fn cell_position(&self) -> (u32, u32) {
-        self.cell_position
-    }
-
-    fn internal_position(&self) -> (u32, u32) {
-        let (x, y) = self.position();
-        (x as u32 % CELL_SIZE, y as u32 % CELL_SIZE)
-    }
-
-    fn is_colliding(&self, other: &dyn Entity) -> bool {
-        let (x, y) = self.position();
-        let (other_x, other_y) = other.position();
-        x == other_x && y == other_y
     }
 
     fn tick(&mut self) {
@@ -305,39 +242,10 @@ impl Entity for Ghost<'_> {
             return;
         }
 
-        if self.internal_position() == (0, 0) {
+        if self.base.is_grid_aligned() {
-            self.cell_position = (
+            self.base.update_cell_position();
-                (self.pixel_position.0 as u32 / CELL_SIZE) - BOARD_OFFSET.0,
-                (self.pixel_position.1 as u32 / CELL_SIZE) - BOARD_OFFSET.1,
-            );
 
-            let current_tile = self
+            if !self.base.handle_tunnel() {
-                .map
-                .borrow()
-                .get_tile((self.cell_position.0 as i32, self.cell_position.1 as i32))
-                .unwrap_or(MapTile::Empty);
-            if current_tile == MapTile::Tunnel {
-                self.in_tunnel = true;
-            }
-
-            // Tunnel logic: if in tunnel, force movement and prevent direction change
-            if self.in_tunnel {
-                // If out of bounds, teleport to the opposite side and exit tunnel
-                if self.cell_position.0 == 0 {
-                    self.cell_position.0 = BOARD_WIDTH - 2;
-                    self.pixel_position =
-                        Map::cell_to_pixel((self.cell_position.0, self.cell_position.1));
-                    self.in_tunnel = false;
-                } else if self.cell_position.0 == BOARD_WIDTH - 1 {
-                    self.cell_position.0 = 1;
-                    self.pixel_position =
-                        Map::cell_to_pixel((self.cell_position.0, self.cell_position.1));
-                    self.in_tunnel = false;
-                } else {
-                    // While in tunnel, do not allow direction change
-                    // and always move in the current direction
-                }
-            } else {
                 // Pathfinding logic (only if not in tunnel)
                 let target_tile = self.get_target_tile();
                 if let Some((path, _)) =
@@ -345,10 +253,10 @@ impl Entity for Ghost<'_> {
                 {
                     if path.len() > 1 {
                         let next_move = path[1];
-                        let (x, y) = self.cell_position;
+                        let (x, y) = self.base.cell_position;
                         let dx = next_move.0 as i32 - x as i32;
                         let dy = next_move.1 as i32 - y as i32;
-                        self.direction = if dx > 0 {
+                        let new_direction = if dx > 0 {
                             Direction::Right
                         } else if dx < 0 {
                             Direction::Left
@@ -357,46 +265,60 @@ impl Entity for Ghost<'_> {
                         } else {
                             Direction::Up
                         };
+                        self.base.set_direction_if_valid(new_direction);
                     }
                 }
             }
 
-            // Check if the next tile in the current direction is a wall
+            // Don't move if the next tile is a wall
-            let (dx, dy) = self.direction.offset();
+            if self.base.is_wall_ahead(None) {
-            let next_cell = (
-                self.cell_position.0 as i32 + dx,
-                self.cell_position.1 as i32 + dy,
-            );
-            let next_tile = self
-                .map
-                .borrow()
-                .get_tile(next_cell)
-                .unwrap_or(MapTile::Empty);
-            if next_tile == MapTile::Wall {
-                // Don't move if the next tile is a wall
                 return;
             }
         }
 
-        if !self.modulation.next() {
+        if self.base.modulation.next() {
-            return;
+            self.base.move_forward();
-        }
 
-        // Update position based on current direction and speed
+            if self.base.is_grid_aligned() {
-        let speed = self.speed as i32;
+                self.base.update_cell_position();
-        match self.direction {
+            }
-            Direction::Right => self.pixel_position.0 += speed,
-            Direction::Left => self.pixel_position.0 -= speed,
-            Direction::Up => self.pixel_position.1 -= speed,
-            Direction::Down => self.pixel_position.1 += speed,
-        }
-
-        // Update cell position when aligned with grid
-        if self.internal_position() == (0, 0) {
-            self.cell_position = (
-                (self.pixel_position.0 as u32 / CELL_SIZE) - BOARD_OFFSET.0,
-                (self.pixel_position.1 as u32 / CELL_SIZE) - BOARD_OFFSET.1,
-            );
         }
     }
 }
+
+impl Renderable for Ghost<'_> {
+    fn render(&mut self, canvas: &mut sdl2::render::Canvas<sdl2::video::Window>) {
+        // Render body
+        if self.mode != GhostMode::Eyes {
+            let color = if self.mode == GhostMode::Frightened {
+                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, None);
+        }
+
+        // Always render eyes on top
+        let eye_frame = if self.mode == GhostMode::Frightened {
+            4 // Frightened frame
+        } else {
+            match self.base.direction {
+                Direction::Right => 0,
+                Direction::Up => 1,
+                Direction::Left => 2,
+                Direction::Down => 3,
+            }
+        };
+
+        self.eyes_sprite.render(
+            canvas,
+            self.base.pixel_position,
+            Direction::Right,
+            Some(eye_frame),
+        );
+    }
+}

src/ghosts/blinky.rs

@@ -5,7 +5,7 @@ use sdl2::render::{Canvas, Texture};
 use sdl2::video::Window;
 
 use crate::{
-    entity::Entity,
+    entity::{Entity, MovableEntity, Renderable},
     ghost::{Ghost, GhostMode, GhostType},
     map::Map,
     pacman::Pacman,
@@ -38,7 +38,8 @@ impl<'a> Blinky<'a> {
     /// Gets Blinky's chase target - directly targets Pac-Man's current position
     fn get_chase_target(&self) -> (i32, i32) {
         let pacman = self.ghost.pacman.borrow();
-        (pacman.cell_position.0 as i32, pacman.cell_position.1 as i32)
+        let cell = pacman.base().cell_position;
+        (cell.0 as i32, cell.1 as i32)
     }
 
     pub fn set_mode(&mut self, mode: GhostMode) {
@@ -46,21 +47,13 @@ impl<'a> Blinky<'a> {
     }
 
     pub fn render(&mut self, canvas: &mut Canvas<Window>) {
-        self.ghost.render(canvas);
+        Renderable::render(&mut self.ghost, canvas);
     }
 }
 
 impl<'a> Entity for Blinky<'a> {
-    fn position(&self) -> (i32, i32) {
+    fn base(&self) -> &MovableEntity {
-        self.ghost.position()
+        self.ghost.base()
-    }
-
-    fn cell_position(&self) -> (u32, u32) {
-        self.ghost.cell_position()
-    }
-
-    fn internal_position(&self) -> (u32, u32) {
-        self.ghost.internal_position()
     }
 
     fn is_colliding(&self, other: &dyn Entity) -> bool {

src/ghosts/mod.rs

@@ -1,3 +1 @@
-mod blinky;
+pub mod blinky;
-
-pub use blinky::Blinky;

src/main.rs

@@ -123,12 +123,7 @@ pub fn main() {
 
     // The target time for each frame of the game loop (60 FPS).
     let loop_time = Duration::from_secs(1) / 60;
-    let mut tick_no = 0u32;
 
-    // The start of a period of time over which we average the frame time.
-    let mut last_averaging_time = Instant::now();
-    // The total time spent sleeping during the current averaging period.
-    let mut sleep_time = Duration::ZERO;
     let mut paused = false;
     // Whether the window is currently shown.
     let mut shown = false;
@@ -203,7 +198,6 @@ pub fn main() {
                     std::thread::sleep(time);
                 }
             }
-            sleep_time += time;
         } else {
             event!(
                 tracing::Level::WARN,
@@ -212,20 +206,6 @@ pub fn main() {
             );
         }
 
-        tick_no += 1;
-
-        // Caclulate and display performance statistics every 60 seconds.
-        const PERIOD: u32 = 60 * 60;
-        let tick_mod = tick_no % PERIOD;
-        if tick_mod % PERIOD == 0 {
-            let average_fps = PERIOD as f32 / last_averaging_time.elapsed().as_secs_f32();
-            let average_sleep = sleep_time / PERIOD;
-            let average_process = loop_time - average_sleep;
-
-            sleep_time = Duration::ZERO;
-            last_averaging_time = Instant::now();
-        }
-
         true
     };
 

src/map.rs

@@ -1,16 +1,42 @@
 //! This module defines the game map and provides functions for interacting with it.
+use rand::seq::IteratorRandom;
+
 use crate::constants::{MapTile, BOARD_OFFSET, CELL_SIZE};
 use crate::constants::{BOARD_HEIGHT, BOARD_WIDTH};
+use std::collections::{HashSet, VecDeque};
+use std::ops::Add;
 
 #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct Position(pub u32, pub u32);
+pub struct SignedPosition {
+    pub x: i32,
+    pub y: i32,
+}
+
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct Position {
+    pub x: u32,
+    pub y: u32,
+}
+
+impl Add<SignedPosition> for Position {
+    type Output = Position;
+    fn add(self, rhs: SignedPosition) -> Self::Output {
+        Position {
+            x: (self.x as i32 + rhs.x) as u32,
+            y: (self.y as i32 + rhs.y) as u32,
+        }
+    }
+}
 
 impl Position {
     pub fn as_i32(&self) -> (i32, i32) {
-        (self.0 as i32, self.1 as i32)
+        (self.x as i32, self.y as i32)
     }
     pub fn wrapping_add(&self, dx: i32, dy: i32) -> Position {
-        Position((self.0 as i32 + dx) as u32, (self.1 as i32 + dy) as u32)
+        Position {
+            x: (self.x as i32 + dx) as u32,
+            y: (self.y as i32 + dy) as u32,
+        }
     }
 }
 
@@ -126,4 +152,74 @@ impl Map {
             ((cell.1 + BOARD_OFFSET.1) * CELL_SIZE) as i32,
         )
     }
+
+    /// Returns a reference to a cached vector of all valid playable positions in the maze.
+    /// This is computed once using a flood fill from a random pellet, and then cached.
+    pub fn get_valid_playable_positions(&mut self) -> &Vec<Position> {
+        use MapTile::*;
+        static mut CACHE: Option<Vec<Position>> = None;
+        // SAFETY: This is only mutated once, and only in this function.
+        unsafe {
+            if let Some(ref cached) = CACHE {
+                return cached;
+            }
+        }
+        // Find a random starting pellet
+        let mut pellet_positions = vec![];
+        for x in 0..BOARD_WIDTH as u32 {
+            for y in 0..BOARD_HEIGHT as u32 {
+                match self.current[x as usize][y as usize] {
+                    Pellet | PowerPellet => pellet_positions.push(Position { x, y }),
+                    _ => {}
+                }
+            }
+        }
+        let mut rng = rand::rng();
+        let &start = pellet_positions
+            .iter()
+            .choose(&mut rng)
+            .expect("No pellet found for flood fill");
+        // Flood fill
+        let mut visited = HashSet::new();
+        let mut queue = VecDeque::new();
+
+        queue.push_back(start);
+        while let Some(pos) = queue.pop_front() {
+            // Mark visited, skip if already visited
+            if !visited.insert(pos) {
+                continue;
+            }
+
+            // Check if the current tile is valid
+            match self.current[pos.x as usize][pos.y as usize] {
+                Empty | Pellet | PowerPellet => {
+                    // Valid, continue flood
+                    for offset in [
+                        SignedPosition { x: -1, y: 0 },
+                        SignedPosition { x: 1, y: 0 },
+                        SignedPosition { x: 0, y: -1 },
+                        SignedPosition { x: 0, y: 1 },
+                    ] {
+                        let neighbor = pos + offset;
+                        if neighbor.x < BOARD_WIDTH as u32 && neighbor.y < BOARD_HEIGHT as u32 {
+                            let neighbor_tile =
+                                self.current[neighbor.x as usize][neighbor.y as usize];
+                            if matches!(neighbor_tile, Empty | Pellet | PowerPellet) {
+                                queue.push_back(neighbor);
+                            }
+                        }
+                    }
+                }
+                StartingPosition(_) | Wall | Tunnel => {
+                    // Not valid, do not continue
+                }
+            }
+        }
+        let mut result: Vec<Position> = visited.into_iter().collect();
+        result.sort_unstable();
+        unsafe {
+            CACHE = Some(result);
+            CACHE.as_ref().unwrap()
+        }
+    }
 }

src/pacman.rs

@@ -9,248 +9,113 @@ use sdl2::{
 use tracing::event;
 
 use crate::{
-    animation::AnimatedTexture,
+    animation::{AnimatedAtlasTexture, FrameDrawn},
-    constants::MapTile,
-    constants::{BOARD_OFFSET, BOARD_WIDTH, CELL_SIZE},
     direction::Direction,
-    entity::Entity,
+    entity::{Entity, MovableEntity, Renderable},
     map::Map,
     modulation::{SimpleTickModulator, TickModulator},
 };
 
 /// The Pac-Man entity.
 pub struct Pacman<'a> {
-    /// The absolute position of Pac-Man on the board, in pixels.
+    /// Shared movement and position fields.
-    pub pixel_position: (i32, i32),
+    pub base: MovableEntity,
-    /// The position of Pac-Man on the board, in grid coordinates.
-    /// This is only updated at the moment Pac-Man is aligned with the grid.
-    pub cell_position: (u32, u32),
-    /// The current direction of Pac-Man.
-    pub direction: Direction,
     /// The next direction of Pac-Man, which will be applied when Pac-Man is next aligned with the grid.
     pub next_direction: Option<Direction>,
     /// Whether Pac-Man is currently stopped.
     pub stopped: bool,
-    map: Rc<RefCell<Map>>,
+    sprite: AnimatedAtlasTexture<'a>,
-    speed: u32,
-    modulation: SimpleTickModulator,
-    sprite: AnimatedTexture<'a>,
-    pub in_tunnel: bool,
 }
 
 impl Pacman<'_> {
     /// Creates a new `Pacman` instance.
-    ///
-    /// # Arguments
-    ///
-    /// * `starting_position` - The starting position of Pac-Man, in grid coordinates.
-    /// * `atlas` - The texture atlas containing the Pac-Man sprites.
-    /// * `map` - A reference to the game map.
     pub fn new<'a>(
         starting_position: (u32, u32),
         atlas: Texture<'a>,
         map: Rc<RefCell<Map>>,
     ) -> Pacman<'a> {
+        let pixel_position = Map::cell_to_pixel(starting_position);
         Pacman {
-            pixel_position: Map::cell_to_pixel(starting_position),
+            base: MovableEntity::new(
-            cell_position: starting_position,
+                pixel_position,
-            direction: Direction::Right,
+                starting_position,
+                Direction::Right,
+                3,
+                SimpleTickModulator::new(1.0),
+                map,
+            ),
             next_direction: None,
-            speed: 3,
-            map,
             stopped: false,
-            modulation: SimpleTickModulator::new(1.0),
+            sprite: AnimatedAtlasTexture::new(atlas, 2, 3, 32, 32, Some((-4, -4))),
-            sprite: AnimatedTexture::new(atlas, 2, 3, 32, 32, Some((-4, -4))),
-            in_tunnel: false,
         }
     }
 
-    /// Renders Pac-Man to the canvas.
-    ///
-    /// # Arguments
-    ///
-    /// * `canvas` - The SDL canvas to render to.
-    pub fn render(&mut self, canvas: &mut Canvas<Window>) {
-        if self.stopped {
-            self.sprite
-                .render_static(canvas, self.pixel_position, self.direction, Some(2));
-        } else {
-            self.sprite
-                .render(canvas, self.pixel_position, self.direction);
-        }
-    }
-
-    /// Calculates the next cell in the given direction.
-    ///
-    /// # Arguments
-    ///
-    /// * `direction` - The direction to check. If `None`, the current direction is used.
-    pub fn next_cell(&self, direction: Option<Direction>) -> (i32, i32) {
-        let (x, y) = direction.unwrap_or(self.direction).offset();
-        let cell = self.cell_position;
-        (cell.0 as i32 + x, cell.1 as i32 + y)
-    }
-
     /// Handles a requested direction change.
-    ///
-    /// The direction change is only applied if the next tile in the requested
-    /// direction is not a wall.
     fn handle_direction_change(&mut self) -> bool {
         match self.next_direction {
-            // If there is no next direction, do nothing.
             None => return false,
-            // If the next direction is the same as the current direction, do nothing.
             Some(next_direction) => {
-                if next_direction == self.direction {
+                if self.base.set_direction_if_valid(next_direction) {
                     self.next_direction = None;
-                    return false;
+                    return true;
                 }
             }
         }
-
+        false
-        // Get the next cell in the proposed direction.
-        let proposed_next_cell = self.next_cell(self.next_direction);
-        let proposed_next_tile = self
-            .map
-            .borrow()
-            .get_tile(proposed_next_cell)
-            .unwrap_or(MapTile::Empty);
-
-        // If the next tile is a wall, do nothing.
-        if proposed_next_tile == MapTile::Wall {
-            return false;
-        }
-
-        // If the next tile is not a wall, change direction.
-        event!(
-            tracing::Level::DEBUG,
-            "Direction change: {:?} -> {:?} at position ({}, {}) internal ({}, {})",
-            self.direction,
-            self.next_direction.unwrap(),
-            self.pixel_position.0,
-            self.pixel_position.1,
-            self.internal_position().0,
-            self.internal_position().1
-        );
-        self.direction = self.next_direction.unwrap();
-        self.next_direction = None;
-
-        true
     }
 
-    /// Returns the internal position of Pac-Man, rounded down to the nearest
+    /// Returns the internal position of Pac-Man, rounded down to the nearest even number.
-    /// even number.
-    ///
-    /// This is used to ensure that Pac-Man is aligned with the grid before
-    /// changing direction.
     fn internal_position_even(&self) -> (u32, u32) {
-        let (x, y) = self.internal_position();
+        let (x, y) = self.base.internal_position();
         ((x / 2u32) * 2u32, (y / 2u32) * 2u32)
     }
 }
 
 impl Entity for Pacman<'_> {
-    fn is_colliding(&self, other: &dyn Entity) -> bool {
+    fn base(&self) -> &MovableEntity {
-        let (x, y) = self.position();
+        &self.base
-        let (other_x, other_y) = other.position();
-        x == other_x && y == other_y
-    }
-
-    fn position(&self) -> (i32, i32) {
-        self.pixel_position
-    }
-
-    fn cell_position(&self) -> (u32, u32) {
-        self.cell_position
-    }
-
-    fn internal_position(&self) -> (u32, u32) {
-        let (x, y) = self.position();
-        (x as u32 % CELL_SIZE, y as u32 % CELL_SIZE)
     }
 
     fn tick(&mut self) {
-        // Pac-Man can only change direction when he is perfectly aligned with the grid.
         let can_change = self.internal_position_even() == (0, 0);
 
         if can_change {
-            self.cell_position = (
+            self.base.update_cell_position();
-                (self.pixel_position.0 as u32 / CELL_SIZE) - BOARD_OFFSET.0,
-                (self.pixel_position.1 as u32 / CELL_SIZE) - BOARD_OFFSET.1,
-            );
 
-            let current_tile = self
+            if !self.base.handle_tunnel() {
-                .map
+                // Handle direction change as normal if not in tunnel
-                .borrow()
-                .get_tile((self.cell_position.0 as i32, self.cell_position.1 as i32))
-                .unwrap_or(MapTile::Empty);
-            if current_tile == MapTile::Tunnel {
-                self.in_tunnel = true;
-            }
-
-            // Tunnel logic: if in tunnel, force movement and prevent direction change
-            if self.in_tunnel {
-                // If out of bounds, teleport to the opposite side and exit tunnel
-                if self.cell_position.0 == 0 {
-                    self.cell_position.0 = BOARD_WIDTH - 2;
-                    self.pixel_position =
-                        Map::cell_to_pixel((self.cell_position.0 + 1, self.cell_position.1));
-                    self.in_tunnel = false;
-                } else if self.cell_position.0 == BOARD_WIDTH - 1 {
-                    self.cell_position.0 = 1;
-                    self.pixel_position =
-                        Map::cell_to_pixel((self.cell_position.0 - 1, self.cell_position.1));
-                    self.in_tunnel = false;
-                } else {
-                    // While in tunnel, do not allow direction change
-                    // and always move in the current direction
-                }
-            } else {
-                // Handle direction change as normal
                 self.handle_direction_change();
 
-                // Check if the next tile in the current direction is a wall.
+                // Check if the next tile in the current direction is a wall
-                let next_tile_position = self.next_cell(None);
+                if !self.stopped && self.base.is_wall_ahead(None) {
-                let next_tile = self
-                    .map
-                    .borrow()
-                    .get_tile(next_tile_position)
-                    .unwrap_or(MapTile::Empty);
-
-                if !self.stopped && next_tile == MapTile::Wall {
                     self.stopped = true;
-                } else if self.stopped && next_tile != MapTile::Wall {
+                } else if self.stopped && !self.base.is_wall_ahead(None) {
                     self.stopped = false;
                 }
             }
         }
 
-        if !self.stopped {
+        if !self.stopped && self.base.modulation.next() {
-            if self.modulation.next() {
+            self.base.move_forward();
-                let speed = self.speed as i32;
+            if self.internal_position_even() == (0, 0) {
-                match self.direction {
+                self.base.update_cell_position();
-                    Direction::Right => {
-                        self.pixel_position.0 += speed;
-                    }
-                    Direction::Left => {
-                        self.pixel_position.0 -= speed;
-                    }
-                    Direction::Up => {
-                        self.pixel_position.1 -= speed;
-                    }
-                    Direction::Down => {
-                        self.pixel_position.1 += speed;
-                    }
-                }
-
-                // Update the cell position if Pac-Man is aligned with the grid.
-                if self.internal_position_even() == (0, 0) {
-                    self.cell_position = (
-                        (self.pixel_position.0 as u32 / CELL_SIZE) - BOARD_OFFSET.0,
-                        (self.pixel_position.1 as u32 / CELL_SIZE) - BOARD_OFFSET.1,
-                    );
-                }
             }
         }
     }
 }
+
+impl Renderable for Pacman<'_> {
+    fn render(&mut self, canvas: &mut Canvas<Window>) {
+        if self.stopped {
+            self.sprite.render(
+                canvas,
+                self.base.pixel_position,
+                self.base.direction,
+                Some(2),
+            );
+        } else {
+            self.sprite
+                .render(canvas, self.base.pixel_position, self.base.direction, None);
+        }
+    }
+}