Use durations everywhere!

[kaka/rust-sdl-test.git] / src / core / app.rs

diff --git a/src/core/app.rs b/src/core/app.rs
index b495edb..be546c1 100644 (file)
--- a/src/core/app.rs
+++ b/src/core/app.rs
@@ -13,9 +13,7 @@ use sdl2::video::{FullscreenType, SwapInterval, Window};
 use sdl2::{EventPump, VideoSubsystem};
 use sprites::SpriteManager;
 use std::f32::consts::PI;
-use time::PreciseTime;
-
-pub type Nanoseconds = u64;
+use time::{Duration, Instant, prelude::*};
 
 const FPS: u32 = 60;
 const NS_PER_FRAME: u32 = 1_000_000_000 / FPS;
@@ -47,7 +45,7 @@ impl AppBuilder {
         let context = sdl2::init().unwrap();
         sdl2::image::init(sdl2::image::InitFlag::PNG)?;
         let video = context.video()?;
-        self.print_video_display_modes(&video);
+        //self.print_video_display_modes(&video);
 
         let window = video
             .window(
@@ -74,18 +72,17 @@ impl AppBuilder {
         let event_pump = context.event_pump()?;
         let sprites = SpriteManager::new(canvas.texture_creator());
        let screen = canvas.output_size().unwrap();
-       let ctrl = context.game_controller()?;
-       ctrl.set_event_state(true);
 
         Ok(App {
             canvas,
             event_pump,
             sprites,
             state: self.state.unwrap_or_else(|| Box::new(ActiveState::new(screen))),
-           ctrl_man: ControllerManager::new(ctrl, context.haptic()?),
+           ctrl_man: ControllerManager::new(context.joystick()?, context.haptic()?),
         })
     }
 
+    #[allow(dead_code)]
     fn print_video_display_modes(&self, video: &VideoSubsystem) {
         println!("video subsystem: {:?}", video);
         println!("current_video_driver: {:?}", video.current_video_driver());
@@ -131,7 +128,7 @@ pub struct App {
     event_pump: EventPump,
     sprites: SpriteManager,
     state: Box<dyn AppState>,
-    ctrl_man: ControllerManager,
+    pub ctrl_man: ControllerManager,
 }
 
 impl App {
@@ -147,30 +144,22 @@ impl App {
     }
 
     pub fn start(&mut self) {
-        let mut frame_count: u64 = 0;
-        let mut fps_time = PreciseTime::now();
-        let mut last_time = PreciseTime::now();
+        let mut last_time = Instant::now();
+
+       self.state.enter(&mut self.ctrl_man);
 
         'running: loop {
            if let Err(_) = self.handle_events() {
                break 'running;
            }
 
-            let duration =
-                last_time.to(PreciseTime::now()).num_nanoseconds().unwrap() as Nanoseconds;
-            last_time = PreciseTime::now();
+            let duration = Instant::now() - last_time;
+           last_time = Instant::now();
+
+           self.ctrl_man.update(duration);
             self.state.update(duration);
 
            self.render();
-
-            frame_count += 1;
-            if frame_count == FPS as u64 {
-                let duration = fps_time.to(PreciseTime::now()).num_nanoseconds().unwrap() as f64
-                    / 1_000_000_000.0;
-                // println!("fps: {}", frame_count as f64 / duration);
-                frame_count = 0;
-                fps_time = PreciseTime::now();
-            }
         }
 
         self.state.leave();
@@ -180,10 +169,6 @@ impl App {
         for event in self.event_pump.poll_iter() {
            self.ctrl_man.handle_event(&event);
             match event {
-               Event::ControllerButtonDown { .. } => {
-                   let c = self.ctrl_man.controllers[0].clone();
-                   c.rumble(0.75, 100);
-               }
                 Event::Quit { .. }
                 | Event::KeyDown {
                     keycode: Some(Keycode::Escape),
@@ -246,7 +231,7 @@ impl App {
                 } => {
                     println!("window focus lost")
                 }
-                _ => self.state.on_event(event),
+                _ => self.state.handle_event(event),
             }
         }
        Ok(())
@@ -261,10 +246,11 @@ impl App {
 }
 
 pub trait AppState {
-    fn update(&mut self, dt: Nanoseconds);
+    fn enter(&mut self, ctrl_man: &mut ControllerManager);
+    fn leave(&mut self);
+    fn update(&mut self, dt: Duration);
     fn render(&mut self, canvas: &mut Canvas<Window>, sprites: &mut SpriteManager);
-    fn leave(&self);
-    fn on_event(&mut self, event: Event);
+    fn handle_event(&mut self, event: Event);
 }
 
 type Bollar = Vec<Box<dyn Boll>>;
@@ -313,14 +299,16 @@ impl ActiveState {
 }
 
 impl AppState for ActiveState {
-    fn update(&mut self, dt: Nanoseconds) {
+    fn enter(&mut self, _ctrl_man: &mut ControllerManager) {}
+
+    fn update(&mut self, dt: Duration) {
         for b in &mut self.bolls {
             b.update();
         }
 
         match dt {
-            ns if ns < (NS_PER_FRAME - 90_0000) as u64 => self.change_boll_count(100),
-            ns if ns > (NS_PER_FRAME + 90_0000) as u64 => self.change_boll_count(-100),
+            ns if ns < (NS_PER_FRAME - 90_0000).nanoseconds() => self.change_boll_count(100),
+            ns if ns > (NS_PER_FRAME + 90_0000).nanoseconds() => self.change_boll_count(-100),
             _ => {}
         }
     }
@@ -430,11 +418,11 @@ impl AppState for ActiveState {
         }
     }
 
-    fn leave(&self) {
+    fn leave(&mut self) {
         println!("number of bolls: {}", self.bolls.len());
     }
 
-    fn on_event(&mut self, event: Event) {
+    fn handle_event(&mut self, event: Event) {
         match event {
             Event::KeyDown {
                 keycode: Some(Keycode::KpPlus),