Add ability to add static monuments to the world

2 files changed, 85 insertions, 30 deletions

diff --git a/world/chunk/ChunkGen.gd b/world/chunk/ChunkGen.gd
index e71cc57..994d624 100644
--- a/world/chunk/ChunkGen.gd
+++ b/world/chunk/ChunkGen.gd
@@ -1,16 +1,11 @@
 extends Node
 
-var chunk_half_size setget _set_chunk_size
-var chunk_size
-
-func _set_chunk_size(val):
-    chunk_half_size = val
-    chunk_size = val * 2.0
-
 onready var noise = OpenSimplexNoise.new()
 onready var rng = RandomNumberGenerator.new()
 var _seed
 
+var monuments = []
+
 func _ready():
     #randomize()
     #self._seed = randi()
@@ -21,13 +16,36 @@ func _ready():
     self.noise.persistence = 0
     self.rng.seed = self._seed
 
+func setup_monuments():
+    monuments.push_back(DockMonument.new(Transform(Basis().rotated(Vector3.UP,0.0),Vector3(0.0,0.0,-600.0))))
+    monuments.push_back(DockMonument.new(Transform(Basis().rotated(Vector3.UP,PI),Vector3(0.0,0.0,600.0))))
+
 func rng_2dv(coords:Vector2):
     self.rng.seed = hash(coords)
 
-func gen_chunk(chunk):
-    gen_distance(chunk,chunk.get_node("gen_tree/lod_distance"))
-    gen_mid(chunk,chunk.get_node("gen_tree/lod_mid"))
-    gen_close(chunk,chunk.get_node("gen_tree/lod_close"))
+func gen_chunk(chunk,dummy=false):
+    if dummy:
+        return
+    var monument = get_monument_at_chunk(ChunkLoader.v2_coords(chunk.transform.origin))
+    if monument != null:
+        gen_monument(chunk, monument)
+    else:
+        gen_distance(chunk,chunk.get_node("gen_tree/lod_distance"))
+        gen_mid(chunk,chunk.get_node("gen_tree/lod_mid"))
+        gen_close(chunk,chunk.get_node("gen_tree/lod_close"))
+
+func get_monument_at_chunk(chunk_coords:Vector2):
+    for monument in monuments:
+        if monument.is_chunk_in_monument(chunk_coords):
+            return monument
+    return null
+
+func gen_monument(chunk, monument):
+    var offset_to_origin = monument.origin_chunk - ChunkLoader.v2_coords(chunk.transform.origin)
+    var inst = monument.scene.instance()
+    inst.transform.origin = ChunkLoader.v3_coords(offset_to_origin)
+    inst.transform.basis = monument.xform.basis
+    chunk.add_child(inst)
 
 func gen_distance(chunk,tree):
     gen_lowres_rocks(chunk,tree)
@@ -38,13 +56,8 @@ func gen_mid(chunk,tree):
 func gen_close(chunk,tree):
     gen_rock_hitboxes(chunk,tree)
 
-func v2_coords(coords:Vector3):
-    return Vector2(coords.x,coords.z)
-
-func v3_coords(coords:Vector2):
-    return Vector3(coords.x,0.0,coords.y)
-
 func iterate_chunk(chunk,tree,step:Vector2,cb:FuncRef,data):
+    var chunk_half_size = ChunkLoader.world.chunk_half_size
     var chunk_size_rounded = Vector2(chunk_half_size,chunk_half_size).snapped(step)
     for x in range(-chunk_size_rounded.x,chunk_size_rounded.x,step.x):
         for y in range(-chunk_size_rounded.y,chunk_size_rounded.y,step.y):
@@ -81,9 +94,9 @@ func gen_rock_hitboxes(chunk,tree):
     iterate_chunk(chunk, tree, Vector2(20.0,20.0), funcref(self,"rock_rng"), [0.4,0.6,1.0,4.0,1.0,funcref(self,"make_rock_hitbox")])
 
 func rock_rng(chunk,rocks,chunk_coords:Vector2,data):
-    var coords = v3_coords(chunk_coords)
+    var coords = ChunkLoader.v3_coords(chunk_coords)
     var basis = Basis()
-    var world_coords = chunk_coords + v2_coords(chunk.transform.origin)
+    var world_coords = chunk_coords + ChunkLoader.v2_coords(chunk.transform.origin)
     self.rng_2dv(world_coords)
     var rng_val = self.rng.randf_range(0.0,TAU)
     basis = Basis(Vector3.UP,rng_val) * basis
diff --git a/world/chunk/ChunkLoader.gd b/world/chunk/ChunkLoader.gd
index 42e40bb..0ea422a 100644
--- a/world/chunk/ChunkLoader.gd
+++ b/world/chunk/ChunkLoader.gd
@@ -4,12 +4,14 @@ var world = null
 
 var Chunk = preload("res://world/chunk/Chunk.tscn")
 var loaded_chunks = {}
