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;
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(
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());
event_pump: EventPump,
sprites: SpriteManager,
state: Box<dyn AppState>,
- ctrl_man: ControllerManager,
+ pub ctrl_man: ControllerManager,
}
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();
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),
} => {
println!("window focus lost")
}
- _ => self.state.on_event(event),
+ _ => self.state.handle_event(event),
}
}
Ok(())
}
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>>;
}
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),
_ => {}
}
}
}
}
- 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),