use {point, time_scope};
-use common::Point2D;
+use common::Point;
use super::{Grid, Level};
use noise::{NoiseFn, OpenSimplex, Seedable};
use rand::Rng;
}
#[allow(dead_code)]
- fn simplex_noise(&self, grid: &mut Grid) {
+ fn simplex_noise(&self, grid: &mut Grid<bool>) {
let noise = OpenSimplex::new().set_seed(self.seed);
self.set_each(grid, |x, y| noise.get([x as f64 / 12.0, y as f64 / 12.0]) > 0.055, 1);
}
#[allow(dead_code)]
- fn random_noise(&self, grid: &mut Grid) {
+ fn random_noise(&self, grid: &mut Grid<bool>) {
let mut rng: rand::prelude::StdRng = rand::SeedableRng::seed_from_u64(self.seed as u64);
let noise = OpenSimplex::new().set_seed(self.seed);
self.set_each(grid, |_x, _y| rng.gen_range(0, 100) > (45 + (150.0 * noise.get([_x as f64 / 40.0, _y as f64 / 10.0])) as usize), 1); // more horizontal platforms
}
#[allow(dead_code)]
- fn smooth(&self, grid: &mut Grid) {
+ fn smooth(&self, grid: &mut Grid<bool>) {
let distance = 1;
for _i in 0..self.iterations {
let mut next = vec!(vec!(true; grid.height); grid.width);
}
#[allow(dead_code)]
- fn smooth_until_equilibrium(&self, grid: &mut Grid) {
+ fn smooth_until_equilibrium(&self, grid: &mut Grid<bool>) {
let distance = 1;
let mut count = 0;
loop {
count
}
- fn set_each<F: FnMut(usize, usize) -> bool>(&self, grid: &mut Grid, mut func: F, walls: usize) {
+ fn set_each<F: FnMut(usize, usize) -> bool>(&self, grid: &mut Grid<bool>, mut func: F, walls: usize) {
for x in walls..(grid.width - walls) {
for y in walls..(grid.height - walls) {
grid.cells[x][y] = func(x, y);
}
}
- fn subdivide(&self, grid: &mut Grid) -> Grid {
+ fn subdivide(&self, grid: &mut Grid<bool>) -> Grid<bool> {
let (width, height) = (grid.width * 2, grid.height * 2);
let mut cells = vec!(vec!(true; height); width);
for x in 1..(width - 1) {
}
}
- fn find_regions(&self, grid: &Grid) -> Vec<Region> {
+ fn find_regions(&self, grid: &Grid<bool>) -> Vec<Region> {
time_scope!("finding all regions");
let mut regions = vec!();
let mut marked = vec!(vec!(false; grid.height); grid.width);
regions
}
- fn get_region_at_point(&self, grid: &Grid, x: usize, y: usize, marked: &mut Vec<Vec<bool>>) -> Region {
+ fn get_region_at_point(&self, grid: &Grid<bool>, x: usize, y: usize, marked: &mut Vec<Vec<bool>>) -> Region {
let value = grid.cells[x][y];
let mut cells = vec!();
let mut queue = vec!((x, y));
Region { value, cells }
}
- fn delete_region(&self, grid: &mut Grid, region: &Region) {
+ fn delete_region(&self, grid: &mut Grid<bool>, region: &Region) {
for c in ®ion.cells {
grid.cells[c.0][c.1] = !region.value;
}
}
- fn filter_regions(&self, grid: &mut Grid) {
+ fn filter_regions(&self, grid: &mut Grid<bool>) {
let min_wall_size = 0.0015;
println!("grid size: ({}, {}) = {} cells", grid.width, grid.height, grid.width * grid.height);
println!("min wall size: {}", (grid.width * grid.height) as f64 * min_wall_size);
}
}
- fn find_walls(&self, grid: &Grid) -> Vec<Vec<Point2D<isize>>> {
+ fn find_walls(&self, grid: &Grid<bool>) -> Vec<Vec<Point<isize>>> {
let mut walls = vec!();
for r in self.find_regions(&grid) {
if r.value {
(min.0, min.1, 1 + max.0 - min.0, 1 + max.1 - min.1)
}
- pub fn outline(&self, scale: usize) -> Vec<Point2D<isize>> {
+ pub fn outline(&self, scale: usize) -> Vec<Point<isize>> {
let rect = self.enclosing_rect();
let (ox, oy, w, h) = rect;
let grid = self.grid(&rect);
grid
}
- fn find_first_point_of_outline(&self, rect: &(usize, usize, usize, usize), grid: &Vec<Vec<bool>>) -> Point2D<isize> {
+ fn find_first_point_of_outline(&self, rect: &(usize, usize, usize, usize), grid: &Vec<Vec<bool>>) -> Point<isize> {
let (ox, oy, w, h) = rect;
let is_outer_wall = (ox, oy) == (&0, &0); // we know this is always the outer wall of the level
for x in 0..*w {
panic!("no wall found!");
}
- fn find_next_point_of_outline(&self, grid: &Vec<Vec<bool>>, p: &mut Point2D<isize>, directions: &mut Vec<(isize, isize)>) {
+ fn find_next_point_of_outline(&self, grid: &Vec<Vec<bool>>, p: &mut Point<isize>, directions: &mut Vec<(isize, isize)>) {
directions.rotate_left(2);
loop {
let d = directions[0];
}
}
- fn check(&self, p: Point2D<isize>, grid: &Vec<Vec<bool>>) -> bool {
+ fn check(&self, p: Point<isize>, grid: &Vec<Vec<bool>>) -> bool {
if p.x < 0 || p.x >= grid.len() as isize || p.y < 0 || p.y >= grid[0].len() as isize {
false
} else {