feat: change starting position of PacMan, draw current PacMan on grid

src/animation.rs

@@ -10,6 +10,7 @@ pub struct AnimatedTexture<'a> {
     raw_texture: Texture<'a>,
     ticker: u32,
     reversed: bool,
+    offset: (i32, i32),
     ticks_per_frame: u32,
     frame_count: u32,
     frame_width: u32,
@@ -23,6 +24,7 @@ impl<'a> AnimatedTexture<'a> {
         frame_count: u32,
         frame_width: u32,
         frame_height: u32,
+        offset: Option<(i32, i32)>,
     ) -> Self {
         AnimatedTexture {
             raw_texture: texture,
@@ -32,6 +34,7 @@ impl<'a> AnimatedTexture<'a> {
             frame_count,
             frame_width,
             frame_height,
+            offset: offset.unwrap_or((0, 0)),
         }
     }
 
@@ -71,7 +74,12 @@ impl<'a> AnimatedTexture<'a> {
         direction: Direction,
     ) {
         let frame_rect = self.get_frame_rect();
-        let position_rect = Rect::new(position.0, position.1, self.frame_width, self.frame_height);
+        let position_rect = Rect::new(
+            position.0 + self.offset.0,
+            position.1 + self.offset.1,
+            self.frame_width,
+            self.frame_height,
+        );
 
         canvas
             .copy_ex(

src/entity.rs

@@ -5,6 +5,7 @@ pub trait Entity {
     fn position(&self) -> (i32, i32);
     // Returns the cell position of the entity (XY position within the grid)
     fn cell_position(&self) -> (u32, u32);
+    fn internal_position(&self) -> (u32, u32);
     // Tick the entity (move it, perform collision checks, etc) 
     fn tick(&mut self);
 }

src/game.rs

@@ -1,13 +1,13 @@
 use sdl2::image::LoadTexture;
 use sdl2::keyboard::Keycode;
-use sdl2::render::{TextureCreator, Texture};
+use sdl2::render::{Texture, TextureCreator};
 use sdl2::video::WindowContext;
 use sdl2::{pixels::Color, render::Canvas, video::Window};
 
 use crate::constants::{MapTile, BOARD, BOARD_HEIGHT, BOARD_WIDTH};
 use crate::direction::Direction;
 use crate::entity::Entity;
-use crate::pacman::{Pacman};
+use crate::pacman::Pacman;
 
 pub struct Game<'a> {
     canvas: &'a mut Canvas<Window>,
@@ -24,31 +24,35 @@ impl Game<'_> {
         let pacman_atlas = texture_creator
             .load_texture("assets/32/pacman.png")
             .expect("Could not load pacman texture");
-        let pacman = Pacman::new(None, pacman_atlas);
+        let pacman = Pacman::new(Some(Game::cell_to_pixel((1, 4))), pacman_atlas);
 
         Game {
             canvas,
             pacman: pacman,
-            debug: true,
+            debug: false,
             map_texture: texture_creator
                 .load_texture("assets/map.png")
                 .expect("Could not load pacman texture"),
         }
     }
 
+    pub fn cell_to_pixel(cell: (u32, u32)) -> (i32, i32) {
+        ((cell.0 as i32 * 24), ((cell.1) as i32 * 24))
+    }
+
     pub fn keyboard_event(&mut self, keycode: Keycode) {
         match keycode {
             Keycode::D => {
-                self.pacman.direction = Direction::Right;
+                self.pacman.next_direction = Some(Direction::Right);
             }
             Keycode::A => {
-                self.pacman.direction = Direction::Left;
+                self.pacman.next_direction = Some(Direction::Left);
             }
             Keycode::W => {
-                self.pacman.direction = Direction::Up;
+                self.pacman.next_direction = Some(Direction::Up);
             }
             Keycode::S => {
-                self.pacman.direction = Direction::Down;
+                self.pacman.next_direction = Some(Direction::Down);
             }
             Keycode::Space => {
                 self.debug = !self.debug;
@@ -65,7 +69,7 @@ impl Game<'_> {
         // Clear the screen (black)
         self.canvas.set_draw_color(Color::RGB(0, 0, 0));
         self.canvas.clear();
-        
+
         self.canvas
             .copy(&self.map_texture, None, None)
             .expect("Could not render texture on canvas");
@@ -74,26 +78,43 @@ impl Game<'_> {
         self.pacman.render(self.canvas);
 
         // Draw a grid
-        for x in 0..BOARD_WIDTH {
+        if self.debug {
-            for y in 0..BOARD_HEIGHT {
+            for x in 0..BOARD_WIDTH {
-                let tile = BOARD[x as usize][y as usize];
+                for y in 0..BOARD_HEIGHT {
-                let color = match tile {
+                    let tile = BOARD[x as usize][y as usize];
-                    MapTile::Empty => None,
+                    let mut color = 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 {
+                    if (x, y) == self.pacman.cell_position() {
-                    self.canvas.set_draw_color(color);
+                        self.draw_cell((x, y), Color::CYAN);
-                    self.canvas
+                    } else {
-                        .draw_rect(sdl2::rect::Rect::new(x as i32 * 24, y as i32 * 24, 24, 24))
+                        color = match tile {
-                        .expect("Could not draw rectangle");
+                            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.draw_cell((x, y), color);
+                    }
                 }
             }
         }
 
         self.canvas.present();
     }
+
+    fn draw_cell(&mut self, cell: (u32, u32), color: Color) {
+        self.canvas.set_draw_color(color);
+        self.canvas
+            .draw_rect(sdl2::rect::Rect::new(
+                cell.0 as i32 * 24,
+                cell.1 as i32 * 24,
+                24,
+                24,
+            ))
+            .expect("Could not draw rectangle");
+    }
 }

src/main.rs

@@ -1,6 +1,5 @@
 use crate::constants::{WINDOW_HEIGHT, WINDOW_WIDTH};
 use crate::game::Game;
-use crate::textures::TextureManager;
 use sdl2::event::{Event};
 use sdl2::keyboard::Keycode;
 use sdl2::pixels::Color;
@@ -14,18 +13,9 @@ mod constants;
 mod direction;
 mod game;
 mod pacman;
-mod textures;
 mod entity;
 mod animation;
 
-fn redraw(canvas: &mut Canvas<sdl2::video::Window>, tex: &Texture, i: u8) {
-    canvas.set_draw_color(Color::RGB(i, i, i));
-    canvas.clear();
-    canvas
-        .copy(tex, None, None)
-        .expect("Could not render texture on canvas");
-}
-
 pub fn main() {
     let sdl_context = sdl2::init().unwrap();
     let video_subsystem = sdl_context.video().unwrap();
@@ -38,6 +28,7 @@ pub fn main() {
 
     let mut canvas = window
         .into_canvas()
+        .accelerated()
         .build()
         .expect("Could not build canvas");
 
@@ -75,17 +66,8 @@ pub fn main() {
             }
         }
 
-        let tick_time = {
+        game.tick();
-            let start = Instant::now();
+        game.draw();
-            game.tick();
-            start.elapsed()
-        };
-
-        let draw_time = {
-            let start = Instant::now();
-            game.draw();
-            start.elapsed()
-        };
 
         if start.elapsed() < loop_time {
             ::std::thread::sleep(loop_time - start.elapsed());

src/pacman.rs

@@ -3,12 +3,13 @@ use sdl2::{
     video::Window,
 };
 
-use crate::{animation::AnimatedTexture, direction::Direction, entity::Entity};
+use crate::{animation::AnimatedTexture, direction::Direction, entity::Entity, constants::CELL_SIZE};
 
 pub struct Pacman<'a> {
     // Absolute position on the board (precise)
     pub position: (i32, i32),
     pub direction: Direction,
+    pub next_direction: Option<Direction>,
     speed: u32,
     sprite: AnimatedTexture<'a>,
 }
@@ -18,8 +19,9 @@ impl Pacman<'_> {
         Pacman {
             position: starting_position.unwrap_or((0i32, 0i32)),
             direction: Direction::Right,
+            next_direction: None,
             speed: 2,
-            sprite: AnimatedTexture::new(atlas, 4, 3, 32, 32),
+            sprite: AnimatedTexture::new(atlas, 4, 3, 32, 32, Some((-4, -4))),
         }
     }
 
@@ -41,10 +43,24 @@ impl Entity for Pacman<'_> {
 
     fn cell_position(&self) -> (u32, u32) {
         let (x, y) = self.position();
-        (x as u32 / 24, y as u32 / 24)
+        (x as u32 / CELL_SIZE, y as u32 / CELL_SIZE)
+    }
+
+    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) {
+        let can_change = self.internal_position() == (0, 0);
+        println!("{:?} ({:?})", self.internal_position(), can_change);
+        if can_change {
+            if let Some(direction) = self.next_direction {
+                self.direction = direction;
+                self.next_direction = None;
+            }
+        }
+        
         let speed = self.speed as i32;
         match self.direction {
             Direction::Right => {

src/textures.rs

@@ -1,29 +0,0 @@
-
-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,
-        }
-    }
-}