+var freed_chunks = {}
 var chunk_thread = Thread.new()
 var mtx = Mutex.new()
 var sgnl = Semaphore.new()
 var exit = false
 var chunk_to_load = null
 var chunk_to_len
+var chunk_to_dummy
 
 func _ready():
     chunk_thread.start(self, "chunk_loader")
@@ -27,14 +29,29 @@ func v2_coords(coords:Vector3):
 func chunk_coords(coords:Vector2):
     return coords.snapped(Vector2(world.chunk_size,world.chunk_size))
 
+func v3_coords(coords:Vector2):
+    return Vector3(coords.x,0.0,coords.y)
+
 func free_chunk(coords:Vector2):
+    var monument = ChunkGen.get_monument_at_chunk(coords)
+    if monument != null && monument.loaded_chunk != null && monument.loaded_chunk == coords:
+        return
     if !loaded_chunks.has(coords):
         return
-    var c = loaded_chunks[coords].get_ref()
-    if c != null:
-        c.queue_free()
+    freed_chunks[coords] = loaded_chunks[coords]
     loaded_chunks.erase(coords)
 
+func clean_chunks():
+    var cleaned = {}
+    for chunk in freed_chunks.keys():
+        var c = freed_chunks[chunk].get_ref()
+        if c == null:
+            cleaned[chunk] = c
+            continue
+        c.queue_free()
+    for chunk in cleaned.keys():
+        freed_chunks.erase(chunk)
+
 func chunk_update():
     var chunks = {}
     var gen_center = -v2_coords(world.get_node("Chunks").transform.origin)
@@ -43,10 +60,11 @@ func chunk_update():
     for x in range(-gen_radius_rounded, gen_radius_rounded+world.chunk_size, world.chunk_size):
         for y in range(-gen_radius_rounded, gen_radius_rounded+world.chunk_size, world.chunk_size):
             var gen_coords = Vector2(x,y)
-            if gen_coords.length() > gen_radius:
+            var coords_len = gen_coords.length()
+            if coords_len > gen_radius:
                 continue
             var coords = chunk_coords(gen_coords + gen_center)
-            chunks[coords] = coords.length()
+            chunks[coords] = coords_len
     var closest_unloaded_chunk = null
     var closest_len = 0.0
     for chunk in chunks.keys():
@@ -56,15 +74,30 @@ func chunk_update():
                 closest_unloaded_chunk = chunk
                 closest_len = chunk_len
     if closest_unloaded_chunk != null:
+        var dummy = false
+        var monument = ChunkGen.get_monument_at_chunk(closest_unloaded_chunk)
+        if monument != null && monument.loaded_chunk != null:
+            dummy = true
         mtx.lock()
         if chunk_to_load == null:
             chunk_to_load = closest_unloaded_chunk
             chunk_to_len = closest_len
+            chunk_to_dummy = dummy
             sgnl.post()
         mtx.unlock()
+    for monument in ChunkGen.monuments:
+        if monument.loaded_chunk != null:
+            var loaded = false
+            for chunk in chunks.keys():
+                if monument.chunks.has(chunk):
+                    loaded = true
+                    break
+            if !loaded:
+                monument.loaded_chunk = null
     for chunk in loaded_chunks.keys():
         if !chunks.has(chunk):
             free_chunk(chunk)
+    clean_chunks()
 
 func chunk_loader():
     while true:
@@ -72,18 +105,27 @@ func chunk_loader():
         mtx.lock()
         var x = exit
         var coords = chunk_to_load
-        var owo = chunk_to_len
-        chunk_to_load = null
+        var lod = chunk_to_len
+        var dummy = chunk_to_dummy
         mtx.unlock()
         if x:
             break
         var chunk = Chunk.instance()
         chunk.transform.origin = Vector3(coords.x,0.0,coords.y)
-        owo -= world.chunk_size
-        chunk.lod = 2 if owo <= world.lod_close else 1 if owo <= world.lod_mid else 0
-        ChunkGen.gen_chunk(chunk)
+        lod -= world.chunk_size
+        var tmp = world.get_node("Chunk")
+        chunk.lod = tmp.LOD.CLOSE if lod <= world.lod_close else tmp.LOD.MID if lod <= world.lod_mid else tmp.LOD.DISTANCE
+        ChunkGen.gen_chunk(chunk,dummy)
         self.call_deferred("finish_chunk", chunk)
 
 func finish_chunk(chunk):
+    mtx.lock()
+    chunk_to_load = null
+    mtx.unlock()
     world.get_node("Chunks").add_child(chunk)
-    loaded_chunks[v2_coords(chunk.transform.origin)] = weakref(chunk)
+    var coords = v2_coords(chunk.transform.origin)
+    loaded_chunks[coords] = weakref(chunk)
+    var monument = ChunkGen.get_monument_at_chunk(coords)
+    if monument != null:
+        if monument.loaded_chunk == null:
+            monument.loaded_chunk = coords