feat: new PacMan entity, entity trait implementation

.cargo/config.toml

@@ -1,28 +1,4 @@
 [target.wasm32-unknown-emscripten]
 rustflags = [
-    "-C",
-    "link-arg=-s",
-    "-C",
-    "link-arg=FULL_ES2",
-    "-C",
-    "link-arg=-s",
-    "-C",
-    "link-arg=FULL_ES3",
-    "-C",
-    "link-arg=-s",
-    "-C",
-    "link-arg=USE_SDL=2",
-    "-C",
-    "link-arg=-s",
-    "-C",
-    "link-arg=MAX_WEBGL_VERSION=2 ",
-    "-C",
-    "link-arg=-s",
-    "-C",
-    "link-arg=MIN_WEBGL_VERSION=2",
-    "-C",
-    "link-arg=-s",
-    "-C",
-    "link-arg=ERROR_ON_UNDEFINED_SYMBOLS=0", # for ignoring some egl symbols. needed for wgpu
-
+    "--use-preload-plugins --preload-file assets -s USE_SDL=2 -s USE_SDL_IMAGE=2 -s ASSERTIONS=1",
 ]

Cargo.lock

@@ -2,13 +2,6 @@
 # It is not intended for manual editing.
 version = 3
 
-[[package]]
-name = "Pac-Man"
-version = "0.1.0"
-dependencies = [
- "sdl2",
-]
-
 [[package]]
 name = "bitflags"
 version = "1.3.2"
@@ -33,6 +26,14 @@ version = "0.2.147"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b4668fb0ea861c1df094127ac5f1da3409a82116a4ba74fca2e58ef927159bb3"
 
+[[package]]
+name = "pacman"
+version = "0.1.0"
+dependencies = [
+ "lazy_static",
+ "sdl2",
+]
+
 [[package]]
 name = "sdl2"
 version = "0.35.2"

Cargo.toml

@@ -1,9 +1,10 @@
 [package]
-name = "Pac-Man"
+name = "pacman"
 version = "0.1.0"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+lazy_static = "1.4.0"
 sdl2 = { version = "0.35", features = ["image", "ttf", "mixer"] }

IMPLEMENTATION.md

