feat: entity trait, direction enum (util)

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/game.rs

@@ -1,11 +1,63 @@
-pub struct Game {}
+use sdl2::{pixels::Color, render::Canvas, video::Window};
 
-impl Game {
-    pub fn new() -> Game {
-        Game {}
+use crate::constants::{MapTile, BOARD, BOARD_HEIGHT, BOARD_WIDTH};
+use crate::pacman::Pacman;
+use crate::textures::TextureManager;
+
+pub struct Game<'a> {
+    pub textures: TextureManager<'a>,
+    canvas: &'a mut Canvas<Window>,
+    pacman: Pacman<'a>,
+    debug: bool,
+}
+
+impl Game<'_> {
+    pub fn new<'a>(
+        canvas: &'a mut Canvas<Window>,
+        texture_manager: TextureManager<'a>,
+    ) -> Game<'a> {
+        let pacman = Pacman::new(None, &texture_manager.pacman);
+
+        Game {
+            canvas,
+            textures: texture_manager,
+            pacman: pacman,
+            debug: true,
+        }
     }
 
-    pub fn tick() {}
+    pub fn tick(&mut self) {}
 
-    pub fn draw() {}
-}
+    pub fn draw(&mut self) {
+        // Clear the screen (black)
+        self.canvas.set_draw_color(Color::RGB(0, 0, 0));
+        self.canvas.clear();
+        
+        self.canvas
+            .copy(&self.textures.map, None, None)
+            .expect("Could not render texture on canvas");
+
+        // Draw a grid
+        for x in 0..BOARD_WIDTH {
+            for y in 0..BOARD_HEIGHT {
+                let tile = BOARD[x as usize][y as usize];
+                let 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),
+                };
+
+                if let Some(color) = color {
+                    self.canvas.set_draw_color(color);
+                    self.canvas
+                        .draw_rect(sdl2::rect::Rect::new(x as i32 * 24, y as i32 * 24, 24, 24))
+                        .expect("Could not draw rectangle");
+                }
+            }
+        }
+
+        self.canvas.present();
+    }
+}

src/textures.rs

@@ -0,0 +1,29 @@
+
+use sdl2::{
+    image::LoadTexture,
+    render::{Texture, TextureCreator},
+    video::WindowContext,
+};
+
+pub struct TextureManager<'a> {
+    pub map: Texture<'a>,
+    pub pacman: Texture<'a>,
+}
+
+impl<'a> TextureManager<'a> {
+    pub fn new(texture_creator: &'a TextureCreator<WindowContext>) -> Self {
+        let map_texture = texture_creator
+            .load_texture("assets/map.png")
+            .expect("Could not load pacman texture");
+        
+        let pacman_atlas = texture_creator
+            .load_texture("assets/pacman.png")
+            .expect("Could not load pacman texture");
+        
+        
+        TextureManager {
+            map: map_texture,
+            pacman: pacman_atlas,
+        }
+    }
+}