feat: new PacMan entity, entity trait implementation

src/animation.rs

@@ -0,0 +1,53 @@
+use sdl2::{
+    rect::Rect,
+    render::{Canvas, Texture},
+    video::Window,
+};
+
+pub struct AnimatedTexture<'a> {
+    raw_texture: &'a Texture<'a>,
+    current_frame: u32,
+    frame_count: u32,
+    frame_width: u32,
+    frame_height: u32,
+}
+
+impl<'a> AnimatedTexture<'a> {
+    pub fn new(
+        texture: &'a Texture<'a>,
+        frame_count: u32,
+        frame_width: u32,
+        frame_height: u32,
+    ) -> Self {
+        AnimatedTexture {
+            raw_texture: texture,
+            current_frame: 0,
+            frame_count,
+            frame_width,
+            frame_height,
+        }
+    }
+
+    fn next_frame(&mut self) {
+        self.current_frame = (self.current_frame + 1) % self.frame_count;
+    }
+
+    fn get_frame_rect(&self) -> Rect {
+        Rect::new(
+            (self.current_frame * self.frame_width) as i32,
+            0,
+            self.frame_width,
+            self.frame_height,
+        )
+    }
+
+    pub fn render(&mut self, canvas: &mut Canvas<Window>, position: (i32, i32)) {
+        let frame_rect = self.get_frame_rect();
+        let position_rect = Rect::new(position.0, position.1, self.frame_width, self.frame_height);
+        canvas
+            .copy(&self.raw_texture, frame_rect, position_rect)
+            .expect("Could not render sprite on canvas");
+
+            self.next_frame();
+    }
+}

src/direction.rs

@@ -0,0 +1,6 @@
+pub enum Direction {
+    Up,
+    Down,
+    Left,
+    Right,
+}

src/entity.rs

@@ -0,0 +1,8 @@
+pub trait Entity {
+    // Returns true if the entity is colliding with the other entity
+    fn is_colliding(&self, other: &dyn Entity) -> bool;
+    // Returns the absolute position of the entity
+    fn position(&self) -> (i32, i32);
+    // Returns the cell position of the entity (XY position within the grid)
+    fn cell_position(&self) -> (u32, u32);
+}

src/pacman.rs

@@ -0,0 +1,41 @@
+use sdl2::{render::{Canvas, Texture}, video::Window};
+
+use crate::{direction::Direction, entity::Entity, animation::AnimatedTexture};
+
+pub struct Pacman<'a> {
+    // Absolute position on the board (precise)
+    pub position: (i32, i32),
+    pub direction: Direction,
+    sprite: AnimatedTexture<'a>,
+}
+
+impl Pacman<'_> {
+    pub fn new<'a>(starting_position: Option<(i32, i32)>, atlas: &'a Texture<'a>) -> Pacman<'a> {
+        Pacman {
+            position: starting_position.unwrap_or((0i32, 0i32)),
+            direction: Direction::Right,
+            sprite: AnimatedTexture::new(atlas, 2, 24, 24),
+        }
+    }
+
+    pub fn render(&mut self,  canvas: &mut Canvas<Window>) {
+        self.sprite.render(canvas, self.position);
+    }
+}
+
+impl Entity for Pacman<'_> {
+    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 position(&self) -> (i32, i32) {
+        self.position
+    }
+
+    fn cell_position(&self) -> (u32, u32) {
+        let (x, y) = self.position();
+        (x as u32 / 24, y as u32 / 24)
+    }
+}