src/teststate.rs

   1 use common::{Dimension, Point, Intersection};
   2 use core::app::{AppState, StateChange};
   3 use core::controller::ControllerManager;
   4 use core::level::Grid;
   5 use core::render::Renderer;
   6 use {point, dimen};
   7 use sdl2::event::Event;
   8 use sprites::SpriteManager;
   9 use time::{Duration, Instant};
  10
  11 pub struct TestState {
  12     start: Instant,
  13     mouse: Point<i32>,
  14 }
  15
  16 impl TestState {
  17     pub fn new() -> TestState {
  18         TestState {
  19             start: Instant::now(),
  20             mouse: point!(0, 0),
  21         }
  22     }
  23
  24     fn draw_intersecting_lines(&self, renderer: &mut Renderer, p1: (i32, i32), p2: (i32, i32), p3: (i32, i32), p4: (i32, i32)) {
  25         let color = match Intersection::lines(
  26             point!(p1.0 as f64, p1.1 as f64),
  27             point!(p2.0 as f64, p2.1 as f64),
  28             point!(p3.0 as f64, p3.1 as f64),
  29             point!(p4.0 as f64, p4.1 as f64)
  30         ) {
  31             Intersection::Point(p) => {
  32                 renderer.circle((p.x as i16, p.y as i16), 3, (255, 255, 0));
  33                 (0, 255, 0)
  34             }
  35             Intersection::None => (255, 0, 0)
  36         };
  37         renderer.draw_line(p1, p2, color);
  38         renderer.draw_line(p3, p4, color);
  39     }
  40 }
  41
  42 impl AppState for TestState {
  43     fn enter(&mut self, _ctrl_man: &ControllerManager) {}
  44
  45     fn update(&mut self, _dt: Duration) -> Option<StateChange> {
  46         None
  47     }
  48
  49     fn render(&mut self, renderer: &mut Renderer, _sprites: &SpriteManager) {
  50         // crossing
  51         self.draw_intersecting_lines(renderer, (0, 0), (20, 20), (20, 0), (0, 20));
  52         self.draw_intersecting_lines(renderer, (30, 10), (50, 10), (40, 0), (40, 20));
  53
  54         // just touching
  55         self.draw_intersecting_lines(renderer, (70, 0), (70, 10), (60, 10), (80, 10));
  56         self.draw_intersecting_lines(renderer, (90, 0), (100, 10), (90, 20), (110, 0));
  57         self.draw_intersecting_lines(renderer, (120, 0), (140, 20), (120, 20), (130, 10));
  58         self.draw_intersecting_lines(renderer, (170, 10), (160, 10), (160, 0), (160, 20));
  59
  60         // not touching
  61         self.draw_intersecting_lines(renderer, (190, 0), (210, 20), (195, 20), (200, 15));
  62
  63         let a = self.start.elapsed().as_seconds_f64().sin() * std::f64::consts::FRAC_PI_2;
  64         let (ax, ay) = ((a.cos() * 200.0) as i32, (a.sin() * 200.0) as i32);
  65         self.draw_intersecting_lines(renderer, (10, 400), (10 + ax, 400 + ay), (30, 200), (30, 600));
  66
  67         let x = (self.start.elapsed().as_seconds_f64().cos() * 60.0) as i32;
  68         let y = (self.start.elapsed().as_seconds_f64().sin() * 60.0) as i32;
  69         let x2 = ((self.start.elapsed().as_seconds_f64() + std::f64::consts::FRAC_PI_4).cos() * 60.0) as i32;
  70         let y2 = ((self.start.elapsed().as_seconds_f64() + std::f64::consts::FRAC_PI_4).sin() * 60.0) as i32;
  71         self.draw_intersecting_lines(renderer, (100 + x, 100 + y), (150 + x, 150 + y), (100 + x2, 150 + y2), (150 + x2, 100 + y2));
  72         self.draw_intersecting_lines(renderer, (250 + x, 85 + y), (250 + x, 165 + y), (210 + x2, 125 + y2), (290 + x2, 125 + y2));
  73
  74         let grid = Grid {
  75             size: dimen!(10, 10),
  76             scale: dimen!(30.0, 30.0),
  77             cells: vec!(vec!(false; 10); 10),
  78         };
  79
  80         let offset = point!(200, 200);
  81         let size = grid.scale;
  82         for x in 0..grid.size.width {
  83             for y in 0..grid.size.height {
  84                 let col = (32 + 32 * ((x + y) % 2)) as u8;
  85                 renderer.canvas().set_draw_color((col, col, col));
  86                 renderer.canvas().fill_rect(sdl2::rect::Rect::new(
  87                     offset.x + x as i32 * size.width as i32,
  88                     offset.y + y as i32 * size.height as i32,
  89                     size.width as u32,
  90                     size.height as u32)).unwrap();
  91             }
  92         }
  93
  94         let offsetf = point!(offset.x as f64, offset.y as f64);
  95 //      let p1 = point!(23.0, 16.0);
  96         let p1 = point!(300.0 / 2.0, 300.0 / 2.0);
  97         let p2 = {
  98             //let p = point!(78.0*3.0, 54.0*3.0);
  99             let p = self.mouse - offset;
 100             point!(p.x as f64, p.y as f64)
 101         };
 102         for p in grid.grid_coordinates_on_line(p1, p2) {
 103             renderer.canvas().set_draw_color((0, 96, 0));
 104             renderer.canvas().fill_rect(sdl2::rect::Rect::new(
 105                 offset.x + p.x as i32 * size.width as i32,
 106                 offset.y + p.y as i32 * size.height as i32,
 107                 size.width as u32,
 108                 size.height as u32)).unwrap();
 109         }
 110         let p1 = p1 + offsetf;
 111         let p2 = self.mouse;//p2 + offsetf;
 112         renderer.draw_line((p1.x as i32, p1.y as i32), (p2.x as i32, p2.y as i32), (255, 255, 0));
 113     }
 114
 115     fn leave(&mut self) {
 116     }
 117
 118     fn handle_event(&mut self, _event: Event) -> Option<StateChange> {
 119         match _event {
 120             Event::MouseMotion { x, y, .. } => self.mouse = point!(x, y),
 121             _ => {}
 122         }
 123         None
 124     }
 125 }