[kaka/rust-sdl-test.git] / src / core / level / mod.rs

use common::{Point, Dimension, Intersection, Radians, supercover_line};
use core::render::Renderer;
use sprites::SpriteManager;
use std::rc::Rc;
use {point, dimen};

mod lvlgen;

pub use self::lvlgen::LevelGenerator;

////////// LEVEL ///////////////////////////////////////////////////////////////

#[derive(Default)]
pub struct Level {
    pub gravity: Point<f64>,
    pub grid: Grid<bool>,
    walls: Vec<WallRegion>,
    wall_grid: Grid<Vec<Rc<WallEdge>>>,
}

impl Level {
    pub fn new(gravity: Point<f64>, grid: Grid<bool>, mut walls: Vec<WallRegion>) -> Self {
	let size = (2560, 1440); // TODO: get actual size from walls or something
	let wall_grid = Level::build_wall_grid(&mut walls, &size.into());
	dbg!(&wall_grid.scale);
	Level {
	    gravity,
	    grid,
	    walls,
	    wall_grid,
	}
    }

    /// Creates a grid of wall edges for fast lookup
    fn build_wall_grid(walls: &mut Vec<WallRegion>, lvlsize: &Dimension<usize>) -> Grid<Vec<Rc<WallEdge>>> {
	let size = dimen!(lvlsize.width / 20, lvlsize.height / 20); // TODO: make sure all walls fit within the grid bounds
	let cs = point!(lvlsize.width / size.width, lvlsize.height / size.height);
	//let cs = point!(scale.width as f64, scale.height as f64);
	let mut grid = Grid {
	    cells: vec!(vec!(vec!(); size.height); size.width),
	    size,
	    scale: dimen!(cs.x as f64, cs.y as f64),
	};

	for wall in walls {
	    for edge in &wall.edges {
		for c in grid.grid_coordinates_on_line(edge.p1, edge.p2) {
		    grid.cells[c.x][c.y].push(Rc::clone(edge));
		}
	    }
	}

	grid
    }

    pub fn render(&mut self, renderer: &mut Renderer, _sprites: &SpriteManager) {
	// original grid
	renderer.canvas().set_draw_color((64, 64, 64));
	let size = &self.grid.scale;
	for x in 0..self.grid.size.width {
	    for y in 0..self.grid.size.height {
		if self.grid.cells[x][y] {
		    renderer.canvas().fill_rect(sdl2::rect::Rect::new(
			x as i32 * size.width as i32,
			y as i32 * size.height as i32,
			size.width as u32,
			size.height as u32)).unwrap();
		}
	    }
	}

	// wall grid
	renderer.canvas().set_draw_color((0, 32, 0));
	let size = &self.wall_grid.scale;
	for x in 0..self.wall_grid.size.width {
	    for y in 0..self.wall_grid.size.height {
		if !self.wall_grid.cells[x][y].is_empty() {
		    let num = self.wall_grid.cells[x][y].len();
		    renderer.canvas().set_draw_color((0, 32*num as u8, 0));
		    renderer.canvas().fill_rect(sdl2::rect::Rect::new(
			x as i32 * size.width as i32,
			y as i32 * size.height as i32,
			size.width as u32,
			size.height as u32)).unwrap();
		}
	    }
	}

	// walls
	for wall in &self.walls {
	    for e in &wall.edges {
		let c = (e.p1 + e.p2) / 2.0;
		let mut rad = (e.p2 - e.p1).to_radians();
		rad.0 += std::f64::consts::FRAC_PI_2;

		renderer.draw_line(
		    <(i32, i32)>::from(c.to_i32()),
		    <(i32, i32)>::from((c + Point::from(rad) * 10.0).to_i32()),
		    (255, 128, 0));

		renderer.draw_line(
		    <(i32, i32)>::from(e.p1.to_i32()),
		    <(i32, i32)>::from(e.p2.to_i32()),
		    (255, 255, 0));
	    }
	}
    }

    pub fn intersect_walls(&self, p1: Point<f64>, p2: Point<f64>) -> IntersectResult {
	for c in self.wall_grid.grid_coordinates_on_line(p1, p2) {
	    for w in &self.wall_grid.cells[c.x][c.y] {
		if let Intersection::Point(p) = Intersection::lines(p1, p2, w.p1, w.p2) {
		    let wall = Wall {
			region: &self.walls[w.region],
			edge: w,
		    };
		    return IntersectResult::Intersection(wall, p)
		}
	    }
	}
	IntersectResult::None
    }
}

pub enum IntersectResult<'a> {
    Intersection(Wall<'a>, Point<f64>),
    None
}

////////// GRID ////////////////////////////////////////////////////////////////

#[derive(Debug, Default)]
pub struct Grid<T> {
    pub size: Dimension<usize>,
    pub scale: Dimension<f64>,
    pub cells: Vec<Vec<T>>,
}

