feat: wall collisions

src/direction.rs

@@ -15,4 +15,13 @@ impl Direction {
             Direction::Up => 270f64,
         }
     }
+
+    pub fn offset(&self) -> (i32, i32) {
+        match self {
+            Direction::Right => (1, 0),
+            Direction::Down => (0, 1),
+            Direction::Left => (-1, 0),
+            Direction::Up => (0, -1),
+        }
+    }
 }

src/helper.rs

@@ -0,0 +1,15 @@
+pub fn is_adjacent(a: (u32, u32), b: (u32, u32), diagonal: bool) -> bool {
+    let (ax, ay) = a;
+    let (bx, by) = b;
+    if diagonal {
+        (ax == bx && (ay == by + 1 || ay == by - 1))
+            || (ay == by && (ax == bx + 1 || ax == bx - 1))
+            || (ax == bx + 1 && ay == by + 1)
+            || (ax == bx + 1 && ay == by - 1)
+            || (ax == bx - 1 && ay == by + 1)
+            || (ax == bx - 1 && ay == by - 1)
+    } else {
+        (ax == bx && (ay == by + 1 || ay == by - 1))
+            || (ay == by && (ax == bx + 1 || ax == bx - 1))
+    }
+}

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 animation;
+mod modulation;
+
+#[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,14 +3,20 @@ use sdl2::{
     video::Window,
 };
 
-use crate::{animation::AnimatedTexture, direction::Direction, entity::Entity, constants::CELL_SIZE};
+use crate::{
+    constants::{BOARD, MapTile},
+    animation::AnimatedTexture, constants::CELL_SIZE, direction::Direction, entity::Entity,
+    modulation::SpeedModulator,
+};
 
 pub struct Pacman<'a> {
     // Absolute position on the board (precise)
     pub position: (i32, i32),
     pub direction: Direction,
     pub next_direction: Option<Direction>,
+    pub stopped: bool,
     speed: u32,
+    modulation: SpeedModulator,
     sprite: AnimatedTexture<'a>,
 }
 
@@ -21,6 +27,8 @@ impl Pacman<'_> {
             direction: Direction::Right,
             next_direction: None,
             speed: 2,
+            stopped: false,
+            modulation: SpeedModulator::new(0.9333),
             sprite: AnimatedTexture::new(atlas, 4, 3, 32, 32, Some((-4, -4))),
         }
     }
@@ -28,6 +36,12 @@ impl Pacman<'_> {
     pub fn render(&mut self, canvas: &mut Canvas<Window>) {
         self.sprite.render(canvas, self.position, self.direction);
     }
+
+    fn next_cell(&self) -> (i32, i32) {
+        let (x, y) = self.direction.offset();
+        let cell = self.cell_position();
+        (cell.0 as i32 + x, cell.1 as i32 + y)
+    }
 }
 
 impl Entity for Pacman<'_> {
@@ -53,28 +67,34 @@ 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;
-        match self.direction {
-            Direction::Right => {
-                self.position.0 += speed;
-            }
-            Direction::Left => {
-                self.position.0 -= speed;
-            }
-            Direction::Up => {
-                self.position.1 -= speed;
-            }
-            Direction::Down => {
-                self.position.1 += speed;
+
+        if !self.stopped && self.modulation.next() {
+            let speed = self.speed as i32;
+            match self.direction {
+                Direction::Right => {
+                    self.position.0 += speed;
+                }
+                Direction::Left => {
+                    self.position.0 -= speed;
+                }
+                Direction::Up => {
+                    self.position.1 -= speed;
+                }
+                Direction::Down => {
+                    self.position.1 += speed;
+                }
             }
         }
+
+        let next = self.next_cell();
+        if BOARD[next.1 as usize][next.0 as usize] == MapTile::Wall {
+            self.stopped = true;
+        }
     }
 }