Partial lake generation

7 files changed, 169 insertions, 15 deletions

diff --git a/scripts/cursor.gd b/scripts/cursor.gd
index 7d9b00f..d36d5eb 100644
--- a/scripts/cursor.gd
+++ b/scripts/cursor.gd
@@ -53,7 +53,7 @@ func handle_move(dir):
 	position.x = max(position.x, map_config.tile_size / 2)
 	position.y = max(position.y, map_config.tile_size / 2)
 	position.x = min(position.x, max_x - (map_config.tile_size / 2))
-	position.y = min(position.y, max_y - map_config.tile_size - (map_config.tile_size / 2))
+	position.y = min(position.y, max_y - (map_config.tile_size / 2))
 
 func is_valid_placement_tile():
 	var tile_coords = tilemap.get_cell_atlas_coords(tilemap.local_to_map(global_position))
diff --git a/scripts/lake_generator.gd b/scripts/lake_generator.gd
new file mode 100644
index 0000000..6c5050d
--- /dev/null
+++ b/scripts/lake_generator.gd
@@ -0,0 +1,141 @@
+extends Object
+
+class_name LakeGenerator
+
+var map_config : MapGeneratorResource = preload("res://resources/map_generator_resource.tres")
+var _tile_map : TileMapLayer
+var _lake : Array[Vector2i]
+var _lake_queue : Array[Vector2i]
+var _path : Array[Vector2i]
+
+enum TileTransform {
+	ROTATE_0 = 0,
+	ROTATE_90 = TileSetAtlasSource.TRANSFORM_TRANSPOSE | TileSetAtlasSource.TRANSFORM_FLIP_H,
+	ROTATE_180 = TileSetAtlasSource.TRANSFORM_FLIP_H | TileSetAtlasSource.TRANSFORM_FLIP_V,
+	ROTATE_270 = TileSetAtlasSource.TRANSFORM_TRANSPOSE | TileSetAtlasSource.TRANSFORM_FLIP_V,
+}
+
+func _init(tile_map_layer: TileMapLayer, path : Array[Vector2i]):
+	_tile_map = tile_map_layer
+	_path = path
+
+func generate_lake():
+	var tile : Vector2i
+
+	while 1:
+		tile.x = randi_range(0, map_config.grid_width - 1)
+		tile.y = randi_range(0, map_config.grid_height - 1)
+
+		if _is_expansion_valid(tile):
+			break
+
+	_visit_tile(tile)
+	print(map_config.max_lake_size)
+	while _lake.size() < map_config.max_lake_size:
+		tile = _pop_tile()
+		# no room to grow
+		if tile == Vector2i(-1, -1):
+			break
+
+		var adj_tiles : Array[Vector2i] = _get_adjacent_tiles(tile)
+		for i in adj_tiles:
+			_try_expand(i)
+
+	draw_lake()
+
+func draw_lake():
+	for i in _lake:
+		var score : int = _get_tile_score(i)
+
+		var atlas_coords : Vector2i = map_config.atlas_coords["WATER_MIDDLE"]
+		var rot : TileTransform = TileTransform.ROTATE_0
+
+		match score:
+			1, 3, 129, 131:
+				atlas_coords = map_config.atlas_coords["WATER_END"]
+				rot = TileTransform.ROTATE_180
+			4, 6, 12, 14:
+				atlas_coords = map_config.atlas_coords["WATER_END"]
+				rot = TileTransform.ROTATE_270
+			16, 24, 48, 56:
+				atlas_coords = map_config.atlas_coords["WATER_END"]
+			64, 96, 192, 224:
+				atlas_coords = map_config.atlas_coords["WATER_END"]
+				rot = TileTransform.ROTATE_90
+			7, 135, 15, 143:
+				atlas_coords = map_config.atlas_coords["WATER_BEND_OUTER"]
+				rot = TileTransform.ROTATE_270
+			28, 30, 60, 62:
+				atlas_coords = map_config.atlas_coords["WATER_BEND_OUTER"]
+			112, 120, 240, 248:
+				atlas_coords = map_config.atlas_coords["WATER_BEND_OUTER"]
+				rot = TileTransform.ROTATE_90
+			193, 195, 225, 227:
+				atlas_coords = map_config.atlas_coords["WATER_BEND_OUTER"]
+				rot = TileTransform.ROTATE_180
+			199, 207, 231, 239:
+				atlas_coords = map_config.atlas_coords["WATER_SHORE"]
+				rot = TileTransform.ROTATE_270
+			31, 63, 159, 191:
+				atlas_coords = map_config.atlas_coords["WATER_SHORE"]
+			124, 126, 252, 254:
+				atlas_coords = map_config.atlas_coords["WATER_SHORE"]
+				rot = TileTransform.ROTATE_90
+			241, 243, 249, 251:
+				atlas_coords = map_config.atlas_coords["WATER_SHORE"]
+				rot = TileTransform.ROTATE_180
+			68, 100, 196:
+				atlas_coords = map_config.atlas_coords["WATER_STRAIGHT"]
+				rot = TileTransform.ROTATE_90
+			17:
+				atlas_coords = map_config.atlas_coords["WATER_STRAIGHT"]
+
+		_display_tile(atlas_coords, rot, i)
+
+func _try_expand(tile : Vector2i):
+	if _is_expansion_valid(tile):
+		_visit_tile(tile)
+
+func _is_expansion_valid(tile : Vector2i) -> bool:
+	return !(_is_tile_oob(tile) || _lake.has(tile) || _path.has(tile))
+
+func _is_tile_oob(tile : Vector2i):
+	return tile.y < 0 || tile.y > map_config.grid_height - 1 || tile.x < 0 || tile.x > map_config.grid_width - 1
+
+func _visit_tile(tile: Vector2i):
+	_lake_queue.append(tile)
+	_lake.append(tile)
+
+func _pop_tile() -> Vector2i:
+	if _lake_queue.size() > 0:
+		return _lake_queue.pop_front()
+	return Vector2i(-1, -1)
+
+func _get_adjacent_tiles(tile: Vector2i) -> Array[Vector2i]:
+	var adj: Array[Vector2i] = []
+	var dirs: Array = [Vector2i(0, -1), Vector2i(0, 1), Vector2i(-1, 0), Vector2i(1, 0)]
+
+	for dir in dirs:
+		var n = tile + dir
+		adj.append(n)
+	
+	return adj
+
+func _display_tile(coords : Vector2i, rot : TileTransform, pos : Vector2i):
+	_tile_map.set_cell(pos, 0, coords, rot)
+
+func _get_tile_score(tile : Vector2i) -> int:
+	var score : int = 0
+	var x : int = tile.x
+	var y : int = tile.y
+	
+	score += 1 if _lake.has(Vector2i(x, y - 1)) else 0
+	score += 2 if _lake.has(Vector2i(x + 1, y - 1)) else 0
+	score += 4 if _lake.has(Vector2i(x + 1, y)) else 0
+	score += 8 if _lake.has(Vector2i(x + 1, y + 1)) else 0
+	score += 16 if _lake.has(Vector2i(x, y + 1)) else 0
+	score += 32 if _lake.has(Vector2i(x - 1, y + 1)) else 0
+	score += 64 if _lake.has(Vector2i(x - 1, y)) else 0
+	score += 128 if _lake.has(Vector2i(x - 1, y - 1)) else 0
+	
+	return score
diff --git a/scripts/lake_generator.gd.uid b/scripts/lake_generator.gd.uid
new file mode 100644
index 0000000..6772280
--- /dev/null
+++ b/scripts/lake_generator.gd.uid
@@ -0,0 +1 @@
+uid://b5enh0f2lhuh7
diff --git a/scripts/map_generator.gd b/scripts/map_generator.gd
index 35ade43..544b8ed 100644
--- a/scripts/map_generator.gd
+++ b/scripts/map_generator.gd
@@ -8,6 +8,7 @@ var _pg : PathGenerator
 func _ready() -> void:
 	_make_obstables()
 	_make_path()
