Refactor walls

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

use common::{Point, Dimension, Intersection, 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<Rc<WallRegion>>,
    wall_grid: Grid<Vec<Rc<WallEdge>>>,
}

impl Level {
    pub fn new(gravity: Point<f64>, grid: Grid<bool>, mut walls: Vec<Rc<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.cell_size);
	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!(cell_size.width as f64, cell_size.height as f64);
	let mut grid = Grid {
	    cells: vec!(vec!(vec!(); size.height); size.width),
	    size,
	    cell_size: dimen!(cs.x, cs.y),
	};

	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.cell_size;
	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.cell_size;
	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 {
		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) {
	    if let walls = &self.wall_grid.cells[c.x][c.y] {
		for w in walls {
		    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 cell_size: Dimension<usize>,
    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>> {
	let scale = (self.cell_size.width as f64, self.cell_size.height as f64);
	supercover_line(p1 / scale, p2 / 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,
	}
    }
}