@@ -0,0 +1,35 @@
+# Implementation
+
+A document detailing the implementation the project from rendering, to game logic, to build systems.
+
+## Rendering
+
+1. Map
+    - May require procedural text generation later on (cacheable?)
+2. Pacman
+3. Ghosts
+    - Requires colors
+4. Items
+5. Interface
+    - Requires fonts
+
+## Grid System
+
+1. How does the grid system work?
+
+The grid is 28 x 36 (although, the map texture is 28 x 37), and each cell is 24x24 (pixels).
+Many of the walls in the map texture only occupy a portion of the cell, so some items are able to render across multiple cells.
+24x24 assets include pellets, the energizer, and the map itself ()
+
+2. What constraints must be enforced on Ghosts and PacMan?
+
+3. How do movement transitions work?
+
+All entities store a precise position, and a direction. This position is only used for animation, rendering, and collision purposes. Otherwise, a separate 'cell position' (which is 24 times less precise, owing to the fact that it is based on the entity's position within the grid).
+
+When an entity is transitioning between cells, movement directions are acknowledged, but won't take effect until the next cell has been entered completely.
+
+4. Between transitions, how does collision detection work?
+
+It appears the original implementation used cell-level detection.
+I worry this may be prone to division errors. Make sure to use rounding (50% >=).

README.md

@@ -2,11 +2,65 @@
 
 If the title doesn't clue you in, I'm remaking Pac-Man with SDL and Rust.
 
-The project is *extremely* early in development, but check back in a week, and maybe I'll have something cool to look
+The project is _extremely_ early in development, but check back in a week, and maybe I'll have something cool to look
 at.
 
 ## Feature Targets
 
 - Near-perfect replication of logic, scoring, graphics, sound, and behaviors.
 - Written in Rust, buildable on Windows, Linux, Mac and WebAssembly.
-- Online demo, playable in a browser.
+- Online demo, playable in a browser.
+- Automatic build system, with releases for Windows, Linux, and Mac & Web-Assembly.
+- Debug tooling
+    - Game state visualization
+    - Game speed controls + pausing
+    - Log tracing
+    - Performance details
+
+## Experimental Ideas
+
+- Perfected Ghost Algorithms
+- More than 4 ghosts
+- Custom Level Generation
+    - Multi-map tunnelling
+
+## Installation
+
+Besides SDL2, the following extensions are required: Image, Mixer, and TTF.
+
+### Ubuntu
+
+On Ubuntu, you can install the required packages with the following command:
+
+```
+sudo apt install libsdl2-dev libsdl2-image-dev libsdl2-mixer-dev libsdl2-ttf-dev
+```
+
+### Windows
+
+On Windows, installation requires either building from source (not covered), or downloading the pre-built binaries.
+
+The latest releases can be found here:
+
+- [SDL2](https://github.com/libsdl-org/SDL/releases/latest/)
+- [SDL2_image](https://github.com/libsdl-org/SDL_image/releases/latest/)
+- [SDL2_mixer](https://github.com/libsdl-org/SDL_mixer/releases/latest/)
+- [SDL2_ttf](https://github.com/libsdl-org/SDL_ttf/releases/latest/)
+
+Download each for your architecture, and locate the appropriately named DLL within. Move said DLL to root of this project.
+
+## Building
+
+To build the project, run the following command:
+
+```
+cargo build
+```
+
+During development, you can easily run the project with:
+
+```
+cargo run
+cargo run -q # Quiet mode, no logging
+cargo run --release # Release mode, optimized
+```

build.ps1

@@ -0,0 +1,7 @@
+& cargo build --target=wasm32-unknown-emscripten --release
+
+mkdir -p dist -Force
+
+cp ./target/wasm32-unknown-emscripten/release/Pac_Man.wasm ./dist
+cp ./target/wasm32-unknown-emscripten/release/Pac-Man.js ./dist
+cp index.html dist

build.sh

@@ -5,6 +5,6 @@ cargo build --target=wasm32-unknown-emscripten --release
 
 mkdir -p dist
 
-cp target/wasm32-unknown-emscripten/release/rust_sdl2_wasm.wasm dist
-cp target/wasm32-unknown-emscripten/release/rust-sdl2-wasm.js dist
+cp target/wasm32-unknown-emscripten/release/Pac_Man.wasm dist
+cp target/wasm32-unknown-emscripten/release/Pac-Man.js dist
 cp index.html dist

index.html

@@ -6,7 +6,7 @@
 <body>
     <canvas id="canvas"></canvas>
     <script type="text/javascript">
-        const Module = {
+        let Module = {
             canvas: (function () {
                 // this is how we provide a canvas to our sdl2
                 return document.getElementById("canvas");
@@ -16,6 +16,6 @@
             }]
         };
     </script>
-    <script src="rust-sdl2-wasm.js"></script>
+    <script src="Pac-Man.js"></script>
 </body>
 </html>

serve.ps1

@@ -0,0 +1,3 @@
+& ./build.ps1
+cd ./dist
+python -m http.server

src/animation.rs

@@ -0,0 +1,53 @@
+use sdl2::{
+    rect::Rect,
+    render::{Canvas, Texture},
+    video::Window,
+};
+
+pub struct AnimatedTexture<'a> {
+    raw_texture: &'a Texture<'a>,
+    current_frame: u32,
+    frame_count: u32,
+    frame_width: u32,
+    frame_height: u32,
+}
+
+impl<'a> AnimatedTexture<'a> {
+    pub fn new(
+        texture: &'a Texture<'a>,
+        frame_count: u32,
+        frame_width: u32,
+        frame_height: u32,
+    ) -> Self {
+        AnimatedTexture {
+            raw_texture: texture,
+            current_frame: 0,
+            frame_count,
+            frame_width,
+            frame_height,
+        }
+    }
+
+    fn next_frame(&mut self) {
+        self.current_frame = (self.current_frame + 1) % self.frame_count;
+    }
+
+    fn get_frame_rect(&self) -> Rect {
+        Rect::new(
+            (self.current_frame * self.frame_width) as i32,
+            0,
+            self.frame_width,
+            self.frame_height,
+        )
+    }
+
+    pub fn render(&mut self, canvas: &mut Canvas<Window>, position: (i32, i32)) {
+        let frame_rect = self.get_frame_rect();
+        let position_rect = Rect::new(position.0, position.1, self.frame_width, self.frame_height);
+        canvas
+            .copy(&self.raw_texture, frame_rect, position_rect)
+            .expect("Could not render sprite on canvas");
+
+            self.next_frame();
+    }
+}

src/constants.rs

@@ -1,44 +1,95 @@
+use lazy_static::lazy_static;
+
 pub const BOARD_WIDTH: u32 = 28;
-pub const BOARD_HEIGHT: u32 = 36;
-pub const BLOCK_SIZE_24: u32 = 24;
-pub const BLOCK_SIZE_32: u32 = 32;
+pub const BOARD_HEIGHT: u32 = 37; // Adjusted to fit map texture?
+pub const CELL_SIZE: u32 = 24;
 
-pub const WINDOW_WIDTH: u32 = BLOCK_SIZE_24 * BOARD_WIDTH;
-pub const WINDOW_HEIGHT: u32 = BLOCK_SIZE_24 * BOARD_HEIGHT;
+pub const WINDOW_WIDTH: u32 = CELL_SIZE * BOARD_WIDTH;
+pub const WINDOW_HEIGHT: u32 = CELL_SIZE * BOARD_HEIGHT;
 
-pub const RAW_BOARD: &str = r###"
+#[derive(Debug, Copy, Clone, PartialEq)]
+pub enum MapTile {
+    Empty,
+    Wall,
+    Pellet,
+    PowerPellet,
+    StartingPosition(u8),
+}
 
+pub const RAW_BOARD: [&str; BOARD_HEIGHT as usize] = [
+    "                            ",
+    "                            ",
+    "                            ",
+    "############################",
+    "#............##............#",
+    "#.####.#####.##.#####.####.#",
+    "#o####.#####.##.#####.####o#",
+    "#.####.#####.##.#####.####.#",
+    "#..........................#",
+    "#.####.##.########.##.####.#",
+    "#.####.##.########.##.####.#",
+    "#......##....##....##......#",
+    "######.##### ## #####.######",
+    "     #.##### ## #####.#     ",
+    "     #.##    1     ##.#     ",
+    "     #.## ###==### ##.#     ",
+    "######.## #      # ##.######",
+    "      .   #2 3 4 #   .      ",
+    "######.## #      # ##.######",
+    "     #.## ######## ##.#     ",
+    "     #.##          ##.#     ",
+    "     #.## ######## ##.#     ",
+    "######.## ######## ##.######",
+    "#............##............#",
+    "#.####.#####.##.#####.####.#",
+    "#.####.#####.##.#####.####.#",
+    "#o..##.......0 .......##..o#",
+    "###.##.##.########.##.##.###",
+    "###.##.##.########.##.##.###",
+    "#......##....##....##......#",
+    "#.##########.##.##########.#",
+    "#.##########.##.##########.#",
+    "#..........................#",
+    "############################",
+    "                            ",
+    "                            ",
+    "                            ",
+];
 
-############################
-#............##............#
-#.####.#####.##.#####.####.#
-#o####.#####.##.#####.####o#
-#.####.#####.##.#####.####.#
-#..........................#
-#.####.##.########.##.####.#
-#.####.##.########.##.####.#
-#......##....##....##......#
-######.##### ## #####.######
-     #.##### ## #####.#
-     #.##    1     ##.#
-     #.## ###==### ##.#
-######.## #      # ##.######
-      .   #2 3 4 #   .
-######.## #      # ##.######
-     #.## ######## ##.#
-     #.##          ##.#
-     #.## ######## ##.#
-######.## ######## ##.######
-#............##............#
-#.####.#####.##.#####.####.#
-#.####.#####.##.#####.####.#
-#o..##.......0 .......##..o#
-###.##.##.########.##.##.###
-###.##.##.########.##.##.###
-#......##....##....##......#
-#.##########.##.##########.#
-#.##########.##.##########.#
-#..........................#
-############################
+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/direction.rs

@@ -0,0 +1,6 @@
+pub enum Direction {
+    Up,
+    Down,
+    Left,
+    Right,
+}

src/emscripten.rs

@@ -0,0 +1,44 @@
+// taken from https://github.com/Gigoteur/PX8/blob/master/src/px8/emscripten.rs
+#[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};
+
+    #[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,
+                                        fps: c_int,
+                                        simulate_infinite_loop: c_int);
+
+        pub fn emscripten_cancel_main_loop();
+        pub fn emscripten_pause_main_loop();
+        pub fn emscripten_get_now() -> c_float;
+    }
+
+    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()
+    {
+        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()
+        {
+            MAIN_LOOP_CALLBACK.with(|z| {
+                let closure = *z.borrow_mut() as *mut F;
+                (*closure)();
+            });
+        }
+    }
+}

src/entity.rs

@@ -0,0 +1,8 @@
+pub trait Entity {
+    // Returns true if the entity is colliding with the other entity
+    fn is_colliding(&self, other: &dyn Entity) -> bool;
+    // Returns the absolute position of the entity
+    fn position(&self) -> (i32, i32);
+    // Returns the cell position of the entity (XY position within the grid)
+    fn cell_position(&self) -> (u32, u32);
+}

src/game.rs

@@ -1,11 +1,63 @@
-pub struct Game {}
+use sdl2::{pixels::Color, render::Canvas, video::Window};
 
-impl Game {
-    pub fn new() -> Game {
-        Game {}
+use crate::constants::{MapTile, BOARD, BOARD_HEIGHT, BOARD_WIDTH};
+use crate::pacman::Pacman;
+use crate::textures::TextureManager;
+
+pub struct Game<'a> {
+    pub textures: TextureManager<'a>,
+    canvas: &'a mut Canvas<Window>,
+    pacman: Pacman<'a>,
+    debug: bool,
+}
+
+impl Game<'_> {
+    pub fn new<'a>(
+        canvas: &'a mut Canvas<Window>,
+        texture_manager: TextureManager<'a>,
+    ) -> Game<'a> {
+        let pacman = Pacman::new(None, &texture_manager.pacman);
+
+        Game {
+            canvas,
+            textures: texture_manager,
+            pacman: pacman,
+            debug: true,
+        }
     }
 
-    pub fn tick() {}
+    pub fn tick(&mut self) {}
 
-    pub fn draw() {}
-}
+    pub fn draw(&mut self) {
+        // Clear the screen (black)
+        self.canvas.set_draw_color(Color::RGB(0, 0, 0));
+        self.canvas.clear();
+        
+        self.canvas
+            .copy(&self.textures.map, None, None)
+            .expect("Could not render texture on canvas");
+
+        // Draw a grid
+        for x in 0..BOARD_WIDTH {
+            for y in 0..BOARD_HEIGHT {
+                let tile = BOARD[x as usize][y as usize];
+                let color = match tile {
+                    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.canvas.set_draw_color(color);
+                    self.canvas
+                        .draw_rect(sdl2::rect::Rect::new(x as i32 * 24, y as i32 * 24, 24, 24))
+                        .expect("Could not draw rectangle");
+                }
+            }
+        }
+
+        self.canvas.present();
+    }
+}

