2 use common::{Point, Dimension};
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: Dimension<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 = Dimension { 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 states: vec!(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 states: Vec<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.states[0].enter(&self.ctrl_man);
147 if let Some(change) = self.handle_events() {
148 self.handle_state_change(change);
151 let duration = Instant::now() - last_time;
152 last_time = Instant::now();
154 self.ctrl_man.update(duration);
156 if let Some(state) = self.states.last_mut() {
157 if let Some(change) = state.update(duration) {
158 self.handle_state_change(change);
168 fn handle_state_change(&mut self, change: StateChange) {
170 StateChange::Push(mut state) => {
171 // if let Some(s) = self.states.last_mut() {
174 state.enter(&mut self.ctrl_man);
175 self.states.push(state);
177 StateChange::Pop => {
178 if let Some(mut s) = self.states.pop() {
182 StateChange::Exit => {
183 while let Some(mut s) = self.states.pop() {
190 fn handle_events(&mut self) -> Option<StateChange> {
191 for event in self.event_pump.poll_iter() {
192 self.ctrl_man.handle_event(&event);
196 keycode: Some(Keycode::Escape),
199 return Some(StateChange::Pop)
202 keycode: Some(Keycode::F11),
205 self.renderer.toggle_fullscreen();
208 win_event: WindowEvent::Resized(x, y),
211 println!("window resized({}, {})", x, y)
214 win_event: WindowEvent::Maximized,
217 println!("window maximized")
220 win_event: WindowEvent::Restored,
223 println!("window restored")
226 win_event: WindowEvent::Enter,
229 println!("window enter")
232 win_event: WindowEvent::Leave,
235 println!("window leave")
238 win_event: WindowEvent::FocusGained,
241 println!("window focus gained")
244 win_event: WindowEvent::FocusLost,
247 println!("window focus lost")
250 if let Some(state) = self.states.last_mut() {
251 if let Some(change) = state.handle_event(event) {
255 return Some(StateChange::Exit)
263 fn render(&mut self) {
264 self.renderer.clear();
265 self.states.last_mut().unwrap().render(&mut self.renderer, &mut self.sprites);
266 self.renderer.present();
270 pub enum StateChange {
271 Push(Box<dyn AppState>),
277 fn enter(&mut self, ctrl_man: &ControllerManager);
279 fn update(&mut self, dt: Duration) -> Option<StateChange>;
280 fn render(&mut self, renderer: &mut Renderer, sprites: &SpriteManager);
281 fn handle_event(&mut self, event: Event) -> Option<StateChange>;
284 type Bollar = Vec<Box<dyn Boll>>;
287 pub struct ActiveState {
288 screen: Dimension<u32>,
295 pub fn new(screen: (u32, u32)) -> ActiveState {
297 bolls: Bollar::new(),
299 screen: Dimension::from(screen),
304 fn change_boll_count(&mut self, delta: i32) {
305 #[allow(clippy::comparison_chain)]
310 } else if delta < 0 {
311 for _i in 0..(-delta) {
317 fn add_boll(&mut self) {
318 let mut rng = rand::thread_rng();
319 self.bolls.push(Box::new(SquareBoll {
321 rng.gen_range(0, self.screen.width) as f64,
322 rng.gen_range(0, self.screen.height) as f64
324 vel: point!(rng.gen_range(-2.0, 2.0), rng.gen_range(-2.0, 2.0)),
329 impl AppState for ActiveState {
330 fn enter(&mut self, _ctrl_man: &ControllerManager) {}
332 fn update(&mut self, dt: Duration) -> Option<StateChange> {
333 for b in &mut self.bolls {
338 ns if ns < (NS_PER_FRAME - 90_0000).nanoseconds() => self.change_boll_count(100),
339 ns if ns > (NS_PER_FRAME + 90_0000).nanoseconds() => self.change_boll_count(-100),
346 fn render(&mut self, renderer: &mut Renderer, sprites: &SpriteManager) {
347 /* draw square of blocks */ {
351 (self.screen.width as i32 - (blocks + 1) * size) / 2,
352 (self.screen.height as i32 - (blocks + 1) * size) / 2
354 let block = sprites.get("block");
360 SDLRect::new((i) * size + offset.x, offset.y, size as u32, size as u32),
367 (blocks - i) * size + offset.x,
368 (blocks) * size + offset.y,
379 (blocks - i) * size + offset.y,
389 (blocks) * size + offset.x,
390 (i) * size + offset.y,
401 (self.screen.width as i32 - size) / 2,
402 (self.screen.height as i32 - size) / 2
404 let radius = 110.0 + size as f32 * 0.5;
405 let angle = (self.mario_angle as f32 - 90.0) * PI / 180.0;
406 let offset2 = point!((angle.cos() * radius) as i32, (angle.sin() * radius) as i32);
409 sprites.get("mario"),
412 offset.x + offset2.x,
413 offset.y + offset2.y,
418 sdl2::rect::Point::new(size / 2, size / 2),
422 self.mario_angle = (self.mario_angle + 1.0) % 360.0;
425 /* draw circles and ellipses*/ {
426 let p = point!((self.screen.width / 2) as i16, (self.screen.height / 2) as i16);
427 renderer.circle(p, 100, (255, 255, 255));
428 renderer.circle(p, 110, (255, 255, 255));
429 renderer.ellipse(p, (50, 100), (255, 255, 255));
430 renderer.ellipse(p, (110, 55), (255, 255, 255));
433 for b in &self.bolls {
434 b.draw(renderer, self.boll_size);
438 fn leave(&mut self) {
439 println!("number of bolls: {}", self.bolls.len());
442 fn handle_event(&mut self, event: Event) -> Option<StateChange> {
445 keycode: Some(Keycode::KpPlus),
447 } => self.boll_size = std::cmp::min(self.boll_size + 1, 32),
449 keycode: Some(Keycode::KpMinus),
451 } => self.boll_size = std::cmp::max(self.boll_size - 1, 1),
452 Event::MouseMotion { x, y, .. } => self.bolls.push(Box::new(CircleBoll::new(
453 point!(x as f64, y as f64),