Clean up Water, Not perfect but better

The code half works, in that it generates a somewhat desirable terrain but there are inconsistencies in the output. Sometimes random cliff tiles are created in the center of a body of water. The bigger issue is that is only places cliffs or edges due to the raw noise value which is equal in areas. So some form of intervention is needed to have cliffs and ramps mixed for instances of elevation layers. The rotation of the tiles is also incorrect and needs work to rotate correctly, which is assumed to be an easy fix to do later.

Author: kthecoder

src/TerrainGen/Terrain_Gen.cpp

@@ -29,7 +29,9 @@ void TerrainGen::generate(GridMap *myGridMap, int height, int width, int depth,
 	vector<vector<vector<int>>> gridMap(
 			depth, vector<vector<int>>(width, vector<int>(height, 0)));
 
+	vector<vector<float>> rawNoise(width, vector<float>(height, 0));
 	vector<vector<int>> elevationMap(width, vector<int>(height, 0));
+	vector<vector<TileType>> tileMap(width, vector<TileType>(height, GROUND));
 
 	int blockSize = 4;
 	int reducedX = floor(width / blockSize);
@@ -50,6 +52,7 @@ void TerrainGen::generate(GridMap *myGridMap, int height, int width, int depth,
 		for (int y = 0; y < height; y++) {
 			float currentNoise = noise->get_noise_2d((float)x, (float)y);
 
+			rawNoise[x][y] = currentNoise;
 			// Normalize and scale noise to [0, depth]
 			float normalizedNoise = (currentNoise + 1.0f) / 2.0f;
 			elevationMap[x][y] = round(normalizedNoise * depth);
@@ -90,20 +93,50 @@ void TerrainGen::generate(GridMap *myGridMap, int height, int width, int depth,
 			}
 		}
 	}
+
+	//Smoothing
+	// 	Ensure elevation change's aren't in succession
+	//TODO...
+
+	// Water Clean Up
+	for (int x = 1; x < width - 1; x++) {
+		for (int y = 1; y < height - 1; y++) {
+			if (elevationMap[x][y] > 0) { // Check if it's an elevated tile
+				int waterCount = 0;
+
+				// Check surrounding 3x3 neighbors
+				for (int dx = -1; dx <= 1; dx++) {
+					for (int dy = -1; dy <= 1; dy++) {
+						if (elevationMap[x + dx][y + dy] == 0) {
+							waterCount++;
+						}
+					}
+				}
+
+				// If it's surrounded by water, set elevation to 0
+				if (waterCount >= 5) {
+					elevationMap[x][y] = 0;
+				}
+			}
+		}
+	}
+
 	/*****************************************************
 
 	Tile Placement
 
 	*****************************************************/
 
-	bool forceCliff = false; // Track cliff sections
-
+	// Loop over all the grid cells
 	for (int x = 0; x < width; ++x) {
 		for (int y = 0; y < height; ++y) {
+			//Get the elevation for the current grid cell
 			int elevation = elevationMap[x][y];
 
-			TileType tileType = GROUND;
+			//Init the current grid cell to ground
+			tileMap[x][y] = GROUND;
 
+			// Setup booleans & Ints
 			bool needsRamp = false, needsCliff = false, adjacentToWater = false;
 
 			int rotationOrientation = 0;
@@ -113,88 +146,76 @@ void TerrainGen::generate(GridMap *myGridMap, int height, int width, int depth,
 			int waterEdgeNeighbors = 0;
 			int waterNeighbors[4] = { 0, 0, 0, 0 };
 
+			// If Elevation is 0, we get water tiles
 			if (elevation == 0) {
 				myGridMap->set_cell_item(Vector3i(x, elevation, y), WATER, 0);
 				continue;
 			}
 
+			// Get the cardinal neighbors
 			int neighborElevations[4] = { elevation, elevation, elevation, elevation };
 
+			// Loop through and assign value to the cardinal neighbors
 			for (int d = 0; d < 4; ++d) {
 				int nx = x + dx[d];
 				int ny = y + dy[d];
 
 				if (nx >= 0 && ny >= 0 && nx < width && ny < height) {
-					neighborElevations[d] = elevationMap[nx][ny];
-				}
-
-				if (nx >= 0 && ny >= 0 && nx < width && ny < height) {
+					// Get Neighbors Elevation
 					neighborElevations[d] = elevationMap[nx][ny];
 					if (neighborElevations[d] == 0) {
+						// If neighbor is water, store that info
 						adjacentToWater = true;
 						waterNeighbors[d] = 1;
 					}
 				}
 			}
 
+			// Loop through the grid cells cardinal neighbors again
 			for (int d = 0; d < 4; ++d) {
+				// Find the Elevation diff between neighbors
 				int diff = neighborElevations[d] - elevation;
 
+				// If not 0, then there is a change
 				if (diff != 0)
 					numDirectionChanges++;
 
+				// If an elevation diff of 1
 				if (diff == 1 || diff == -1) {
+					//We have elevation change
+
 					numElevationChanges++;
 					maxElevationChange = max(maxElevationChange, abs(diff));
 
 					float randomFactor = (float)rand() / RAND_MAX;
 
-					if (forceCliff || randomFactor < 0.2) {
-						tileType = CLIFF;
-						forceCliff = true;
+					// Set Cliffs or Ramps since Elevation has changed
+					if (rawNoise[x][y] < 0.4) {
+						tileMap[x][y] = CLIFF;
 					} else {
-						tileType = RAMP;
-						forceCliff = false;
+						tileMap[x][y] = RAMP;
 					}
 				}
 			}
 
+			// If grid cell is adjacent to water
 			if (adjacentToWater) {
+				// Get the cardinal neighbors
 				waterEdgeNeighbors = waterNeighbors[0] + waterNeighbors[1] + waterNeighbors[2] + waterNeighbors[3];
 
+				// Decide if it needs to be a water edge or a water corner
 				if (waterEdgeNeighbors == 1) {
-					tileType = WATER_EDGE;
+					tileMap[x][y] = WATER_EDGE;
 				} else if (
 						(waterNeighbors[0] && waterNeighbors[1]) ||
 						(waterNeighbors[1] && waterNeighbors[2]) ||
 						(waterNeighbors[2] && waterNeighbors[3]) ||
 						(waterNeighbors[3] && waterNeighbors[0])) {
-					tileType = WATER_CORNER; // Two adjacent water edges form a corner
+					tileMap[x][y] = WATER_CORNER; // Two adjacent water edges form a corner
 				}
 			}
 
-			if (tileType == CLIFF && forceCliff) {
-				forceCliff = true;
-			} else if (tileType == RAMP) {
-				forceCliff = false;
-			}
-
-			if (numElevationChanges >= 2) {
-				if (tileType == RAMP)
-					tileType = RAMP_CORNER;
-				if (tileType == CLIFF)
-					tileType = CLIFF_CORNER;
-			}
-
-			if (tileType == WATER) {
-				if (numDirectionChanges == 1) {
-					tileType = WATER_EDGE;
-				} else if (numDirectionChanges >= 2) {
-					tileType = WATER_CORNER;
-				}
-			}
-
-			if (tileType == RAMP || tileType == CLIFF || tileType == RAMP_CORNER || tileType == CLIFF_CORNER) {
+			if (tileMap[x][y] == RAMP || tileMap[x][y] == CLIFF || tileMap[x][y] == RAMP_CORNER || tileMap[x][y] == CLIFF_CORNER) {
 				int highestNeighborIndex = -1;
 				int secondaryNeighborIndex = -1;
 				int highestNeighborElevation = elevation;
@@ -260,11 +281,36 @@ void TerrainGen::generate(GridMap *myGridMap, int height, int width, int depth,
 
 			*****************************************************/
 
-			myGridMap->set_cell_item(Vector3i(x, elevation, y), tileType, rotationOrientation);
+			myGridMap->set_cell_item(Vector3i(x, elevation, y), tileMap[x][y], rotationOrientation);
 		}
 	}
 }
 
+TerrainGen::TileType TerrainGen::isCornerTile(int x, int y, vector<vector<TileType>> &tileMap) {
+	if (x < 1 || y < 1 || x >= tileMap.size() - 1 || y >= tileMap[0].size() - 1)
+		return GROUND; // Bounds check
+
+	TileType TL = tileMap[x - 1][y - 1];
+	TileType TR = tileMap[x + 1][y - 1];
+	TileType BL = tileMap[x - 1][y + 1];
+	TileType BR = tileMap[x + 1][y + 1];
+
+	// Check diagonal patterns for L-shapes
+	if ((TL == WATER && BR == WATER) || (TR == WATER && BL == WATER)) {
+		return WATER_CORNER; // Water Corner
+	}
+
+	if ((TL == CLIFF && BR == CLIFF) || (TR == CLIFF && BL == CLIFF)) {
+		return CLIFF_CORNER; // Cliff Corner
+	}
+
+	if ((TL == RAMP && BR == RAMP) || (TR == RAMP && BL == RAMP)) {
+		return RAMP_CORNER; // Ramp Corner
+	}
+
+	return GROUND;
+}
+
 void TerrainGen::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("generate", "GridMap", "height", "width", "depth", "seed", "noiseType", "waterRemoval", "noiseFreq"), &TerrainGen::generate);
 }

src/TerrainGen/Terrain_Gen.h

@@ -1,5 +1,5 @@
-#ifndef HELLOWORLD_H
-#define HELLOWORLD_H
+#ifndef TERRAIN_GEN_H
+#define TERRAIN_GEN_H
 
 #include <godot_cpp/classes/fast_noise_lite.hpp>
 #include <godot_cpp/classes/grid_map.hpp>
@@ -36,6 +36,9 @@ class TerrainGen : public Node {
 
 	static void _bind_methods();
 
+private:
+	TileType isCornerTile(int x, int y, vector<vector<TileType>> &tileMap);
+
 public:
 	TerrainGen();
 	~TerrainGen();