From 9a6d1261d88ddaec58166d83b44b134948a9fabc Mon Sep 17 00:00:00 2001
From: =?utf8?q?Tomas=20Wenstr=C3=B6m?= <tomas.wenstrom@gmail.com>
Date: Sat, 30 Jan 2021 18:01:03 +0100
Subject: [PATCH] Made wall smoothness adjustable

---
 src/core/game.rs         | 14 +++++++++++---
 src/core/level/lvlgen.rs | 24 +++++++++++++++---------
 2 files changed, 26 insertions(+), 12 deletions(-)

diff --git a/src/core/game.rs b/src/core/game.rs
index 3dacac1..3e424fd 100644
--- a/src/core/game.rs
+++ b/src/core/game.rs
@@ -26,7 +26,7 @@ pub struct GameState {
 
 impl GameState {
     pub fn new() -> Self {
-	let lvlgen = LevelGenerator::new(0, 5);
+	let lvlgen = LevelGenerator::new(0);
 	GameState {
 	    world: World::new(lvlgen.generate()),
 	    lvlgen,
@@ -66,13 +66,21 @@ impl AppState for GameState {
 	    }
 	    Event::KeyDown { keycode: Some(Keycode::KpPlus), .. } => {
 		self.lvlgen.iterations += 1;
-		println!("{} iteration(s) of cellular automata", self.lvlgen.iterations);
 		self.world.level = self.lvlgen.generate();
 	    }
 	    Event::KeyDown { keycode: Some(Keycode::KpMinus), .. } => {
 		if self.lvlgen.iterations > 0 {
 		    self.lvlgen.iterations -= 1;
-		    println!("{} iteration(s) of cellular automata", self.lvlgen.iterations);
+		    self.world.level = self.lvlgen.generate();
+		}
+	    }
+	    Event::KeyDown { keycode: Some(Keycode::KpMultiply), .. } => {
+		self.lvlgen.wall_smooth_radius += 1;
+		self.world.level = self.lvlgen.generate();
+	    }
+	    Event::KeyDown { keycode: Some(Keycode::KpDivide), .. } => {
+		if self.lvlgen.wall_smooth_radius > 0 {
+		    self.lvlgen.wall_smooth_radius -= 1;
 		    self.world.level = self.lvlgen.generate();
 		}
 	    }
diff --git a/src/core/level/lvlgen.rs b/src/core/level/lvlgen.rs
index a549166..4a22807 100644
--- a/src/core/level/lvlgen.rs
+++ b/src/core/level/lvlgen.rs
@@ -6,19 +6,25 @@ use rand::Rng;
 
 ////////// LEVEL GENERATOR /////////////////////////////////////////////////////
 
-#[derive(Default)]
+#[derive(Debug, Default)]
 pub struct LevelGenerator {
     pub seed: u32,
     pub iterations: u8,
+    pub wall_smooth_radius: u8,
 }
 
 impl LevelGenerator {
-    pub fn new(seed: u32, iterations: u8) -> Self{
-	LevelGenerator { seed, iterations }
+    pub fn new(seed: u32) -> Self{
+	LevelGenerator {
+	    seed,
+	    iterations: 5,
+	    wall_smooth_radius: 2,
+	}
     }
 
     pub fn generate(&self) -> Level {
-	time_scope!("grid generation");
+	println!("new level from {:?}", self);
+	time_scope!("level generation");
 
 	let cell_size = 20;
 	let (width, height) = (2560 / cell_size, 1440 / cell_size);
@@ -114,7 +120,7 @@ impl LevelGenerator {
 		grid.cells = next;
 	    }
 	}
-	println!("{} iterations needed", count);
+	println!("  {} iterations needed", count);
     }
 
     fn neighbours(&self, grid: &Vec<Vec<bool>>, px: usize, py: usize, distance: usize) -> u8 {
@@ -154,7 +160,7 @@ impl LevelGenerator {
     }
 
     fn find_regions(&self, grid: &Grid<bool>) -> Vec<Region> {
-	time_scope!("finding all regions");
+	time_scope!("  finding all regions");
 	let mut regions = vec!();
 	let mut marked = vec!(vec!(false; grid.height); grid.width);
 	for x in 0..grid.width {
@@ -198,14 +204,14 @@ impl LevelGenerator {
 
     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);
+	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);
 
 	// delete all smaller wall regions
 	for r in self.find_regions(grid).iter().filter(|r| r.value) {
 	    let percent = r.cells.len() as f64 / (grid.width * grid.height) as f64;
 	    if percent < min_wall_size {
-		// println!("delete wall region of size {}", r.cells.len());
+		// println!("  delete wall region of size {}", r.cells.len());
 		self.delete_region(grid, r);
 	    }
 	}
-- 
2.11.0