feat: speed modulation to implement precise speed decrease despite integers

src/main.rs

@@ -13,6 +13,7 @@ mod direction;
 mod entity;
 mod game;
 mod pacman;
+mod modulation;
 
 #[cfg(target_os = "emscripten")]
 mod emscripten;

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;
+                }
             }
         }
     }