feat: keycode to direction utility function

Cargo.toml

@@ -9,6 +9,6 @@ edition = "2021"
 lazy_static = "1.4.0"
 sdl2 = { version = "0.35", features = ["image", "ttf", "mixer"] }
 spin_sleep = "1.1.1"
-tracing = "0.1.37"
+tracing = { version = "0.1.37", features = ["max_level_debug", "release_max_level_warn"]}
 tracing-error = "0.2.0"
-tracing-subscriber = {version = "0.3.17", features = ["env-filter"]}
+tracing-subscriber = {version = "0.3.17", features = ["env-filter"]}

src/animation.rs

@@ -38,11 +38,13 @@ impl<'a> AnimatedTexture<'a> {
         }
     }
 
+    // Get the current frame number
     fn current_frame(&self) -> u32 {
         self.ticker / self.ticks_per_frame
     }
 
-    fn next_frame(&mut self) {
+    // Move to the next frame. If we are at the end of the animation, reverse the direction
+    pub fn tick(&mut self) {
         if self.reversed {
             self.ticker -= 1;
 
@@ -58,9 +60,14 @@ impl<'a> AnimatedTexture<'a> {
         }
     }
 
-    fn get_frame_rect(&self) -> Rect {
+    // Calculate the frame rect (portion of the texture to render) for the given frame.
+    fn get_frame_rect(&self, frame: u32) -> Rect {
+        if frame >= self.frame_count {
+            panic!("Frame {} is out of bounds for this texture", frame);
+        }
+
         Rect::new(
-            self.current_frame() as i32 * self.frame_width as i32,
+            frame as i32 * self.frame_width as i32,
             0,
             self.frame_width,
             self.frame_height,
@@ -73,7 +80,18 @@ impl<'a> AnimatedTexture<'a> {
         position: (i32, i32),
         direction: Direction,
     ) {
-        let frame_rect = self.get_frame_rect();
+        self.render_static(canvas, position, direction, Some(self.current_frame()));
+        self.tick();
+    }
+    
+    pub fn render_static(
+        &mut self,
+        canvas: &mut Canvas<Window>,
+        position: (i32, i32),
+        direction: Direction,
+        frame: Option<u32>,
+    ) {
+        let frame_rect = self.get_frame_rect(frame.unwrap_or(self.current_frame()));
         let position_rect = Rect::new(
             position.0 + self.offset.0,
             position.1 + self.offset.1,
@@ -92,7 +110,5 @@ impl<'a> AnimatedTexture<'a> {
                 false,
             )
             .expect("Could not render texture on canvas");
-
-        self.next_frame();
     }
 }

src/direction.rs

@@ -1,3 +1,5 @@
+use sdl2::keyboard::Keycode;
+
 #[derive(Debug, Copy, Clone, PartialEq)]
 pub enum Direction {
     Up,
@@ -24,4 +26,18 @@ impl Direction {
             Direction::Up => (0, -1),
         }
     }
+
+    pub fn from_keycode(keycode: Keycode) -> Option<Direction> {
+        match keycode {
+            Keycode::D => Some(Direction::Right),
+            Keycode::Right => Some(Direction::Right),
+            Keycode::A => Some(Direction::Left),
+            Keycode::Left => Some(Direction::Left),
+            Keycode::W => Some(Direction::Up),
+            Keycode::Up => Some(Direction::Up),
+            Keycode::S => Some(Direction::Down),
+            Keycode::Down => Some(Direction::Down),
+            _ => None,
+        }
+    }
 }

src/modulation.rs

@@ -1,22 +1,44 @@
-pub struct SpeedModulator {
+/// A tick modulator allows you to slow down operations by a percentage.
+/// 
+/// Unfortunately, switching to floating point numbers for entities can induce floating point errors, slow down calculations
+/// and make the game less deterministic. This is why we use a speed modulator instead.
+/// Additionally, with small integers, lowering the speed by a percentage is not possible. For example, if we have a speed of 2,
+/// and we want to slow it down by 10%, we would need to slow it down by 0.2. However, since we are using integers, we can't.
+/// The only amount you can slow it down by is 1, which is 50% of the speed.
+/// 
+/// The basic principle of the Speed Modulator is to instead 'skip' movement ticks every now and then.
+/// At 60 ticks per second, skips could happen several times per second, or once every few seconds.
+/// Whatever it be, as long as the tick rate is high enough, the human eye will not be able to tell the difference.
+/// 
+/// For example, if we want to slow down the speed by 10%, we would need to skip every 10th tick.
+pub trait TickModulator {
+    fn new(percent: f32) -> Self;
+    fn next(&mut self) -> bool;
+}
+
+pub struct SimpleTickModulator {
     tick_count: u32,
     ticks_left: u32,
 }
 
-impl SpeedModulator {
+// TODO: Add tests
-    pub fn new(percent: f32) -> Self {
+// TODO: Look into average precision, binary code modulation strategy
+impl TickModulator for SimpleTickModulator {
+    fn new(percent: f32) -> Self {
         let ticks_required: u32 = (1f32 / (1f32 - percent)).round() as u32;
 
-        SpeedModulator {
+        SimpleTickModulator {
             tick_count: ticks_required,
             ticks_left: ticks_required,
         }
     }
 
-    pub fn next(&mut self) -> bool {
+    fn next(&mut self) -> bool {
         self.ticks_left -= 1;
 
+        // Return whether or not we should skip this tick
         if self.ticks_left == 0 {
+            // We've reached the tick to skip, reset the counter
             self.ticks_left = self.tick_count;
             false
         } else {