tonytins/citylimits-next
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

refactor worldgen to class, make worldgen functional

Browse source
This commit is contained in:
Antti Hakkarainen 2023-02-09 22:20:23 +02:00
parent 5cb839d8e2
commit 7651e574c1
5 changed files with 248 additions and 126 deletions
Download patch file Download diff file Expand all files Collapse all files

8
scenes/Main.tscn
View file

@ -462,7 +462,14 @@ texture = ExtResource("3_yddbk")
[sub_resource type="TileSetAtlasSource" id="TileSetAtlasSource_hwjm3"]
texture = ExtResource("5_bqev6")
0:0/next_alternative_id = 4
0:0/0 = 0
0:0/1 = 1
0:0/1/flip_h = true
0:0/2 = 2
0:0/2/flip_v = true
0:0/3 = 3
0:0/3/transpose = true
1:0/0 = 0
2:0/0 = 0
3:0/0 = 0
@ -1514,7 +1521,6 @@ offset_right = 936.0
offset_bottom = 256.0
horizontal_alignment = 2
[connection signal="set_camera_position" from="World" to="World/CameraZoom2D" method="_on_world_set_camera_position"]
[connection signal="button_pressed" from="UILayer/Control" to="World" method="_on_control_button_pressed"]
[connection signal="pressed" from="UILayer/Control/ConstructionPanel/button_residental" to="UILayer/Control" method="_on_button_residental_pressed"]
[connection signal="pressed" from="UILayer/Control/ConstructionPanel/button_commercial" to="UILayer/Control" method="_on_button_commercial_pressed"]

10
scripts/Globals.gd
View file

@ -3,6 +3,16 @@
extends Node
enum {TILE_WATER, TILE_TERRAIN, TILE_FOREST, TILE_BOG}
func are_coords_valid(value:int, bounds:Vector2i, errmsg:String) -> bool:
if bounds.x > value or value > bounds.y:
errmsg = errmsg % [value, bounds.x, bounds.y]
push_error(errmsg)
return false
return true
var world_map: TileMap
var map_image_size:Vector2i

13
scripts/Main.gd
View file

@ -6,25 +6,28 @@
# - Then click and drag to draw the lines of grey cubes.
# - etc.
class_name Main
extends Node
# The idea is for the user to be able to choose the map from GUI later
var map_file_name: String = "res://maps/tampere_200px_crop.png"
var map_filename: String = "res://maps/tampere_10x10km_1000px.png"
var _world := World.new()
var _world_generator := WorldGeneration.new()
func _init():
DisplayServer.window_set_size(
Vector2i(Globals.DEFAULT_X_RES, Globals.DEFAULT_Y_RES)
#Vector2i(Globals.DEFAULT_X_RES, Globals.DEFAULT_Y_RES)
Vector2i(2560,1440)
)
# Called when the node enters the scene tree for the first time.
func _ready():
Globals.world_map = get_node("World")
if !Globals.world_map:
if !_world:
push_error(Globals.ERROR_MAKING_WORLD_INSTANCE)
quit_game()
# generate terrain. quit game if generation fails.
if !Globals.world_map.generate_terrain(map_file_name):
if !_world_generator.generate_world(map_filename):
push_error(Globals.ERROR_WHILE_GENERATING_MAP)
quit_game()

128
scripts/World.gd
View file