+	_make_lake()
 	
 func _make_obstables():
 	var _og : ObstacleGenerator = ObstacleGenerator.new($TileMapLayer)
@@ -20,5 +21,9 @@ func _make_path():
 		_path = _pg.generate_path()
 	_pg.draw_path()
 
+func _make_lake():
+	var _lg : LakeGenerator = LakeGenerator.new($TileMapLayer, _path)
+	_lg.generate_lake()
+
 func get_enemy_path() -> Array[Vector2i]:
 	return _path
diff --git a/scripts/map_generator_resource.gd b/scripts/map_generator_resource.gd
index fee187a..7d58032 100644
--- a/scripts/map_generator_resource.gd
+++ b/scripts/map_generator_resource.gd
@@ -2,9 +2,10 @@ extends Resource
 class_name MapGeneratorResource
 
 @export var grid_width : int = 20
-@export var grid_height : int = 15
+@export var grid_height : int = 14
 @export var tile_size : int = 16
 @export var min_path_size : int = 45
+@export var max_lake_size : int = 35
 
 var atlas_coords : Dictionary = {
 	"PATH_EMPTY": Vector2i(0, 0),
@@ -15,9 +16,16 @@ var atlas_coords : Dictionary = {
 	"WATER_SHORE": Vector2i(9, 5),
 	"WATER_BEND_OUTER": Vector2i(10, 5),
 	"WATER_BEND_INNER": Vector2i(11, 5),
+	"WATER_STRAIGHT": Vector2i(8, 4),
+	"WATER_END": Vector2i(12, 4),
 
 	"DEAD_TREE": [Vector2i(18, 6), Vector2i(19, 6), Vector2i(20, 6)],
 	"TREE": [Vector2i(0, 1), Vector2i(1, 1), Vector2i(2, 1), Vector2i(3, 1), Vector2i(4, 1), Vector2i(3, 2)],
 	"GRASS": [Vector2i(0, 2), Vector2i(5, 2), Vector2i(6, 2)],
-	"CAMPSITE": [Vector2i(2, 20), Vector2i(29, 7), Vector2i(14, 10), Vector2i(27, 7)]
+	"CAMPSITE": [Vector2i(2, 20), Vector2i(29, 7), Vector2i(14, 10), Vector2i(27, 7)],
+
+	"FENCE": Vector2i(1, 3),
+	"GATE": Vector2i(2, 3),
+	"CASTLE_STRAIGHT": Vector2i(17, 13),
+	"CASTLE_CORNER": Vector2i(16, 13)
 }
diff --git a/scripts/obstacle_generator.gd b/scripts/obstacle_generator.gd
index 5b97820..d799b88 100644
--- a/scripts/obstacle_generator.gd
+++ b/scripts/obstacle_generator.gd
@@ -17,12 +17,11 @@ func generate_obstacles():
 	for i in range(map_config.grid_width):
 		for j in range(map_config.grid_height):
 			var noise = _noise.get_noise_2d(i, j)
-			print(noise)
-			if noise < 0.25:
+			if noise < 0.20:
 				pass
-			elif noise < 0.5:
+			elif noise < 0.55:
 				_draw_tile_from_pool(map_config.atlas_coords["TREE"], Vector2i(i, j))
-			elif noise < 0.65:
+			elif noise < 0.63:
 				_draw_tile_from_pool(map_config.atlas_coords["DEAD_TREE"], Vector2i(i, j))
 			elif noise < 0.74:
 				_draw_tile_from_pool(map_config.atlas_coords["GRASS"], Vector2i(i, j))
diff --git a/scripts/path_generator.gd b/scripts/path_generator.gd
index 2b8a3a8..75322cc 100644
--- a/scripts/path_generator.gd
+++ b/scripts/path_generator.gd
@@ -20,7 +20,7 @@ func generate_path() -> Array[Vector2i]:
 	_path.clear()
 
 	var x : int = 0
-	var y : int = randi_range(1, map_config.grid_height - 3)
+	var y : int = randi_range(1, map_config.grid_height - 2)
 
 	while x < map_config.grid_width:
 		if not _path.has(Vector2i(x,y)):
@@ -31,7 +31,7 @@ func generate_path() -> Array[Vector2i]:
 		# every even tile goes right to leave room for towers
 		if choice == 0 || x % 2 == 0 || x == map_config.grid_width - 1:
 			x += 1
-		elif choice == 1 && y < map_config.grid_height - 3 && !_path.has(Vector2i(x, y + 1)):
+		elif choice == 1 && y < map_config.grid_height - 2 && !_path.has(Vector2i(x, y + 1)):
 			y += 1
 		elif choice == 2 && y > 1 && !_path.has(Vector2i(x, y - 1)):
 			y -= 1
@@ -40,7 +40,7 @@ func generate_path() -> Array[Vector2i]:
 
 func draw_path():
 	for i in _path:
-		var score : int = _get_tile_score(_path, i)
+		var score : int = _get_tile_score(i)
 
 		var atlas_coords : Vector2i = map_config.atlas_coords["PATH_EMPTY"]
 		var rot : TileTransform = TileTransform.ROTATE_0
@@ -68,14 +68,14 @@ func draw_path():
 func _display_tile(coords : Vector2i, rot : TileTransform, pos : Vector2i):
 	_tile_map.set_cell(pos, 0, coords, rot)
 
-func _get_tile_score(path : Array[Vector2i], tile : Vector2i) -> int:
+func _get_tile_score(tile : Vector2i) -> int:
 	var score : int = 0
 	var x : int = tile.x
 	var y : int = tile.y
 	
-	score += 1 if path.has(Vector2i(x, y - 1)) else 0
-	score += 2 if path.has(Vector2i(x + 1, y)) else 0
-	score += 4 if path.has(Vector2i(x, y + 1)) else 0
-	score += 8 if path.has(Vector2i(x - 1, y)) else 0
+	score += 1 if _path.has(Vector2i(x, y - 1)) else 0
+	score += 2 if _path.has(Vector2i(x + 1, y)) else 0
+	score += 4 if _path.has(Vector2i(x, y + 1)) else 0
+	score += 8 if _path.has(Vector2i(x - 1, y)) else 0
 
 	return score