X-Git-Url: http://git.dolda2000.com/gitweb/?a=blobdiff_plain;f=src%2Fcore%2Fapp.rs;h=ddfe3d9a250a1a4b7bc27dfea2e7c4524a5fad0d;hb=bf7b5671bb386ccd3d325ae3dea33046342d129c;hp=f6adba046d0d64f4885d68b6cebf3f05d2282ce7;hpb=3d049b501751d825314db31b7f89d607eaae3e70;p=kaka%2Frust-sdl-test.git

diff --git a/src/core/app.rs b/src/core/app.rs
index f6adba0..ddfe3d9 100644
--- a/src/core/app.rs
+++ b/src/core/app.rs
@@ -1,5 +1,6 @@
 use boll::*;
-use common::{Point2D, Rect};
+use common::{Nanoseconds, Point2D, Rect};
+use core::controller::ControllerManager;
 use point; // defined in common, but loaded from main...
 use rand::Rng;
 use sdl2::event::{Event, WindowEvent};
@@ -14,8 +15,6 @@ use sprites::SpriteManager;
 use std::f32::consts::PI;
 use time::PreciseTime;
 
-pub type Nanoseconds = u64;
-
 const FPS: u32 = 60;
 const NS_PER_FRAME: u32 = 1_000_000_000 / FPS;
 
@@ -46,8 +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(
@@ -80,9 +78,11 @@ impl AppBuilder {
             event_pump,
             sprites,
             state: self.state.unwrap_or_else(|| Box::new(ActiveState::new(screen))),
+	    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());
@@ -124,10 +124,11 @@ impl AppBuilder {
 }
 
 pub struct App {
-    pub canvas: Canvas<Window>,
-    pub event_pump: EventPump,
-    pub sprites: SpriteManager,
-    pub state: Box<dyn AppState>,
+    canvas: Canvas<Window>,
+    event_pump: EventPump,
+    sprites: SpriteManager,
+    state: Box<dyn AppState>,
+    pub ctrl_man: ControllerManager,
 }
 
 impl App {
@@ -143,10 +144,12 @@ impl App {
     }
 
     pub fn start(&mut self) {
-        let mut frame_count: u64 = 0;
-        let mut fps_time = PreciseTime::now();
+        // let mut frame_count: u64 = 0;
+        // let mut fps_time = PreciseTime::now();
         let mut last_time = PreciseTime::now();
 
+	self.state.enter(&mut self.ctrl_man);
+
         'running: loop {
 	    if let Err(_) = self.handle_events() {
 		break 'running;
@@ -155,18 +158,19 @@ impl App {
             let duration =
                 last_time.to(PreciseTime::now()).num_nanoseconds().unwrap() as Nanoseconds;
             last_time = PreciseTime::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();
-            }
+            // 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();
@@ -174,6 +178,7 @@ impl App {
 
     fn handle_events(&mut self) -> Result<(), ()> {
         for event in self.event_pump.poll_iter() {
+	    self.ctrl_man.handle_event(&event);
             match event {
                 Event::Quit { .. }
                 | Event::KeyDown {
@@ -237,7 +242,7 @@ impl App {
                 } => {
                     println!("window focus lost")
                 }
-                _ => self.state.on_event(event),
+                _ => self.state.handle_event(event),
             }
         }
 	Ok(())
@@ -252,10 +257,11 @@ impl App {
 }
 
 pub trait AppState {
+    fn enter(&mut self, ctrl_man: &mut ControllerManager);
+    fn leave(&mut self);
     fn update(&mut self, dt: Nanoseconds);
     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>>;
@@ -304,6 +310,8 @@ impl ActiveState {
 }
 
 impl AppState for ActiveState {
+    fn enter(&mut self, ctrl_man: &mut ControllerManager) {}
+
     fn update(&mut self, dt: Nanoseconds) {
         for b in &mut self.bolls {
             b.update();
@@ -421,11 +429,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),