impl<T> Grid<T> {
    pub fn at<C>(&self, c: C) -> Option<&T>
    where C: Into<(isize, isize)>
    {
	let c = c.into();
	if c.0 >= 0 && c.0 < self.size.width as isize && c.1 >= 0 && c.1 < self.size.height as isize {
	    Some(&self.cells[c.0 as usize][c.1 as usize])
	} else {
	    None
	}
    }

    pub fn to_grid_coordinate<C>(&self, c: C) -> Option<Point<usize>>
    where C: Into<(isize, isize)>
    {
	let c = c.into();
	if c.0 >= 0 && c.0 < self.size.width as isize && c.1 >= 0 && c.1 < self.size.height as isize {
	    Some(point!(c.0 as usize, c.1 as usize))
	} else {
	    None
	}
    }

    /// Returns a list of grid coordinates that a line in world coordinates passes through.
    pub fn grid_coordinates_on_line(&self, p1: Point<f64>, p2: Point<f64>) -> Vec<Point<usize>> {
	supercover_line(p1 / self.scale, p2 / self.scale)
	    .iter()
	    .map(|c| self.to_grid_coordinate(*c))
	    .flatten()
	    .collect()
    }
}

////////// WALL REGION /////////////////////////////////////////////////////////

#[derive(Debug)]
pub struct WallRegion {
    edges: Vec<Rc<WallEdge>>,
}

impl WallRegion {
    pub fn new(points: Vec<Point<f64>>) -> Self {
	let index: RegionIndex = 0; // use as param
	let mut edges = Vec::with_capacity(points.len());

	for i in 0..points.len() {
	    let edge = Rc::new(WallEdge {
		region: index,
		id: i,
		p1: points[i],
		p2: points[(i + 1) % points.len()],
	    });
	    edges.push(edge);
	}

	WallRegion { edges }
    }

    // #[allow(dead_code)]
    // fn next(&self, index: EdgeIndex) -> Rc<WallEdge> {
    // 	let index = (index + 1) % self.edges.len();
    // 	Rc::clone(&self.edges[index])
    // }

    // #[allow(dead_code)]
    // fn previous(&self, index: EdgeIndex) -> Rc<WallEdge> {
    // 	let index = (index + self.edges.len() + 1) % self.edges.len();
    // 	Rc::clone(&self.edges[index])
    // }
}

////////// WALL EDGE ///////////////////////////////////////////////////////////

type RegionIndex = usize;
type EdgeIndex = usize;

#[derive(Debug, Default)]
struct WallEdge {
    region: RegionIndex,
    id: EdgeIndex,
    pub p1: Point<f64>,
    pub p2: Point<f64>,
}

////////// WALL ////////////////////////////////////////////////////////////////

/// kommer det här att fungera ifall nåt objekt ska spara en referens till Wall?
/// 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?
pub struct Wall<'a> {
    region: &'a WallRegion,
    edge: &'a WallEdge,
}

