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

use common::{Point, Dimension, Intersection, Angle, ToAngle, 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 a = (e.p2 - e.p1).to_angle() + std::f64::consts::FRAC_PI_2.radians();

		renderer.draw_line(
		    <(i32, i32)>::from(c.to_i32()),
		    <(i32, i32)>::from((c + Point::from(a) * 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) -> Angle {
	(self.edge.p2 - self.edge.p1).to_angle() + std::f64::consts::FRAC_PI_2.radians()
    }
}
Commit	Line	Data
	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	}