@ -1,12 +1,13 @@
class_name World
extends TileMap
signal set_camera_position(pos:Vector2)
var has_placeable_building: bool = false
var building
var building_type: String
var scene
var image:Image = Image.new()
func _init():
Globals.world_map = self
# Called when the node enters the scene tree for the first time.
func _ready():
@ -57,7 +58,7 @@ func _on_control_button_pressed(type):
self.building_type = type
# create new building, in Building node it is attached to mouse cursor
var building_properties = get_building_properties()
#var building_properties = get_building_properties()
scene = load(Globals.SCENE_PATH + "Building.tscn")
building = scene.instantiate()
#building.set_cell(0, Vector2i(0,0), building_properties[0], building_properties[1], 0)
@ -75,29 +76,21 @@ func _input(event):
if event.is_action_pressed("cancel"):
if has_placeable_building:
pass
func calculate_grid_coordinates(map_position: Vector2) -> Vector2:
return (map_position).floor()
func are_coords_valid(value:int, bounds:Vector2i, errmsg:String) -> bool:
if bounds.x > value or value > bounds.y:
errmsg = errmsg % [value, bounds.x, bounds.y]
push_error(errmsg)
return false
return true
func place_building_to_map():
var building_properties = get_building_properties()
var tile_on_mouse = local_to_map(get_global_mouse_position())
if !are_coords_valid(
if !Globals.are_coords_valid(
tile_on_mouse.y,
Vector2i(0, Globals.map_image_size.y),
Globals.ERROR_TILE_Y_COORDS_OUT_OF_BOUNDS
):
return false
elif !are_coords_valid(
elif !Globals.are_coords_valid(
tile_on_mouse.x,
Vector2i(0, Globals.map_image_size.x),
Globals.ERROR_TILE_X_COORDS_OUT_OF_BOUNDS
@ -105,109 +98,4 @@ func place_building_to_map():
return false
set_cell(Globals.LAYER_BUILDINGS, tile_on_mouse, building_properties[0], building_properties[1], 0)
func generate_terrain(filename) -> bool:
# Try to load the image which we used to place water & ground to world map
image = load(filename)
if image == null:
var errmsg = Globals.ERROR_FAILED_TO_LOAD_FILE
push_error(errmsg % filename)
return false
# Check if image is too small or too large
Globals.map_image_size = image.get_size()
if !validate_mapgen_params():
return false
generate_water_and_land()
generate_shorelines()
# center camera to world map
emit_signal(
"set_camera_position",
Vector2(Globals.map_image_size.x / 2.0 * Globals.TILE_SIZE_X,
Globals.map_image_size.y / 2.0 * Globals.TILE_SIZE_Y)
)
return true
func validate_mapgen_params() -> bool:
if !are_coords_valid(
Globals.map_image_size.y,
Vector2i(Globals.MAP_MIN_HEIGHT, Globals.MAP_MAX_HEIGHT),
Globals.ERROR_IMAGE_HEIGHT_INCORRECT):
return false
elif !are_coords_valid(
Globals.map_image_size.x,
Vector2i(Globals.MAP_MIN_WIDTH, Globals.MAP_MAX_WIDTH),
Globals.ERROR_IMAGE_WIDTH_INCORRECT):
return false
# Try to load the world tilemap where we place the tiles
if (Globals.world_map == null):
var errmsg = Globals.ERROR_WORLD_TILEMAP_NODE_MISSING % Globals.WORLD_NODE
push_error(errmsg)
return false
return true
func generate_water_and_land() -> void:
for x in Globals.map_image_size.x:
for y in Globals.map_image_size.y:
# layer | position coords | tilemap id | coords of the tile at tilemap | alternative tile
if image.get_pixel(x, y) == Globals.WATER_TILE_COLOR_IN_MAP_FILE:
Globals.world_map.set_cell(Globals.LAYER_TERRAIN, Vector2i(x, y), 2, Vector2i(15,5), 0)
else:
Globals.world_map.set_cell(Globals.LAYER_TERRAIN, Vector2i(x, y), 2, Vector2i(0,0), 0)
func generate_shorelines() -> void:
# for testing avoid map borders to make it simpler to implement
var directions:Array = [
Vector2i(0,1), # south
Vector2i(1,0), # east
Vector2i(0,-1), # north
Vector2i(-1,0) # west
]
for x in range(1, Globals.map_image_size.x-1):
for y in range(1, Globals.map_image_size.y-1):
# skip tiles with water
if image.get_pixel(x, y) == Globals.WATER_TILE_COLOR_IN_MAP_FILE:
continue
# now we are supposed to be inspecting a tile with land
# 1 = water 0 = land
var surrounding_water_tiles:Array = []
# determine which directions have water around the tile
for dir in directions:
if image.get_pixel(x+dir.x, y+dir.y) == Globals.WATER_TILE_COLOR_IN_MAP_FILE:
surrounding_water_tiles.append(1)
continue
surrounding_water_tiles.append(0)
var selected_tile:Vector2i = Vector2i(0,0)
match surrounding_water_tiles:
[1,1,0,0]: # south & east
selected_tile = Vector2i(19,0) # or 20
[0,1,1,0]: # north & east
selected_tile = Vector2i(15,0) # or 60
[0,0,1,1]: # north & west
selected_tile = Vector2i(11,0) # or 12
[1,0,0,1]: # south & west
selected_tile = Vector2i(7,0) # or 8
[0,0,0,1]: # water in west only
selected_tile = Vector2i(9,0) # or 10
[0,0,1,0]: # water in north only
selected_tile = Vector2i(13,0) # or 14
[0,1,0,0]: # water in east only
selected_tile = Vector2i(17,0) # or 18
[1,0,0,0]: # water in south only
selected_tile = Vector2i(5,0) # or 6
_: # otherwise skip drawing
continue
# layer | position coords | tilemap id | coords of the tile at tilemap | alternative tile
Globals.world_map.set_cell(Globals.LAYER_TERRAIN, Vector2i(x, y), 2, selected_tile, 0)

215
scripts/WorldGeneration.gd Normal file
View file

@ -0,0 +1,215 @@
class_name WorldGeneration
extends RefCounted
signal set_camera_position(pos:Vector2)
var image:Image = Image.new()
var map_tile_data:Array[Array] = [[]] # store map tile info to a 2d array
var directions:Array = [
Vector2i(0,1), # south
Vector2i(1,0), # east
Vector2i(0,-1), # north
Vector2i(-1,0) # west
]
var count:int = 0
func choose_randomly(list_of_entries:Array[int]) -> int:
return list_of_entries[randi() % list_of_entries.size()]
#
# Generates biomes, like forest and bog
#
func generate_biomes() -> void:
pass
func generate_world(filename) -> bool:
# Try to load the image which we used to place water & ground to world map
image = load(filename)
if image == null:
var errmsg = Globals.ERROR_FAILED_TO_LOAD_FILE
push_error(errmsg % filename)
return false
# Check if image is too small or too large
Globals.map_image_size = image.get_size()
if !validate_mapgen_params():
return false
read_image_pixel_data()
smooth_land_features()
generate_biomes()
set_tilemap_tiles()
set_shorelines()
print(count)
# center camera to world map
emit_signal(
"set_camera_position",
Vector2(Globals.map_image_size.x / 2.0 * Globals.TILE_SIZE_X,
Globals.map_image_size.y / 2.0 * Globals.TILE_SIZE_Y)
)
return true
func match_tile(surrounding_tiles) -> Vector2i:
match surrounding_tiles:
# 3 land tiles around water
[1,1,1,0]:
return Vector2i(0,0) # land tile
[1,1,0,1]:
return Vector2i(0,0) # land tile
[1,0,1,1]:
return Vector2i(0,0) # land tile
[0,1,1,1]:
return Vector2i(0,0) # land tile
# 2 land tiles around water
[1,1,0,0]: # south & east
return Vector2i(choose_randomly([11,12]),0)
[0,1,1,0]: # north & east
return Vector2i(choose_randomly([7,8]),0)
[0,0,1,1]: # north & west
return Vector2i(choose_randomly([19,20]),0)
[1,0,0,1]: # south & west
return Vector2i(choose_randomly([15,16]),0)
# 1 land tile around water
[0,0,0,1]: # west only
return Vector2i(choose_randomly([17,18]),0)
[0,0,1,0]: # north only
return Vector2i(choose_randomly([5,6]),0)
[0,1,0,0]: # east only
return Vector2i(choose_randomly([9,10]),0)
[1,0,0,0]: # south only
return Vector2i(choose_randomly([13,14]),0)
_: # otherwise skip drawing
return Vector2i(-1,-1)
func read_image_pixel_data():
# initialize the array to have enough rows
map_tile_data.resize(Globals.map_image_size.y)
for y in Globals.map_image_size.y:
#initialize the row to have enough columns
map_tile_data[y].resize(Globals.map_image_size.y)
for x in Globals.map_image_size.x:
if image.get_pixel(x, y) == Globals.WATER_TILE_COLOR_IN_MAP_FILE:
map_tile_data[y][x] = Globals.TILE_WATER
else:
map_tile_data[y][x] = Globals.TILE_TERRAIN
func set_shorelines() -> void:
# for testing avoid map borders to make it simpler to implement
for y in range(1, Globals.map_image_size.y-1):
for x in range(1, Globals.map_image_size.x-1):
# skip tiles with land
if map_tile_data[y][x] != Globals.TILE_WATER:
continue
# now we are supposed to be inspecting a tile with land
# 1 = water 0 = land
var surrounding_tiles:Array = []
# determine which directions have land around the tile
for dir in directions:
if map_tile_data[y+dir.y][x+dir.x] == Globals.TILE_TERRAIN:
surrounding_tiles.append(Globals.TILE_TERRAIN)
continue
surrounding_tiles.append(Globals.TILE_WATER)
var selected_tile = match_tile(surrounding_tiles)
if selected_tile.x == -1 or selected_tile.y == -1:
continue
# layer | position coords | tilemap id | coords of the tile at tilemap | alternative tile
Globals.world_map.set_cell(Globals.LAYER_TERRAIN, Vector2i(x, y), 2, selected_tile, 0)
func set_tilemap_tiles() -> void:
for y in map_tile_data.size():
for x in map_tile_data[y].size():
# layer | position coords | tilemap id | coords of the tile at tilemap | alternative tile
# set water or ground
match map_tile_data[y][x]:
Globals.TILE_WATER:
Globals.world_map.set_cell(
Globals.LAYER_TERRAIN,
Vector2i(x, y),
2,
Vector2i(15,5),
0
)
Globals.TILE_TERRAIN:
Globals.world_map.set_cell(
Globals.LAYER_TERRAIN,
Vector2i(x, y),
2,
Vector2i(0,0),
choose_randomly([0,1,2,3])
)
_: #default
pass
# Fill water tiles, surrounded in 3-4 sides by land, with land.
# Do it recursively with limit of n recursions!
func smooth_land_features() -> void:
# for testing avoid map borders to make it simpler to implement
for y in range(1, Globals.map_image_size.y-1):
for x in range(1, Globals.map_image_size.x-1):
if map_tile_data[y][x] != Globals.TILE_WATER:
continue
smooth_recursively(Vector2i(x, y))
func smooth_recursively(pos:Vector2i) -> void:
# now we are supposed to be inspecting a tile with land
# 1 = water 0 = land
var surrounding_tiles:Array = []
count += 1
# determine which directions have land around the tile
for dir in directions:
if map_tile_data[pos.y+dir.y][pos.x+dir.x] == Globals.TILE_TERRAIN:
surrounding_tiles.append(Globals.TILE_TERRAIN)
elif map_tile_data[pos.y+dir.y][pos.x+dir.x] == Globals.TILE_WATER:
surrounding_tiles.append(Globals.TILE_WATER)
match surrounding_tiles:
[1,1,1,0]: #west
map_tile_data[pos.y][pos.x] = Globals.TILE_TERRAIN
pos.x -= 1
[1,1,0,1]: #north
map_tile_data[pos.y][pos.x] = Globals.TILE_TERRAIN
pos.y -= 1
[1,0,1,1]: #east
map_tile_data[pos.y][pos.x] = Globals.TILE_TERRAIN
pos.x += 1
[0,1,1,1]: #south
map_tile_data[pos.y][pos.x] = Globals.TILE_TERRAIN
pos.y += 1
_:
return
smooth_recursively(pos)
func validate_mapgen_params() -> bool:
if !Globals.are_coords_valid(
Globals.map_image_size.y,
Vector2i(Globals.MAP_MIN_HEIGHT, Globals.MAP_MAX_HEIGHT),
Globals.ERROR_IMAGE_HEIGHT_INCORRECT):
return false
elif !Globals.are_coords_valid(
Globals.map_image_size.x,
Vector2i(Globals.MAP_MIN_WIDTH, Globals.MAP_MAX_WIDTH),
Globals.ERROR_IMAGE_WIDTH_INCORRECT):
return false
# Try to load the world tilemap where we place the tiles
if (Globals.world_map == null):
var errmsg = Globals.ERROR_WORLD_TILEMAP_NODE_MISSING % Globals.WORLD_NODE
push_error(errmsg)
return false
return true