127 lines
3.8 KiB
GDScript
127 lines
3.8 KiB
GDScript
extends Node3D
|
|
|
|
@export var dimension: int = 5
|
|
@export var path_count: int = 5
|
|
|
|
@export var ped_spawn_rate: int = 20
|
|
|
|
var pedestrian_scn = preload("res://pedestrian.tscn")
|
|
var chunk_scn = preload("res://chunk.tscn")
|
|
var station_scn = preload("res://station.tscn")
|
|
var spawn_scn = preload("res://spawn.tscn")
|
|
|
|
func dir_to_vector(dir: int) -> Vector2i:
|
|
assert(dir >= 0 and dir <= 3)
|
|
var polarity = dir % 2 # 0: negative, 1: positive
|
|
var axis = floor(dir / 2) # 0: vertical, 1: horizontal
|
|
return Vector2i(
|
|
axis * (polarity * 2 - 1),
|
|
(1 - axis) * (polarity * 2 -1),
|
|
)
|
|
|
|
func vector_to_dir(vec: Vector2i) -> int:
|
|
assert(vec.length() == 1)
|
|
if vec == Vector2i(0, -1):
|
|
return 0
|
|
elif vec == Vector2i(0, 1):
|
|
return 1
|
|
elif vec == Vector2i(-1, 0):
|
|
return 2
|
|
elif vec == Vector2i(1, 0):
|
|
return 3
|
|
assert(false)
|
|
return -1
|
|
|
|
func _ready() -> void:
|
|
# ---- Decide position of Spawn & Station ----
|
|
var station = Vector2i(randi() % dimension, 0)
|
|
var spawn = Vector2i(dimension - station.x - 1, dimension - 1)
|
|
|
|
$Player.position.x = spawn.x * Global.chunk_size
|
|
$Player.position.z = spawn.y * Global.chunk_size
|
|
|
|
# ---- Generate the paths ----
|
|
var paths: Array = []
|
|
for path_idx in range(path_count):
|
|
# Station's and the chunk below are always the same.
|
|
var path: Array[Vector2i] = [
|
|
station,
|
|
Vector2i(station.x, station.y + 1),
|
|
]
|
|
|
|
while true: # Decide each of the steps
|
|
var last_pos = path.slice(-1)[0]
|
|
var next_dir = dir_to_vector(randi() % 3 + 1) # cannot go up
|
|
var next_pos = (last_pos + next_dir).clampi(0,dimension-1)
|
|
|
|
if next_pos in path: # Invalid path, try again
|
|
continue
|
|
|
|
path.append(next_pos)
|
|
|
|
if next_pos == spawn or next_pos.y == dimension-1: # End of path
|
|
break
|
|
|
|
paths.append(path)
|
|
|
|
# ---- Instantiate chunks, station & spawn ----
|
|
var chunks: Array # Array[int(x)][int(y)][station_scn|chunk_scn|spawn_scn]
|
|
for x in range(dimension):
|
|
var row: Array
|
|
for y in range(dimension):
|
|
var new_chunk = null
|
|
if Vector2i(x,y) == station:
|
|
new_chunk = station_scn.instantiate()
|
|
elif Vector2i(x,y) == spawn:
|
|
new_chunk = spawn_scn.instantiate()
|
|
else:
|
|
new_chunk = chunk_scn.instantiate()
|
|
new_chunk.position = Vector3(x * Global.chunk_size+1, 0, y * Global.chunk_size+1)
|
|
row.append(new_chunk)
|
|
add_child(new_chunk)
|
|
chunks.append(row)
|
|
|
|
# ---- Set exits based on paths ----
|
|
for path in paths:
|
|
for i in range(path.size()):
|
|
var curr = path[i]
|
|
var next = path[i+1] if i+1 < path.size() else null
|
|
var curr_chunk = chunks[curr.x][curr.y]
|
|
var next_chunk = chunks[next.x][next.y] if next else null
|
|
|
|
if not next_chunk or next_chunk.scene_file_path != "res://chunk.tscn":
|
|
continue
|
|
|
|
var revdir = vector_to_dir(curr - next)
|
|
next_chunk.exits[revdir] = true
|
|
next_chunk.update()
|
|
|
|
if curr_chunk.scene_file_path == "res://chunk.tscn":
|
|
var dir = vector_to_dir(next - curr)
|
|
curr_chunk.exits[dir] = true
|
|
curr_chunk.update()
|
|
|
|
# ---- Open all bottom exits ----
|
|
for x in range(dimension):
|
|
var chunk = chunks[x][dimension-1]
|
|
if chunk.scene_file_path != "res://chunk.tscn":
|
|
continue
|
|
|
|
if x > 0:
|
|
chunk.exits[2] = true
|
|
if x < dimension-1:
|
|
chunk.exits[3] = true
|
|
|
|
chunk.update()
|
|
|
|
# Called every frame. 'delta' is the elapsed time since the previous frame.
|
|
func _process(delta: float) -> void:
|
|
var spawn_radius = $Player/SpawnArea/Collision.shape.radius + randf_range(-5, 5)
|
|
var rand_unit_vec = Vector3.RIGHT.rotated(Vector3.UP, randf() * TAU)
|
|
var ped_pos = $Player.position + rand_unit_vec * spawn_radius
|
|
if (randi() % ped_spawn_rate == 0):
|
|
print("Pedestrian at ", ped_pos)
|
|
var new_ped = pedestrian_scn.instantiate()
|
|
add_child(new_ped)
|
|
new_ped.position = ped_pos
|