src/main.rs

@@ -1,45 +1,110 @@
+use crate::constants::{WINDOW_HEIGHT, WINDOW_WIDTH};
+use crate::game::Game;
+use crate::textures::TextureManager;
+use sdl2::event::{Event};
+use sdl2::keyboard::Keycode;
 use sdl2::pixels::Color;
-use sdl2::event::Event;
-use sdl2::image::LoadTexture;
-use sdl2::keyboard::{Keycode, Mod};
-use std::time::Duration;
-use crate::constants::{WINDOW_WIDTH, WINDOW_HEIGHT};
+use sdl2::render::{Canvas, Texture};
+use std::time::{Duration, Instant};
+
+#[cfg(target_os = "emscripten")]
+pub mod emscripten;
 
 mod constants;
-mod board;
+mod direction;
 mod game;
+mod pacman;
+mod textures;
+mod entity;
+mod animation;
+
+fn redraw(canvas: &mut Canvas<sdl2::video::Window>, tex: &Texture, i: u8) {
+    canvas.set_draw_color(Color::RGB(i, i, i));
+    canvas.clear();
+    canvas
+        .copy(tex, None, None)
+        .expect("Could not render texture on canvas");
+}
 
 pub fn main() {
     let sdl_context = sdl2::init().unwrap();
     let video_subsystem = sdl_context.video().unwrap();
 
-    let window = video_subsystem.window("Pac-Man", WINDOW_WIDTH, WINDOW_HEIGHT)
+    let window = video_subsystem
+        .window("Pac-Man", WINDOW_WIDTH, WINDOW_HEIGHT)
         .position_centered()
         .build()
         .expect("Could not initialize window");
 
-    let mut canvas = window.into_canvas().build().expect("Could not build canvas");
-    let texture_creator= canvas.texture_creator();
+    let mut canvas = window
+        .into_canvas()
+        .build()
+        .expect("Could not build canvas");
 
-    let map_texture = texture_creator.load_texture("assets/map.png").expect("Could not load pacman texture");
-    canvas.copy(&map_texture, None, None).expect("Could not render texture on canvas");
+    canvas
+        .set_logical_size(WINDOW_WIDTH, WINDOW_HEIGHT)
+        .expect("Could not set logical size");
 
-    let mut event_pump = sdl_context.event_pump().expect("Could not get SDL EventPump");
-    'main: loop {
+    let texture_creator = canvas.texture_creator();
+    let mut game = Game::new(&mut canvas, TextureManager::new(&texture_creator));
+
+    let mut event_pump = sdl_context
+        .event_pump()
+        .expect("Could not get SDL EventPump");
+
+    game.draw();
+    game.tick();
+
+    let mut main_loop = || {
         for event in event_pump.poll_iter() {
             match event {
-                Event::Quit { .. } |
-                Event::KeyDown { keycode: Some(Keycode::Q), .. } => {
-                    break 'main;
-                }
-                event @ Event::KeyDown {  .. } => {
+                // Handle quitting keys or window close
+                Event::Quit { .. }
+                | Event::KeyDown {
+                    keycode: Some(Keycode::Escape) | Some(Keycode::Q),
+                    ..
+                } => return false,
+                event @ Event::KeyDown { .. } => {
                     println!("{:?}", event);
-                },
+                }
                 _ => {}
             }
         }
 
-        canvas.present();
+        let tick_time = {
+            let start = Instant::now();
+            game.tick();
+            start.elapsed()
+        };
+
+        let draw_time = {
+            let start = Instant::now();
+            game.draw();
+            start.elapsed()
+        };
+
+        // Alert if tick time exceeds 10ms
+        if tick_time > Duration::from_millis(3) {
+            println!("Tick took: {:?}", tick_time);
+        }
+        if draw_time > Duration::from_millis(3) {
+            println!("Draw took: {:?}", draw_time);
+        }
+
         ::std::thread::sleep(Duration::from_millis(10));
+        true
+    };
+
+    #[cfg(target_os = "emscripten")]
+    use emscripten::emscripten;
+
+    #[cfg(target_os = "emscripten")]
+    emscripten::set_main_loop_callback(main_loop);
+
+    #[cfg(not(target_os = "emscripten"))]
+    loop {
+        if !main_loop() {
+            break;
+        }
     }
-}
+}

