Load the images directly into the executable

Cool, haha. We did it.

I also changed a bunch of random shit.

1 files changed, 87 insertions, 64 deletions

diff --git a/src/main.rs b/src/main.rs
index 43c0c22..eccef92 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,16 +1,14 @@
 extern crate sdl2;
-extern crate tempfile;
+extern crate sdl2_sys;
 
 mod state;
 mod player;
 mod constants;
 mod gates;
-mod music;
 
 use state::Positioned;
 use state::Drawable;
 use state::Bullet;
-use std::io::Write;
 
 enum FResult {
     Win,
@@ -26,6 +24,8 @@ struct Textures<'a> {
     ebullet: sdl2::render::Texture<'a>,
 }
 
+const DURATION: u32 = 1_000_000_000u32 / 60;
+
 fn frame<T: state::Enemy<U>, U: state::Bullet>(canvas: &mut sdl2::render::WindowCanvas, state: &mut state::State<T, U>, events: &mut sdl2::event::EventPollIterator, textures: &Textures) -> FResult {
     let mut new_bullets = Vec::new();
     let count = state.count;
@@ -83,11 +83,15 @@ fn frame<T: state::Enemy<U>, U: state::Bullet>(canvas: &mut sdl2::render::Window
 
 /* Why tf do I not need a lifetime here? */
 fn get_surface(bytes: &[u8]) -> sdl2::surface::Surface {
-    /* Wow what a risky function */
-    let mut f = tempfile::NamedTempFile::new().unwrap();
-    f.write(bytes).unwrap();
-    f.flush().unwrap();
-    sdl2::image::LoadSurface::from_file(f.path()).unwrap()
+    (unsafe {
+        let rw = sdl2_sys::SDL_RWFromMem(bytes.as_ptr() as *mut std::os::raw::c_void, bytes.len() as i32);
+        let raw = sdl2_sys::image::IMG_Load_RW(rw, 1);
+        if (raw as *mut ()).is_null() {
+            Err("Returned null")
+        } else {
+            Ok(sdl2::surface::Surface::from_ll(raw))
+        }
+    }).unwrap()
 }
 
 fn get_player_surface() -> sdl2::surface::Surface<'static> {
@@ -106,46 +110,51 @@ fn get_pbullet_surface() -> sdl2::surface::Surface<'static> {
     get_surface(include_bytes!("assets/player_pepp.png"))
 }
 
-fn generic_message(canvas: &mut sdl2::render::WindowCanvas, event_pump: &mut sdl2::EventPump, image: &[u8]) -> Result<(), ()> {
+fn generic_message(canvas: &mut sdl2::render::WindowCanvas, event_pump: &mut sdl2::EventPump, image: &[u8], okay: sdl2::keyboard::Keycode, error: sdl2::keyboard::Keycode) -> Result<(), ()> {
     let surface = get_surface(image);
     let texture_creator = canvas.texture_creator();
     let texture = texture_creator.create_texture_from_surface(surface).unwrap();
-    canvas.copy(&texture, None, None).unwrap();
-    canvas.present();
-    for event in event_pump.wait_iter() {
-        match event {
-            sdl2::event::Event::Quit {..} => {
-                return Err(());
-            },
-            sdl2::event::Event::KeyDown { keycode: Some(sdl2::keyboard::Keycode::Return), .. } => {
-                return Ok(());
+    let frame_duration = std::time::Duration::new(0, DURATION);
+    loop {
+        let start = std::time::Instant::now();
+        canvas.copy(&texture, None, None).unwrap();
+        canvas.present();
+        for event in event_pump.poll_iter() {
+            match event {
+                sdl2::event::Event::KeyDown { keycode: Some(keycode), .. } => {
+                    if keycode == okay {
+                        return Ok(());
+                    }
+                    if keycode == error {
+                        return Err(());
+                    }
+                }
+                sdl2::event::Event::Quit {..} => {
+                    return Err(());
+                }
+                _ => { }
             }
-            _ => { }
+        }
+        match frame_duration.checked_sub(start.elapsed()) {
+            Some(t) => std::thread::sleep(t),
+            None => (),
         }
     }
-    Ok(())
 }
 
 fn introduction(canvas: &mut sdl2::render::WindowCanvas, event_pump: &mut sdl2::EventPump) -> Result<(), ()> {
-    return generic_message(canvas, event_pump, include_bytes!("assets/introduction.png"));
+    return generic_message(canvas, event_pump, include_bytes!("assets/introduction.png"), sdl2::keyboard::Keycode::Return, sdl2::keyboard::Keycode::Escape);
 }
 
 fn loss(canvas: &mut sdl2::render::WindowCanvas, event_pump: &mut sdl2::EventPump) -> Result<(), ()> {
-    return generic_message(canvas, event_pump, include_bytes!("assets/loss.png"));
+    return generic_message(canvas, event_pump, include_bytes!("assets/loss.png"), sdl2::keyboard::Keycode::R, sdl2::keyboard::Keycode::Escape);
 }
 
 fn victory(canvas: &mut sdl2::render::WindowCanvas, event_pump: &mut sdl2::EventPump) -> Result<(), ()> {
-    return generic_message(canvas, event_pump, include_bytes!("assets/victory.png"));
+    return generic_message(canvas, event_pump, include_bytes!("assets/victory.png"), sdl2::keyboard::Keycode::R, sdl2::keyboard::Keycode::Escape);
 }
 
 fn main() {
-    let mut player = music::new();
-    match player.play() {
-        Ok(_) => { }
-        Err(e) => {
-            println!("{}", e);
-        }
-    }
     let sdl_context = sdl2::init().unwrap();
     let video_subsystem = sdl_context.video().unwrap();
 
@@ -160,42 +169,56 @@ fn main() {
         }
     }
 
-    let frame_duration = std::time::Duration::new(0, 1_000_000_000u32 / 60);
-    let mut state: state::State<gates::Gates, gates::GatesBullet> = state::State::new();
-    let player_surface = get_player_surface();
-    let enemy_surface = get_enemy_surface();
-    let ebullet_surface = get_ebullet_surface();
-    let pbullet_surface = get_pbullet_surface();
-    let texture_creator = canvas.texture_creator();
-    let player_texture = texture_creator.create_texture_from_surface(player_surface).unwrap();
-    let enemy_texture = texture_creator.create_texture_from_surface(enemy_surface).unwrap();
-    let ebullet_texture = texture_creator.create_texture_from_surface(ebullet_surface).unwrap();
-    let pbullet_texture = texture_creator.create_texture_from_surface(pbullet_surface).unwrap();
-    let surfaces = Textures { player: player_texture, enemy: enemy_texture, pbullet: pbullet_texture, ebullet: ebullet_texture };
-    'running: loop {
-        let start = std::time::Instant::now();
-        canvas.set_draw_color(sdl2::pixels::Color::RGB(255, 255, 255));
-        canvas.clear();
-        match frame(&mut canvas, &mut state, &mut event_pump.poll_iter(), &surfaces) {
-            FResult::Loss => {
-                let _ = loss(&mut canvas, &mut event_pump);
-                break;
-            }
-            FResult::Win => {
-                let _ = victory(&mut canvas, &mut event_pump);
-                break;
-            }
-            FResult::Exit => {
-                break;
+    'retry: loop {
+        let mut state: state::State<gates::Gates, gates::GatesBullet> = state::State::new();
+        let player_surface = get_player_surface();
+        let enemy_surface = get_enemy_surface();
+        let ebullet_surface = get_ebullet_surface();
+        let pbullet_surface = get_pbullet_surface();
+        let texture_creator = canvas.texture_creator();
+        let player_texture = texture_creator.create_texture_from_surface(player_surface).unwrap();
+        let enemy_texture = texture_creator.create_texture_from_surface(enemy_surface).unwrap();
+        let ebullet_texture = texture_creator.create_texture_from_surface(ebullet_surface).unwrap();
+        let pbullet_texture = texture_creator.create_texture_from_surface(pbullet_surface).unwrap();
+        let surfaces = Textures { player: player_texture, enemy: enemy_texture, pbullet: pbullet_texture, ebullet: ebullet_texture };
+        let frame_duration = std::time::Duration::new(0, DURATION);
+        'running: loop {
+            let start = std::time::Instant::now();
+            canvas.set_draw_color(sdl2::pixels::Color::RGB(255, 255, 255));
+            canvas.clear();
+            match frame(&mut canvas, &mut state, &mut event_pump.poll_iter(), &surfaces) {
+                FResult::Loss => {
+                    match loss(&mut canvas, &mut event_pump) {
+                        Ok(_) => {
+                            break;
+                        }
+                        Err(_) => {
+                            break 'retry;
+                        }
+                    }
+                }
+                FResult::Win => {
+                    match victory(&mut canvas, &mut event_pump) {
+                        Ok(_) => {
+                            break;
+                        }
+                        Err(_) => {
+                            break 'retry;
+                        }
+                    }
+                }
+                FResult::Exit => {
+                    break 'retry;
+                }
+                FResult::Nothing => {
+                    canvas.present();
+                }
             }
-            FResult::Nothing => {
-                canvas.present();
+            /* Make sure this iteration took a whole frame */
+            match frame_duration.checked_sub(start.elapsed()) {
+                Some(t) => std::thread::sleep(t),
+                None => (),
             }
         }
-        /* Make sure this iteration took a whole frame */
-        match frame_duration.checked_sub(start.elapsed()) {
-            Some(t) => std::thread::sleep(t),
-            None => (),
-        }
     }
 }