2 use common::{Point2D, Rect};
3 use core::controller::ControllerManager;
4 use core::render::Renderer;
5 use point; // defined in common, but loaded from main...
7 use sdl2::event::{Event, WindowEvent};
8 use sdl2::keyboard::Keycode;
9 use sdl2::rect::Rect as SDLRect;
10 use sdl2::video::SwapInterval;
11 use sdl2::{EventPump, VideoSubsystem};
12 use sprites::SpriteManager;
13 use std::f32::consts::PI;
14 use time::{Duration, Instant, prelude::*};
17 const NS_PER_FRAME: u32 = 1_000_000_000 / FPS;
20 pub struct AppBuilder {
21 resolution: Rect<u16>,
22 state: Option<Box<dyn AppState>>,
23 title: Option<String>,
27 pub fn with_resolution(mut self, width: u16, height: u16) -> Self {
28 self.resolution = Rect { width, height };
32 pub fn with_state(mut self, state: Box<dyn AppState>) -> Self {
33 self.state = Some(state);
37 pub fn with_title(mut self, title: &str) -> Self {
38 self.title = Some(title.to_string());
42 pub fn build(self) -> Result<App, String> {
43 let context = sdl2::init().unwrap();
44 sdl2::image::init(sdl2::image::InitFlag::PNG)?;
45 let video = context.video()?;
46 //self.print_video_display_modes(&video);
51 self.resolution.width.into(),
52 self.resolution.height.into(),
56 // .fullscreen_desktop()
60 context.mouse().show_cursor(false);
62 let canvas = window.into_canvas().build().unwrap();
63 let sprites = SpriteManager::new(canvas.texture_creator());
64 let screen = canvas.output_size().unwrap();
65 let renderer = Renderer::new(canvas);
67 video.gl_set_swap_interval(SwapInterval::VSync)?;
69 let event_pump = context.event_pump()?;
75 state: self.state.unwrap_or_else(|| Box::new(ActiveState::new(screen))),
76 ctrl_man: ControllerManager::new(context.joystick()?, context.haptic()?),
81 fn print_video_display_modes(&self, video: &VideoSubsystem) {
82 println!("video subsystem: {:?}", video);
83 println!("current_video_driver: {:?}", video.current_video_driver());
84 for display in 0..video.num_video_displays().unwrap() {
86 "=== display {} - {} ===",
88 video.display_name(display).unwrap()
91 " display_bounds: {:?}",
92 video.display_bounds(display).unwrap()
95 " num_display_modes: {:?}",
96 video.num_display_modes(display).unwrap()
99 " desktop_display_mode: {:?}",
100 video.desktop_display_mode(display).unwrap()
102 let current = video.current_display_mode(display).unwrap();
104 " current_display_mode: {:?}",
107 for idx in 0..video.num_display_modes(display).unwrap() {
108 let mode = video.display_mode(display, idx).unwrap();
111 if mode == current { "*" } else { " " },
117 println!("swap interval: {:?}", video.gl_get_swap_interval());
123 event_pump: EventPump,
124 sprites: SpriteManager,
125 state: Box<dyn AppState>,
126 pub ctrl_man: ControllerManager,
130 #[allow(clippy::new_ret_no_self)]
131 pub fn new() -> AppBuilder {
135 pub fn load_sprites(&mut self, sprites: &[(&str, &str)]) {
136 for (name, file) in sprites {
137 self.sprites.load(name, file);
141 pub fn start(&mut self) {
142 let mut last_time = Instant::now();
144 self.state.enter(&mut self.ctrl_man);
147 if let Err(_) = self.handle_events() {
151 let duration = Instant::now() - last_time;
152 last_time = Instant::now();
154 self.ctrl_man.update(duration);
155 self.state.update(duration);
163 fn handle_events(&mut self) -> Result<(), ()> {
164 for event in self.event_pump.poll_iter() {
165 self.ctrl_man.handle_event(&event);
169 keycode: Some(Keycode::Escape),
175 keycode: Some(Keycode::F11),
178 self.renderer.toggle_fullscreen();
181 win_event: WindowEvent::Resized(x, y),
184 println!("window resized({}, {})", x, y)
187 win_event: WindowEvent::Maximized,
190 println!("window maximized")
193 win_event: WindowEvent::Restored,
196 println!("window restored")
199 win_event: WindowEvent::Enter,
202 println!("window enter")
205 win_event: WindowEvent::Leave,
208 println!("window leave")
211 win_event: WindowEvent::FocusGained,
214 println!("window focus gained")
217 win_event: WindowEvent::FocusLost,
220 println!("window focus lost")
222 _ => self.state.handle_event(event),
228 fn render(&mut self) {
229 self.renderer.clear();
230 self.state.render(&mut self.renderer, &mut self.sprites);
231 self.renderer.present();
236 fn enter(&mut self, ctrl_man: &ControllerManager);
238 fn update(&mut self, dt: Duration);
239 fn render(&mut self, renderer: &mut Renderer, sprites: &SpriteManager);
240 fn handle_event(&mut self, event: Event);
243 type Bollar = Vec<Box<dyn Boll>>;
246 pub struct ActiveState {
254 pub fn new(screen: (u32, u32)) -> ActiveState {
256 bolls: Bollar::new(),
258 screen: Rect::from(screen),
263 fn change_boll_count(&mut self, delta: i32) {
264 #[allow(clippy::comparison_chain)]
269 } else if delta < 0 {
270 for _i in 0..(-delta) {
276 fn add_boll(&mut self) {
277 let mut rng = rand::thread_rng();
278 self.bolls.push(Box::new(SquareBoll {
280 rng.gen_range(0, self.screen.width) as f64,
281 rng.gen_range(0, self.screen.height) as f64
283 vel: point!(rng.gen_range(-2.0, 2.0), rng.gen_range(-2.0, 2.0)),
288 impl AppState for ActiveState {
289 fn enter(&mut self, _ctrl_man: &ControllerManager) {}
291 fn update(&mut self, dt: Duration) {
292 for b in &mut self.bolls {
297 ns if ns < (NS_PER_FRAME - 90_0000).nanoseconds() => self.change_boll_count(100),
298 ns if ns > (NS_PER_FRAME + 90_0000).nanoseconds() => self.change_boll_count(-100),
303 fn render(&mut self, renderer: &mut Renderer, sprites: &SpriteManager) {
304 /* draw square of blocks */ {
308 (self.screen.width as i32 - (blocks + 1) * size) / 2,
309 (self.screen.height as i32 - (blocks + 1) * size) / 2
311 let block = sprites.get("block");
317 SDLRect::new((i) * size + offset.x, offset.y, size as u32, size as u32),
324 (blocks - i) * size + offset.x,
325 (blocks) * size + offset.y,
336 (blocks - i) * size + offset.y,
346 (blocks) * size + offset.x,
347 (i) * size + offset.y,
358 (self.screen.width as i32 - size) / 2,
359 (self.screen.height as i32 - size) / 2
361 let radius = 110.0 + size as f32 * 0.5;
362 let angle = (self.mario_angle as f32 - 90.0) * PI / 180.0;
363 let offset2 = point!((angle.cos() * radius) as i32, (angle.sin() * radius) as i32);
366 sprites.get("mario"),
369 offset.x + offset2.x,
370 offset.y + offset2.y,
375 sdl2::rect::Point::new(size / 2, size / 2),
379 self.mario_angle = (self.mario_angle + 1.0) % 360.0;
382 /* draw circles and ellipses*/ {
383 let p = point!((self.screen.width / 2) as i16, (self.screen.height / 2) as i16);
384 renderer.circle(p, 100, (255, 255, 255));
385 renderer.circle(p, 110, (255, 255, 255));
386 renderer.ellipse(p, (50, 100), (255, 255, 255));
387 renderer.ellipse(p, (110, 55), (255, 255, 255));
390 for b in &self.bolls {
391 b.draw(renderer, self.boll_size);
395 fn leave(&mut self) {
396 println!("number of bolls: {}", self.bolls.len());
399 fn handle_event(&mut self, event: Event) {
402 keycode: Some(Keycode::KpPlus),
404 } => self.boll_size = std::cmp::min(self.boll_size + 1, 32),
406 keycode: Some(Keycode::KpMinus),
408 } => self.boll_size = std::cmp::max(self.boll_size - 1, 1),
409 Event::MouseMotion { x, y, .. } => self.bolls.push(Box::new(CircleBoll::new(
410 point!(x as f64, y as f64),