feat: add pausing functionality, clean up statistic calculations

src/constants.rs

@@ -1,11 +1,11 @@
-use lazy_static::lazy_static;
-
 pub const BOARD_WIDTH: u32 = 28;
-pub const BOARD_HEIGHT: u32 = 37; // Adjusted to fit map texture?
+pub const BOARD_HEIGHT: u32 = 31; // Adjusted to fit map texture?
 pub const CELL_SIZE: u32 = 24;
 
+pub const BOARD_OFFSET: (u32, u32) = (0, 3); // Relative cell offset for where map text / grid starts
+
 pub const WINDOW_WIDTH: u32 = CELL_SIZE * BOARD_WIDTH;
-pub const WINDOW_HEIGHT: u32 = CELL_SIZE * BOARD_HEIGHT;
+pub const WINDOW_HEIGHT: u32 = CELL_SIZE * (BOARD_HEIGHT + 6); // Map texture is 6 cells taller (3 above, 3 below) than the grid
 
 #[derive(Debug, Copy, Clone, PartialEq)]
 pub enum MapTile {
@@ -17,9 +17,6 @@ pub enum MapTile {
 }
 
 pub const RAW_BOARD: [&str; BOARD_HEIGHT as usize] = [
-    "                            ",
-    "                            ",
-    "                            ",
     "############################",
     "#............##............#",
     "#.####.#####.##.#####.####.#",
@@ -51,45 +48,4 @@ pub const RAW_BOARD: [&str; BOARD_HEIGHT as usize] = [
     "#.##########.##.##########.#",
     "#..........................#",
     "############################",
-    "                            ",
-    "                            ",
-    "                            ",
 ];
-
-lazy_static! {
-    pub static ref BOARD: [[MapTile; BOARD_HEIGHT as usize]; BOARD_HEIGHT as usize] = {
-        let mut board = [[MapTile::Empty; BOARD_HEIGHT as usize]; BOARD_HEIGHT as usize];
-
-        for y in 0..BOARD_HEIGHT as usize {
-            let line = RAW_BOARD[y];
-
-            for x in 0..BOARD_WIDTH as usize {
-                if x >= line.len() {
-                    break;
-                }
-                
-                let i = (y * (BOARD_WIDTH as usize) + x) as usize;
-                let character = line
-                    .chars()
-                    .nth(x as usize)
-                    .unwrap_or_else(|| panic!("Could not get character at {} = ({}, {})", i, x, y));
-
-                let tile = match character {
-                    '#' => MapTile::Wall,
-                    '.' => MapTile::Pellet,
-                    'o' => MapTile::PowerPellet,
-                    ' ' => MapTile::Empty,
-                    c @ '0' | c @ '1' | c @ '2' | c @ '3' | c @ '4' => {
-                        MapTile::StartingPosition(c.to_digit(10).unwrap() as u8)
-                    },
-                    '=' => MapTile::Empty,
-                    _ => panic!("Unknown character in board: {}", character),
-                };
-
-                board[x as usize][y as usize] = tile;
-            }
-        }
-
-        board
-    };
-}

src/emscripten.rs

@@ -2,18 +2,20 @@
 #[cfg(target_os = "emscripten")]
 pub mod emscripten {
     use std::cell::RefCell;
-    use std::ptr::null_mut;
-    use std::os::raw::{c_int, c_void, c_char, c_float};
     use std::ffi::{CStr, CString};
+    use std::os::raw::{c_char, c_float, c_int, c_void};
+    use std::ptr::null_mut;
 
     #[allow(non_camel_case_types)]
     type em_callback_func = unsafe extern "C" fn();
 
     extern "C" {
         // void emscripten_set_main_loop(em_callback_func func, int fps, int simulate_infinite_loop)
-        pub fn emscripten_set_main_loop(func: em_callback_func,
+        pub fn emscripten_set_main_loop(
+            func: em_callback_func,
             fps: c_int,
-                                        simulate_infinite_loop: c_int);
+            simulate_infinite_loop: c_int,
+        );
 
         pub fn emscripten_cancel_main_loop();
         pub fn emscripten_pause_main_loop();
@@ -23,17 +25,20 @@ pub mod emscripten {
     thread_local!(static MAIN_LOOP_CALLBACK: RefCell<*mut c_void> = RefCell::new(null_mut()));
 
     pub fn set_main_loop_callback<F>(callback: F)
-        where F: FnMut()
+    where
+        F: FnMut(),
     {
-        MAIN_LOOP_CALLBACK
-            .with(|log| { *log.borrow_mut() = &callback as *const _ as *mut c_void; });
+        MAIN_LOOP_CALLBACK.with(|log| {
+            *log.borrow_mut() = &callback as *const _ as *mut c_void;
+        });
 
         unsafe {
             emscripten_set_main_loop(wrapper::<F>, -1, 1);
         }
 
         unsafe extern "C" fn wrapper<F>()
-            where F: FnMut()
+        where
+            F: FnMut(),
         {
             MAIN_LOOP_CALLBACK.with(|z| {
                 let closure = *z.borrow_mut() as *mut F;

src/game.rs

@@ -1,18 +1,23 @@
+use std::rc::Rc;
+
 use sdl2::image::LoadTexture;
 use sdl2::keyboard::Keycode;
 use sdl2::render::{Texture, TextureCreator};
 use sdl2::video::WindowContext;
 use sdl2::{pixels::Color, render::Canvas, video::Window};
+use tracing::event;
 
-use crate::constants::{MapTile, BOARD, BOARD_HEIGHT, BOARD_WIDTH};
+use crate::constants::{MapTile, BOARD_HEIGHT, BOARD_WIDTH, RAW_BOARD};
 use crate::direction::Direction;
 use crate::entity::Entity;
+use crate::map::Map;
 use crate::pacman::Pacman;
 
 pub struct Game<'a> {
     canvas: &'a mut Canvas<Window>,
     map_texture: Texture<'a>,
     pacman: Pacman<'a>,
+    map: Rc<Map>,
     debug: bool,
 }
 
@@ -21,44 +26,32 @@ impl Game<'_> {
         canvas: &'a mut Canvas<Window>,
         texture_creator: &'a TextureCreator<WindowContext>,
     ) -> Game<'a> {
+        let map = Rc::new(Map::new(RAW_BOARD));
         let pacman_atlas = texture_creator
             .load_texture("assets/32/pacman.png")
             .expect("Could not load pacman texture");
-        let pacman = Pacman::new(Some(Game::cell_to_pixel((1, 4))), pacman_atlas);
+        let pacman = Pacman::new((1, 1), pacman_atlas, Rc::clone(&map));
 
         Game {
             canvas,
             pacman: pacman,
             debug: false,
+            map: map,
             map_texture: texture_creator
                 .load_texture("assets/map.png")
                 .expect("Could not load pacman texture"),
         }
     }
 
-    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 => {
-                self.pacman.next_direction = Some(Direction::Right);
-            }
-            Keycode::A => {
-                self.pacman.next_direction = Some(Direction::Left);
-            }
-            Keycode::W => {
-                self.pacman.next_direction = Some(Direction::Up);
-            }
-            Keycode::S => {
-                self.pacman.next_direction = Some(Direction::Down);
-            }
-            Keycode::Space => {
+        // Change direction
+        let direction = Direction::from_keycode(keycode);
+        self.pacman.next_direction = direction;
+
+        // Toggle debug mode
+        if keycode == Keycode::Space {
             self.debug = !self.debug;
         }
-            _ => {}
-        }
     }
 
     pub fn tick(&mut self) {
@@ -81,7 +74,10 @@ impl Game<'_> {
         if self.debug {
             for x in 0..BOARD_WIDTH {
                 for y in 0..BOARD_HEIGHT {
-                    let tile = BOARD[x as usize][y as usize];
+                    let tile = self
+                        .map
+                        .get_tile((x as i32, y as i32))
+                        .unwrap_or(MapTile::Empty);
                     let mut color = None;
 
                     if (x, y) == self.pacman.cell_position() {
@@ -111,11 +107,12 @@ impl Game<'_> {
     }
 
     fn draw_cell(&mut self, cell: (u32, u32), color: Color) {
+        let position = Map::cell_to_pixel(cell);
         self.canvas.set_draw_color(color);
         self.canvas
             .draw_rect(sdl2::rect::Rect::new(
-                cell.0 as i32 * 24,
-                cell.1 as i32 * 24,
+                position.0 as i32,
+                position.1 as i32,
                 24,
                 24,
             ))

src/main.rs

@@ -1,10 +1,10 @@
 use crate::constants::{WINDOW_HEIGHT, WINDOW_WIDTH};
 use crate::game::Game;
-use tracing::{event};
-use sdl2::event::{Event};
+use sdl2::event::Event;
 use sdl2::keyboard::Keycode;
-use std::time::{Duration, Instant};
 use spin_sleep::sleep;
+use std::time::{Duration, Instant};
+use tracing::event;
 use tracing_error::ErrorLayer;
 use tracing_subscriber::layer::SubscriberExt;
 
@@ -16,9 +16,9 @@ mod constants;
 mod direction;
 mod entity;
 mod game;
-mod pacman;
-mod modulation;
 mod map;
+mod modulation;
+mod pacman;
 
 #[cfg(target_os = "emscripten")]
 mod emscripten;
@@ -68,11 +68,17 @@ pub fn main() {
     // The start of a period of time over which we average the frame time.
     let mut last_averaging_time = Instant::now();
     let mut sleep_time = Duration::ZERO;
+    let mut paused = false;
 
-    event!(tracing::Level::INFO, "Starting game loop ({:.3}ms)", loop_time.as_secs_f32() * 1000.0);
+    event!(
+        tracing::Level::INFO,
+        "Starting game loop ({:.3}ms)",
+        loop_time.as_secs_f32() * 1000.0
+    );
     let mut main_loop = || {
         let start = Instant::now();
 
+        // TODO: Fix key repeat delay issues by using VecDeque for instant key repeat
         for event in event_pump.poll_iter() {
             match event {
                 // Handle quitting keys or window close
@@ -82,8 +88,19 @@ pub fn main() {
                     ..
                 } => {
                     event!(tracing::Level::INFO, "Exit requested. Exiting...");
-                    return false
-                },
+                    return false;
+                }
+                Event::KeyDown {
+                    keycode: Some(Keycode::P),
+                    ..
+                } => {
+                    paused = !paused;
+                    event!(
+                        tracing::Level::INFO,
+                        "{}",
+                        if paused { "Paused" } else { "Unpaused" }
+                    );
+                }
                 Event::KeyDown { keycode, .. } => {
                     game.keyboard_event(keycode.unwrap());
                 }
@@ -91,8 +108,11 @@ pub fn main() {
             }
         }
 
+        // TODO: Proper pausing implementation that does not interfere with statistic gathering
+        if !paused {
             game.tick();
             game.draw();
+        }
 
         if start.elapsed() < loop_time {
             let time = loop_time - start.elapsed();
@@ -108,9 +128,11 @@ pub fn main() {
 
         tick_no += 1;
 
-        if tick_no % (60 * 60) == 0 || tick_no == (60 * 2) {
-            let average_fps = (tick_no % (60 * 60)) as f32 / last_averaging_time.elapsed().as_secs_f32();
-            let average_sleep = sleep_time / tick_no;
+        const PERIOD: u32 = 60 * 2;
+        let tick_mod = tick_no % PERIOD;
+        if tick_mod % PERIOD == 0 || tick_no == PERIOD {
+            let average_fps = PERIOD as f32 / last_averaging_time.elapsed().as_secs_f32();
+            let average_sleep = sleep_time / PERIOD;
             let average_process = loop_time - average_sleep;
 
             event!(

src/map.rs

@@ -0,0 +1,59 @@
+use crate::constants::MapTile;
+use crate::constants::{BOARD_HEIGHT, BOARD_WIDTH};
+
+pub struct Map {
+    inner: [[MapTile; BOARD_HEIGHT as usize]; BOARD_WIDTH as usize],
+}
+
+impl Map {
+    pub fn new(raw_board: [&str; BOARD_HEIGHT as usize]) -> Map {
+        let mut inner = [[MapTile::Empty; BOARD_HEIGHT as usize]; BOARD_WIDTH as usize];
+
+        for y in 0..BOARD_HEIGHT as usize {
+            let line = raw_board[y];
+
+            for x in 0..BOARD_WIDTH as usize {
+                if x >= line.len() {
+                    break;
+                }
+
+                let i = (y * (BOARD_WIDTH as usize) + x) as usize;
+                let character = line
+                    .chars()
+                    .nth(x as usize)
+                    .unwrap_or_else(|| panic!("Could not get character at {} = ({}, {})", i, x, y));
+
+                let tile = match character {
+                    '#' => MapTile::Wall,
+                    '.' => MapTile::Pellet,
+                    'o' => MapTile::PowerPellet,
+                    ' ' => MapTile::Empty,
+                    c @ '0' | c @ '1' | c @ '2' | c @ '3' | c @ '4' => {
+                        MapTile::StartingPosition(c.to_digit(10).unwrap() as u8)
+                    }
+                    '=' => MapTile::Empty,
+                    _ => panic!("Unknown character in board: {}", character),
+                };
+
+                inner[x as usize][y as usize] = tile;
+            }
+        }
+
+        Map { inner: inner }
+    }
+
+    pub fn get_tile(&self, cell: (i32, i32)) -> Option<MapTile> {
+        let x = cell.0 as usize;
+        let y = cell.1 as usize;
+
+        if x >= BOARD_WIDTH as usize || y >= BOARD_HEIGHT as usize {
+            return None;
+        }
+
+        Some(self.inner[x][y])
+    }
+
+    pub fn cell_to_pixel(cell: (u32, u32)) -> (i32, i32) {
+        ((cell.0 as i32) * 24, ((cell.1 + 3) as i32) * 24)
+    }
+}

src/pacman.rs

@@ -1,12 +1,19 @@
+use std::rc::Rc;
+
 use sdl2::{
     render::{Canvas, Texture},
     video::Window,
 };
+use tracing::event;
 
 use crate::{
-    constants::{BOARD, MapTile},
-    animation::AnimatedTexture, constants::CELL_SIZE, direction::Direction, entity::Entity,
-    modulation::SpeedModulator,
+    animation::AnimatedTexture,
+    constants::MapTile,
+    constants::{BOARD_OFFSET, CELL_SIZE},
+    direction::Direction,
+    entity::Entity,
+    map::Map,
+    modulation::{SimpleTickModulator, TickModulator},
 };
 
 pub struct Pacman<'a> {
@@ -15,20 +22,22 @@ pub struct Pacman<'a> {
     pub direction: Direction,
     pub next_direction: Option<Direction>,
     pub stopped: bool,
+    map: Rc<Map>,
     speed: u32,
-    modulation: SpeedModulator,
+    modulation: SimpleTickModulator,
     sprite: AnimatedTexture<'a>,
 }
 
 impl Pacman<'_> {
-    pub fn new<'a>(starting_position: Option<(i32, i32)>, atlas: Texture<'a>) -> Pacman<'a> {
+    pub fn new<'a>(starting_position: (u32, u32), atlas: Texture<'a>, map: Rc<Map>) -> Pacman<'a> {
         Pacman {
-            position: starting_position.unwrap_or((0i32, 0i32)),
+            position: Map::cell_to_pixel(starting_position),
             direction: Direction::Right,
             next_direction: None,
             speed: 2,
+            map,
             stopped: false,
-            modulation: SpeedModulator::new(0.9333),
+            modulation: SimpleTickModulator::new(0.9333),
             sprite: AnimatedTexture::new(atlas, 4, 3, 32, 32, Some((-4, -4))),
         }
     }
@@ -41,12 +50,33 @@ impl Pacman<'_> {
         } else {
             self.sprite.render(canvas, self.position, self.direction);
         }
+    }
 
-    fn next_cell(&self) -> (i32, i32) {
-        let (x, y) = self.direction.offset();
+    pub fn next_cell(&self, direction: Option<Direction>) -> (i32, i32) {
+        let (x, y) = direction.unwrap_or(self.direction).offset();
         let cell = self.cell_position();
         (cell.0 as i32 + x, cell.1 as i32 + y)
     }
+
+    fn handle_requested_direction(&mut self) {
+        if self.next_direction.is_none() {
+            return;
+        }
+        if self.next_direction.unwrap() == self.direction {
+            self.next_direction = None;
+            return;
+        }
+
+        let proposed_next_cell = self.next_cell(self.next_direction);
+        let proposed_next_tile = self
+            .map
+            .get_tile(proposed_next_cell)
+            .unwrap_or(MapTile::Empty);
+        if proposed_next_tile != MapTile::Wall {
+            self.direction = self.next_direction.unwrap();
+            self.next_direction = None;
+        }
+    }
 }
 
 impl Entity for Pacman<'_> {
@@ -61,8 +91,11 @@ impl Entity for Pacman<'_> {
     }
 
     fn cell_position(&self) -> (u32, u32) {
-        let (x, y) = self.position();
-        (x as u32 / CELL_SIZE, y as u32 / CELL_SIZE)
+        let (x, y) = self.position;
+        (
+            (x as u32 / CELL_SIZE) - BOARD_OFFSET.0,
+            (y as u32 / CELL_SIZE) - BOARD_OFFSET.1,
+        )
     }
 
     fn internal_position(&self) -> (u32, u32) {
@@ -72,10 +105,19 @@ impl Entity for Pacman<'_> {
 
     fn tick(&mut self) {
         let can_change = self.internal_position() == (0, 0);
+
         if can_change {
-            if let Some(direction) = self.next_direction {
-                self.direction = direction;
-                self.next_direction = None;
+            self.handle_requested_direction();
+
+            let next = self.next_cell(None);
+            let next_tile = self.map.get_tile(next).unwrap_or(MapTile::Empty);
+
+            if !self.stopped && next_tile == MapTile::Wall {
+                event!(tracing::Level::DEBUG, "Wall collision. Stopping.");
+                self.stopped = true;
+            } else if self.stopped && next_tile != MapTile::Wall {
+                event!(tracing::Level::DEBUG, "Wall collision resolved. Moving.");
+                self.stopped = false;
             }
         }
 
@@ -96,10 +138,5 @@ impl Entity for Pacman<'_> {
                 }
             }
         }
-
-        let next = self.next_cell();
-        if BOARD[next.1 as usize][next.0 as usize] == MapTile::Wall {
-            self.stopped = true;
-        }
     }
 }