src/pacman.rs

@@ -0,0 +1,41 @@
+use sdl2::{render::{Canvas, Texture}, video::Window};
+
+use crate::{direction::Direction, entity::Entity, animation::AnimatedTexture};
+
+pub struct Pacman<'a> {
+    // Absolute position on the board (precise)
+    pub position: (i32, i32),
+    pub direction: Direction,
+    sprite: AnimatedTexture<'a>,
+}
+
+impl Pacman<'_> {
+    pub fn new<'a>(starting_position: Option<(i32, i32)>, atlas: &'a Texture<'a>) -> Pacman<'a> {
+        Pacman {
+            position: starting_position.unwrap_or((0i32, 0i32)),
+            direction: Direction::Right,
+            sprite: AnimatedTexture::new(atlas, 2, 24, 24),
+        }
+    }
+
+    pub fn render(&mut self,  canvas: &mut Canvas<Window>) {
+        self.sprite.render(canvas, self.position);
+    }
+}
+
+impl Entity for Pacman<'_> {
+    fn is_colliding(&self, other: &dyn Entity) -> bool {
+        let (x, y) = self.position();
+        let (other_x, other_y) = other.position();
+        x == other_x && y == other_y
+    }
+
+    fn position(&self) -> (i32, i32) {
+        self.position
+    }
+
+    fn cell_position(&self) -> (u32, u32) {
+        let (x, y) = self.position();
+        (x as u32 / 24, y as u32 / 24)
+    }
+}

src/textures.rs

@@ -0,0 +1,29 @@
+
+use sdl2::{
+    image::LoadTexture,
+    render::{Texture, TextureCreator},
+    video::WindowContext,
+};
+
+pub struct TextureManager<'a> {
+    pub map: Texture<'a>,
+    pub pacman: Texture<'a>,
+}
+
+impl<'a> TextureManager<'a> {
+    pub fn new(texture_creator: &'a TextureCreator<WindowContext>) -> Self {
+        let map_texture = texture_creator
+            .load_texture("assets/map.png")
+            .expect("Could not load pacman texture");
+        
+        let pacman_atlas = texture_creator
+            .load_texture("assets/pacman.png")
+            .expect("Could not load pacman texture");
+        
+        
+        TextureManager {
+            map: map_texture,
+            pacman: pacman_atlas,
+        }
+    }
+}