feat: speed modulation to implement precise speed decrease despite integers

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,7 +24,7 @@ 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,
@@ -36,6 +36,10 @@ impl Game<'_> {
         }
     }
 
+    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 => {
@@ -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");
@@ -75,25 +79,42 @@ impl Game<'_> {
 
         // Draw a grid
         if self.debug {
-        for x in 0..BOARD_WIDTH {
+            for x in 0..BOARD_WIDTH {
-            for y in 0..BOARD_HEIGHT {
+                for y in 0..BOARD_HEIGHT {
-                let tile = BOARD[x as usize][y as usize];
+                    let tile = BOARD[x as usize][y as usize];
-                let color = match tile {
+                    let mut color = None;
-                    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 {
+                    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,20 +1,22 @@
 use crate::constants::{WINDOW_HEIGHT, WINDOW_WIDTH};
 use crate::game::Game;
-use sdl2::event::{Event};
+use sdl2::event::Event;
 use sdl2::keyboard::Keycode;
-use sdl2::pixels::Color;
-use sdl2::render::{Canvas, Texture};
 use std::time::{Duration, Instant};
 
 #[cfg(target_os = "emscripten")]
 pub mod emscripten;
 
+mod animation;
 mod constants;
 mod direction;
+mod entity;
 mod game;
 mod pacman;
-mod entity;
+mod modulation;
-mod animation;
+
+#[cfg(target_os = "emscripten")]
+mod emscripten;
 
 pub fn main() {
     let sdl_context = sdl2::init().unwrap();
@@ -59,9 +61,9 @@ pub fn main() {
                     keycode: Some(Keycode::Escape) | Some(Keycode::Q),
                     ..
                 } => return false,
-                Event::KeyDown { keycode , .. } => {
+                Event::KeyDown { keycode, .. } => {
                     game.keyboard_event(keycode.unwrap());
-                },
+                }
                 _ => {}
             }
         }
@@ -72,7 +74,10 @@ pub fn main() {
         if start.elapsed() < loop_time {
             ::std::thread::sleep(loop_time - start.elapsed());
         } else {
-            println!("Game loop behind schedule by: {:?}", start.elapsed() - loop_time);
+            println!(
+                "Game loop behind schedule by: {:?}",
+                start.elapsed() - loop_time
+            );
         }
 
         true

src/modulation.rs

@@ -0,0 +1,26 @@
+pub struct SpeedModulator {
+    tick_count: u32,
+    ticks_left: u32,
+}
+
+impl SpeedModulator {
+    pub fn new(percent: f32) -> Self {
+        let ticks_required: u32 = (1f32 / (1f32 - percent)).round() as u32;
+
+        SpeedModulator {
+            tick_count: ticks_required,
+            ticks_left: ticks_required,
+        }
+    }
+
+    pub fn next(&mut self) -> bool {
+        self.ticks_left -= 1;
+
+        if self.ticks_left == 0 {
+            self.ticks_left = self.tick_count;
+            false
+        } else {
+            true
+        }
+    }
+}

src/pacman.rs

@@ -3,7 +3,10 @@ use sdl2::{
     video::Window,
 };
 
-use crate::{animation::AnimatedTexture, direction::Direction, entity::Entity, constants::CELL_SIZE};
+use crate::{
+    animation::AnimatedTexture, constants::CELL_SIZE, direction::Direction, entity::Entity,
+    modulation::SpeedModulator,
+};
 
 pub struct Pacman<'a> {
     // Absolute position on the board (precise)
@@ -11,6 +14,7 @@ pub struct Pacman<'a> {
     pub direction: Direction,
     pub next_direction: Option<Direction>,
     speed: u32,
+    modulation: SpeedModulator,
     sprite: AnimatedTexture<'a>,
 }
 
@@ -21,6 +25,7 @@ impl Pacman<'_> {
             direction: Direction::Right,
             next_direction: None,
             speed: 2,
+            modulation: SpeedModulator::new(0.9333),
             sprite: AnimatedTexture::new(atlas, 4, 3, 32, 32, Some((-4, -4))),
         }
     }
@@ -53,27 +58,28 @@ impl Entity for Pacman<'_> {
 
     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;
+        if self.modulation.next() {
-        match self.direction {
+            let speed = self.speed as i32;
-            Direction::Right => {
+            match self.direction {
-                self.position.0 += speed;
+                Direction::Right => {
-            }
+                    self.position.0 += speed;
-            Direction::Left => {
+                }
-                self.position.0 -= speed;
+                Direction::Left => {
-            }
+                    self.position.0 -= speed;
-            Direction::Up => {
+                }
-                self.position.1 -= speed;
+                Direction::Up => {
-            }
+                    self.position.1 -= speed;
-            Direction::Down => {
+                }
-                self.position.1 += speed;
+                Direction::Down => {
+                    self.position.1 += speed;
+                }
             }
         }
     }