src/core/level/mod.rs

   1 use common::{Point, Dimension, Intersection, Angle, ToAngle, supercover_line};
   2 use core::render::Renderer;
   3 use sprites::SpriteManager;
   4 use std::rc::Rc;
   5 use {point, dimen};
   6
   7 mod lvlgen;
   8
   9 pub use self::lvlgen::LevelGenerator;
  10
  11 ////////// LEVEL ///////////////////////////////////////////////////////////////
  12
  13 #[derive(Default)]
  14 pub struct Level {
  15     pub gravity: Point<f64>,
  16     pub grid: Grid<bool>,
  17     walls: Vec<WallRegion>,
  18     wall_grid: Grid<Vec<Rc<WallEdge>>>,
  19 }
  20
  21 impl Level {
  22     pub fn new(gravity: Point<f64>, grid: Grid<bool>, mut walls: Vec<WallRegion>) -> Self {
  23         let size = (2560, 1440); // TODO: get actual size from walls or something
  24         let wall_grid = Level::build_wall_grid(&mut walls, &size.into());
  25         dbg!(&wall_grid.scale);
  26         Level {
  27             gravity,
  28             grid,
  29             walls,
  30             wall_grid,
  31         }
  32     }
  33
  34     /// Creates a grid of wall edges for fast lookup
  35     fn build_wall_grid(walls: &mut Vec<WallRegion>, lvlsize: &Dimension<usize>) -> Grid<Vec<Rc<WallEdge>>> {
  36         let size = dimen!(lvlsize.width / 20, lvlsize.height / 20); // TODO: make sure all walls fit within the grid bounds
  37         let cs = point!(lvlsize.width / size.width, lvlsize.height / size.height);
  38         //let cs = point!(scale.width as f64, scale.height as f64);
  39         let mut grid = Grid {
  40             cells: vec!(vec!(vec!(); size.height); size.width),
  41             size,
  42             scale: dimen!(cs.x as f64, cs.y as f64),
  43         };
  44
  45         for wall in walls {
  46             for edge in &wall.edges {
  47                 for c in grid.grid_coordinates_on_line(edge.p1, edge.p2) {
  48                     grid.cells[c.x][c.y].push(Rc::clone(edge));
  49                 }
  50             }
  51         }
  52
  53         grid
  54     }
  55
  56     pub fn render(&mut self, renderer: &mut Renderer, _sprites: &SpriteManager) {
  57         // original grid
  58         renderer.canvas().set_draw_color((64, 64, 64));
  59         let size = &self.grid.scale;
  60         for x in 0..self.grid.size.width {
  61             for y in 0..self.grid.size.height {
  62                 if self.grid.cells[x][y] {
  63                     renderer.canvas().fill_rect(sdl2::rect::Rect::new(
  64                         x as i32 * size.width as i32,
  65                         y as i32 * size.height as i32,
  66                         size.width as u32,
  67                         size.height as u32)).unwrap();
  68                 }
  69             }
  70         }
  71
  72         // wall grid
  73         renderer.canvas().set_draw_color((0, 32, 0));
  74         let size = &self.wall_grid.scale;
  75         for x in 0..self.wall_grid.size.width {
  76             for y in 0..self.wall_grid.size.height {
  77                 if !self.wall_grid.cells[x][y].is_empty() {
  78                     let num = self.wall_grid.cells[x][y].len();
  79                     renderer.canvas().set_draw_color((0, 32*num as u8, 0));
  80                     renderer.canvas().fill_rect(sdl2::rect::Rect::new(
  81                         x as i32 * size.width as i32,
  82                         y as i32 * size.height as i32,
  83                         size.width as u32,
  84                         size.height as u32)).unwrap();
  85                 }
  86             }
  87         }
  88
  89         // walls
  90         for wall in &self.walls {
  91             for e in &wall.edges {
  92                 let c = (e.p1 + e.p2) / 2.0;
  93                 let a = (e.p2 - e.p1).to_angle() + std::f64::consts::FRAC_PI_2.radians();
  94
  95                 renderer.draw_line(
  96                     <(i32, i32)>::from(c.to_i32()),
  97                     <(i32, i32)>::from((c + Point::from(a) * 10.0).to_i32()),
  98                     (255, 128, 0));
  99
 100                 renderer.draw_line(
 101                     <(i32, i32)>::from(e.p1.to_i32()),
 102                     <(i32, i32)>::from(e.p2.to_i32()),
 103                     (255, 255, 0));
 104             }
 105         }
 106     }
 107
 108     pub fn intersect_walls(&self, p1: Point<f64>, p2: Point<f64>) -> IntersectResult {
 109         for c in self.wall_grid.grid_coordinates_on_line(p1, p2) {
 110             for w in &self.wall_grid.cells[c.x][c.y] {
 111                 if let Intersection::Point(p) = Intersection::lines(p1, p2, w.p1, w.p2) {
 112                     let wall = Wall {
 113                         region: &self.walls[w.region],
 114                         edge: w,
 115                     };
 116                     return IntersectResult::Intersection(wall, p)
 117                 }
 118             }
 119         }
 120         IntersectResult::None
 121     }
 122 }
 123
 124 pub enum IntersectResult<'a> {
 125     Intersection(Wall<'a>, Point<f64>),
 126     None
 127 }
 128
 129 ////////// GRID ////////////////////////////////////////////////////////////////
 130
 131 #[derive(Debug, Default)]
 132 pub struct Grid<T> {
 133     pub size: Dimension<usize>,
 134     pub scale: Dimension<f64>,
 135     pub cells: Vec<Vec<T>>,
 136 }
 137
 138 impl<T> Grid<T> {
 139     pub fn at<C>(&self, c: C) -> Option<&T>
 140     where C: Into<(isize, isize)>
 141     {
 142         let c = c.into();
 143         if c.0 >= 0 && c.0 < self.size.width as isize && c.1 >= 0 && c.1 < self.size.height as isize {
 144             Some(&self.cells[c.0 as usize][c.1 as usize])
 145         } else {
 146             None
 147         }
 148     }
 149
 150     pub fn to_grid_coordinate<C>(&self, c: C) -> Option<Point<usize>>
 151     where C: Into<(isize, isize)>
 152     {
 153         let c = c.into();
 154         if c.0 >= 0 && c.0 < self.size.width as isize && c.1 >= 0 && c.1 < self.size.height as isize {
 155             Some(point!(c.0 as usize, c.1 as usize))
 156         } else {
 157             None
 158         }
 159     }
 160
 161     /// Returns a list of grid coordinates that a line in world coordinates passes through.
 162     pub fn grid_coordinates_on_line(&self, p1: Point<f64>, p2: Point<f64>) -> Vec<Point<usize>> {
 163         supercover_line(p1 / self.scale, p2 / self.scale)
 164             .iter()
 165             .map(|c| self.to_grid_coordinate(*c))
 166             .flatten()
 167             .collect()
 168     }
 169 }
 170
 171 ////////// WALL REGION /////////////////////////////////////////////////////////
 172
 173 #[derive(Debug)]
 174 pub struct WallRegion {
 175     edges: Vec<Rc<WallEdge>>,
 176 }
 177
 178 impl WallRegion {
 179     pub fn new(points: Vec<Point<f64>>) -> Self {
 180         let index: RegionIndex = 0; // use as param
 181         let mut edges = Vec::with_capacity(points.len());
 182
 183         for i in 0..points.len() {
 184             let edge = Rc::new(WallEdge {
 185                 region: index,
 186                 id: i,
 187                 p1: points[i],
 188                 p2: points[(i + 1) % points.len()],
 189             });
 190             edges.push(edge);
 191         }
 192
 193         WallRegion { edges }
 194     }
 195
 196     // #[allow(dead_code)]
 197     // fn next(&self, index: EdgeIndex) -> Rc<WallEdge> {
 198     //  let index = (index + 1) % self.edges.len();
 199     //  Rc::clone(&self.edges[index])
 200     // }
 201
 202     // #[allow(dead_code)]
 203     // fn previous(&self, index: EdgeIndex) -> Rc<WallEdge> {
 204     //  let index = (index + self.edges.len() + 1) % self.edges.len();
 205     //  Rc::clone(&self.edges[index])
 206     // }
 207 }
 208
 209 ////////// WALL EDGE ///////////////////////////////////////////////////////////
 210
 211 type RegionIndex = usize;
 212 type EdgeIndex = usize;
 213
 214 #[derive(Debug, Default)]
 215 struct WallEdge {
 216     region: RegionIndex,
 217     id: EdgeIndex,
 218     pub p1: Point<f64>,
 219     pub p2: Point<f64>,
 220 }
 221
 222 ////////// WALL ////////////////////////////////////////////////////////////////
 223
 224 /// kommer det här att fungera ifall nåt objekt ska spara en referens till Wall?
 225 /// kanske istället ska lägga Vec<WallRegion> i en Rc<Walls> och skicka med en klon av den, samt id:n till regionen och väggen?
 226 pub struct Wall<'a> {
 227     region: &'a WallRegion,
 228     edge: &'a WallEdge,
 229 }
 230
 231 impl<'a> Wall<'a> {
 232     pub fn next(&self) -> Wall<'a> {
 233         let next = (self.edge.id + 1) % self.region.edges.len();
 234         let edge = &self.region.edges[next];
 235         Wall {
 236             region: self.region,
 237             edge,
 238         }
 239     }
 240
 241     pub fn previous(&self) -> Wall<'a> {
 242         let prev = (self.edge.id + self.region.edges.len() - 1) % self.region.edges.len();
 243         let edge = &self.region.edges[prev];
 244         Wall {
 245             region: self.region,
 246             edge,
 247         }
 248     }
 249
 250     pub fn normal(&self) -> Angle {
 251         (self.edge.p2 - self.edge.p1).to_angle() + std::f64::consts::FRAC_PI_2.radians()
 252     }
 253 }