feat: new assets

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,55 +1,96 @@
-use sdl2::pixels::Color;
-use sdl2::event::Event;
+use crate::constants::{WINDOW_HEIGHT, WINDOW_WIDTH};
+use sdl2::event::{Event, WindowEvent};
 use sdl2::image::LoadTexture;
-use sdl2::keyboard::{Keycode, Mod};
+use sdl2::keyboard::Keycode;
+use sdl2::pixels::Color;
+use sdl2::render::{Texture, Canvas};
 use std::time::Duration;
-use crate::constants::{WINDOW_WIDTH, WINDOW_HEIGHT};
 
 #[cfg(target_os = "emscripten")]
 pub mod emscripten;
 
-mod constants;
 mod board;
+mod constants;
 mod game;
 
+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()
+        .resizable()
         .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");
     let texture_creator = canvas.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 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 i = 0u8;
+
+    let mut event_pump = sdl_context
+        .event_pump()
+        .expect("Could not get SDL EventPump");
 
-    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);
-                }
+                },
+                Event::Window { win_event, .. } => {
+                    if let WindowEvent::Resized(width, height) = win_event {
+                        i = i.wrapping_add(1);
+
+                        canvas.set_logical_size(width as u32, height as u32).unwrap();
+                        redraw(&mut canvas, &map_texture, i);
+                    }
+                },
                 _ => {}
             }
         }
 
         canvas.present();
         ::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;
+        }
+    }
+}