feat: add optional offset to AnimatedTexture

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,
@@ -18,11 +19,12 @@ pub struct AnimatedTexture<'a> {
 
 impl<'a> AnimatedTexture<'a> {
     pub fn new(
-        texture:Texture<'a>,
+        texture: Texture<'a>,
         ticks_per_frame: u32,
         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)),
         }
     }
 
@@ -49,7 +52,7 @@ impl<'a> AnimatedTexture<'a> {
         } else {
             self.ticker += 1;
 
-            if self.ticker > self.ticks_per_frame * self.frame_count {
+            if self.ticker + 1 == self.ticks_per_frame * self.frame_count {
                 self.reversed = !self.reversed;
             }
         }
@@ -64,9 +67,19 @@ impl<'a> AnimatedTexture<'a> {
         )
     }
 
-    pub fn render(&mut self, canvas: &mut Canvas<Window>, position: (i32, i32), direction: Direction) {
+    pub fn render(
+        &mut self,
+        canvas: &mut Canvas<Window>,
+        position: (i32, i32),
+        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(
@@ -76,9 +89,10 @@ impl<'a> AnimatedTexture<'a> {
                 direction.angle(),
                 None,
                 false,
-                false
-            ).expect("Could not render texture on canvas");
+                false,
+            )
+            .expect("Could not render texture on canvas");
 
-            self.next_frame();
+        self.next_frame();
     }
 }

src/game.rs

@@ -29,7 +29,7 @@ impl Game<'_> {
         Game {
             canvas,
             pacman: pacman,
-            debug: true,
+            debug: false,
             map_texture: texture_creator
                 .load_texture("assets/map.png")
                 .expect("Could not load pacman texture"),
@@ -74,6 +74,7 @@ impl Game<'_> {
         self.pacman.render(self.canvas);
 
         // Draw a grid
+        if self.debug {
         for x in 0..BOARD_WIDTH {
             for y in 0..BOARD_HEIGHT {
                 let tile = BOARD[x as usize][y as usize];
@@ -93,7 +94,6 @@ impl Game<'_> {
                 }
             }
         }
-
-        self.canvas.present();
+        }
     }
 }

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 = {
-            let start = Instant::now();
-            game.tick();
-            start.elapsed()
-        };
-
-        let draw_time = {
-            let start = Instant::now();
-            game.draw();
-            start.elapsed()
-        };
+        game.tick();
+        game.draw();
 
         if start.elapsed() < loop_time {
             ::std::thread::sleep(loop_time - start.elapsed());

src/pacman.rs

@@ -1,11 +1,15 @@
-use sdl2::{render::{Canvas, Texture}, video::Window};
+use sdl2::{
+    render::{Canvas, Texture},
+    video::Window,
+};
 
-use crate::{direction::Direction, entity::Entity, animation::AnimatedTexture};
+use crate::{animation::AnimatedTexture, direction::Direction, entity::Entity};
 
 pub struct Pacman<'a> {
     // Absolute position on the board (precise)
     pub position: (i32, i32),
     pub direction: Direction,
+    speed: u32,
     sprite: AnimatedTexture<'a>,
 }
 
@@ -14,11 +18,12 @@ impl Pacman<'_> {
         Pacman {
             position: starting_position.unwrap_or((0i32, 0i32)),
             direction: Direction::Right,
-            sprite: AnimatedTexture::new(atlas, 4, 3, 32,32),
+            speed: 2,
+            sprite: AnimatedTexture::new(atlas, 4, 3, 32, 32),
         }
     }
 
-    pub fn render(&mut self,  canvas: &mut Canvas<Window>) {
+    pub fn render(&mut self, canvas: &mut Canvas<Window>) {
         self.sprite.render(canvas, self.position, self.direction);
     }
 }
@@ -40,19 +45,20 @@ impl Entity for Pacman<'_> {
     }
 
     fn tick(&mut self) {
+        let speed = self.speed as i32;
         match self.direction {
             Direction::Right => {
-                self.position.0 += 1;
+                self.position.0 += speed;
             }
             Direction::Left => {
-                self.position.0 -= 1;
+                self.position.0 -= speed;
             }
             Direction::Up => {
-                self.position.1 -= 1;
+                self.position.1 -= speed;
             }
             Direction::Down => {
-                self.position.1 += 1;
+                self.position.1 += speed;
             }
         }
     }
-}
+}

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,
-        }
-    }
-}