feat: current canvas, window & mainloop

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
+```

src/main.rs

@@ -1,38 +1,69 @@
+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 mut canvas = window
+        .into_canvas()
+        .build()
+        .expect("Could not build canvas");
+
+    canvas
+        .set_logical_size(WINDOW_WIDTH, WINDOW_HEIGHT)
+        .expect("Could not set logical size");
+
     let texture_creator = canvas.texture_creator();
+    let mut game = Game::new(&mut canvas, TextureManager::new(&texture_creator));
 
-    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");
+    let mut event_pump = sdl_context
+        .event_pump()
+        .expect("Could not get SDL EventPump");
+
+    game.draw();
+    game.tick();
 
-    let mut event_pump = sdl_context.event_pump().expect("Could not get SDL EventPump");
     let mut main_loop = || {
         for event in event_pump.poll_iter() {
             match event {
-                Event::Quit { .. } |
-                Event::KeyDown { keycode: Some(Keycode::Q), .. } => break,
+                // Handle quitting keys or window close
+                Event::Quit { .. }
+                | Event::KeyDown {
+                    keycode: Some(Keycode::Escape) | Some(Keycode::Q),
+                    ..
+                } => return false,
                 event @ Event::KeyDown { .. } => {
                     println!("{:?}", event);
                 }
@@ -40,16 +71,40 @@ pub fn main() {
             }
         }
 
-        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};
+    use emscripten::emscripten;
 
     #[cfg(target_os = "emscripten")]
     emscripten::set_main_loop_callback(main_loop);
 
     #[cfg(not(target_os = "emscripten"))]
-    loop { main_loop(); }
-}
+    loop {
+        if !main_loop() {
+            break;
+        }
+    }
+}