impl<'a> Wall<'a> {
    pub fn next(&self) -> Wall<'a> {
	let next = (self.edge.id + 1) % self.region.edges.len();
	let edge = &self.region.edges[next];
	Wall {
	    region: self.region,
	    edge,
	}
    }

    pub fn previous(&self) -> Wall<'a> {
	let prev = (self.edge.id + self.region.edges.len() - 1) % self.region.edges.len();
	let edge = &self.region.edges[prev];
	Wall {
	    region: self.region,
	    edge,
	}
    }

    pub fn normal(&self) -> Radians {
	let mut rad = (self.edge.p2 - self.edge.p1).to_radians();
	rad.0 += std::f64::consts::FRAC_PI_2;
	rad
    }
}
Commit	Line	Data
	1	use common::{Point, Dimension, Intersection, Radians, 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 mut rad = (e.p2 - e.p1).to_radians();
	94	rad.0 += std::f64::consts::FRAC_PI_2;
	95
	96	renderer.draw_line(
	97	<(i32, i32)>::from(c.to_i32()),
	98	<(i32, i32)>::from((c + Point::from(rad) * 10.0).to_i32()),
	99	(255, 128, 0));
	100
	101	renderer.draw_line(
	102	<(i32, i32)>::from(e.p1.to_i32()),
	103	<(i32, i32)>::from(e.p2.to_i32()),
	104	(255, 255, 0));
	105	}
	106	}
	107	}
	108
	109	pub fn intersect_walls(&self, p1: Point<f64>, p2: Point<f64>) -> IntersectResult {
	110	for c in self.wall_grid.grid_coordinates_on_line(p1, p2) {
	111	for w in &self.wall_grid.cells[c.x][c.y] {
	112	if let Intersection::Point(p) = Intersection::lines(p1, p2, w.p1, w.p2) {
	113	let wall = Wall {
	114	region: &self.walls[w.region],
	115	edge: w,
	116	};
	117	return IntersectResult::Intersection(wall, p)
	118	}
	119	}
	120	}
	121	IntersectResult::None
	122	}
	123	}
	124
	125	pub enum IntersectResult<'a> {
	126	Intersection(Wall<'a>, Point<f64>),
	127	None
	128	}
	129
	130	////////// GRID ////////////////////////////////////////////////////////////////
	131
	132	#[derive(Debug, Default)]
	133	pub struct Grid<T> {
	134	pub size: Dimension<usize>,
	135	pub scale: Dimension<f64>,
	136	pub cells: Vec<Vec<T>>,
	137	}
	138
	139	impl<T> Grid<T> {
	140	pub fn at<C>(&self, c: C) -> Option<&T>
	141	where C: Into<(isize, isize)>
	142	{
	143	let c = c.into();
	144	if c.0 >= 0 && c.0 < self.size.width as isize && c.1 >= 0 && c.1 < self.size.height as isize {
	145	Some(&self.cells[c.0 as usize][c.1 as usize])
	146	} else {
	147	None
	148	}
	149	}
	150
	151	pub fn to_grid_coordinate<C>(&self, c: C) -> Option<Point<usize>>
	152	where C: Into<(isize, isize)>
	153	{
	154	let c = c.into();
	155	if c.0 >= 0 && c.0 < self.size.width as isize && c.1 >= 0 && c.1 < self.size.height as isize {
	156	Some(point!(c.0 as usize, c.1 as usize))
	157	} else {
	158	None
	159	}
	160	}
	161
	162	/// Returns a list of grid coordinates that a line in world coordinates passes through.
	163	pub fn grid_coordinates_on_line(&self, p1: Point<f64>, p2: Point<f64>) -> Vec<Point<usize>> {
	164	supercover_line(p1 / self.scale, p2 / self.scale)
	165	.iter()
	166	.map(\|c\| self.to_grid_coordinate(*c))
	167	.flatten()
	168	.collect()
	169	}
	170	}
	171
	172	////////// WALL REGION /////////////////////////////////////////////////////////
	173
	174	#[derive(Debug)]
	175	pub struct WallRegion {
	176	edges: Vec<Rc<WallEdge>>,
	177	}
	178
	179	impl WallRegion {
	180	pub fn new(points: Vec<Point<f64>>) -> Self {
	181	let index: RegionIndex = 0; // use as param
	182	let mut edges = Vec::with_capacity(points.len());
	183
	184	for i in 0..points.len() {
	185	let edge = Rc::new(WallEdge {
	186	region: index,
	187	id: i,
	188	p1: points[i],
	189	p2: points[(i + 1) % points.len()],
	190	});
	191	edges.push(edge);
	192	}
	193
	194	WallRegion { edges }
	195	}
	196
	197	// #[allow(dead_code)]
	198	// fn next(&self, index: EdgeIndex) -> Rc<WallEdge> {
	199	// let index = (index + 1) % self.edges.len();
	200	// Rc::clone(&self.edges[index])
	201	// }
	202
	203	// #[allow(dead_code)]
	204	// fn previous(&self, index: EdgeIndex) -> Rc<WallEdge> {
	205	// let index = (index + self.edges.len() + 1) % self.edges.len();
	206	// Rc::clone(&self.edges[index])
	207	// }
	208	}
	209
	210	////////// WALL EDGE ///////////////////////////////////////////////////////////
	211
	212	type RegionIndex = usize;
	213	type EdgeIndex = usize;
	214
	215	#[derive(Debug, Default)]
	216	struct WallEdge {
	217	region: RegionIndex,
	218	id: EdgeIndex,
	219	pub p1: Point<f64>,
	220	pub p2: Point<f64>,
	221	}
	222
	223	////////// WALL ////////////////////////////////////////////////////////////////
	224
	225	/// kommer det här att fungera ifall nåt objekt ska spara en referens till Wall?
	226	/// 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?
	227	pub struct Wall<'a> {
	228	region: &'a WallRegion,
	229	edge: &'a WallEdge,
	230	}
	231
	232	impl<'a> Wall<'a> {
	233	pub fn next(&self) -> Wall<'a> {
	234	let next = (self.edge.id + 1) % self.region.edges.len();
	235	let edge = &self.region.edges[next];
	236	Wall {
	237	region: self.region,
	238	edge,
	239	}
	240	}
	241
	242	pub fn previous(&self) -> Wall<'a> {
	243	let prev = (self.edge.id + self.region.edges.len() - 1) % self.region.edges.len();
	244	let edge = &self.region.edges[prev];
	245	Wall {
	246	region: self.region,
	247	edge,
	248	}
	249	}
	250
	251	pub fn normal(&self) -> Radians {
	252	let mut rad = (self.edge.p2 - self.edge.p1).to_radians();
	253	rad.0 += std::f64::consts::FRAC_PI_2;
	254	rad
	255	}
	256	}