ac4b96ef49
The belt was laid out with its own arithmetic - a centre BELT_AHEAD in front of the fleet, rocks spread BELT_DEPTH either side of it - so its near edge reached back to within a screen of the convoy. At the aspect it was eyeballed on that was just outside the view; at a wider one, or any zoom out, rocks appeared in plain sight. #126 already answered this question for the rest of the game, so the answer is borrowed rather than restated: AsteroidField's keep-out rect and its push-out-through-the-nearest-edge placement are public now, and the belt runs through them. That also means the two cannot drift apart later. The distance moves as well, 2200 to 2900. The clamp alone would work, but it would work by pressing every stray rock onto the boundary line; with the belt properly out in front, the clamp has almost nothing left to do and the belt still looks laid out ahead rather than pinned to the edge of the screen. Measured: nearest rock 1551 units out, against a keep-out that reaches 1100.
148 lines
6.3 KiB
GDScript
148 lines
6.3 KiB
GDScript
extends Node2D
|
|
|
|
# Spawns slow-drifting asteroids inside ASTEROID_FIELD biome chunks near
|
|
# the fleet, and despawns them once the fleet has moved far enough away -
|
|
# keeps the scene from accumulating unbounded nodes over a long session
|
|
# while still populating newly-entered asteroid regions on the fly.
|
|
|
|
@export var check_interval: float = 1.0
|
|
@export var spawn_radius_chunks: int = 2
|
|
# #126: no asteroid may be created anywhere the player can SEE. It used to be
|
|
# a fixed bubble around the fleet, which was smaller than the screen - so a
|
|
# rock could and did materialise in plain view, several hundred pixels from
|
|
# the fleet but well inside the window. The real rule is the visible rect,
|
|
# and this radius is now only the floor under it: what to use when the
|
|
# viewport cannot be measured (no camera yet on the very first frame of a
|
|
# scene, or a headless run with no window at all).
|
|
@export var safe_spawn_radius: float = 420.0
|
|
# Pushed this far past the edge of the visible rect, so a rock placed just
|
|
# outside does not drift into view on the same frame it was created.
|
|
@export var offscreen_margin: float = 140.0
|
|
@export var despawn_radius_chunks: int = 4
|
|
@export var asteroids_per_chunk: int = 6
|
|
@export var min_speed: float = 12.0
|
|
@export var max_speed: float = 35.0
|
|
|
|
@onready var fleet: Node2D = get_node("../Fleet")
|
|
|
|
var asteroid_scene: PackedScene = preload("res://world/Asteroid.tscn")
|
|
var populated_chunks: Dictionary = {}
|
|
var timer: float = 0.0
|
|
|
|
|
|
func _ready() -> void:
|
|
randomize()
|
|
|
|
|
|
func _process(delta: float) -> void:
|
|
timer += delta
|
|
if timer < check_interval:
|
|
return
|
|
timer = 0.0
|
|
update_chunks()
|
|
|
|
|
|
func update_chunks() -> void:
|
|
# Public (not just called from _process's own timer): also invoked
|
|
# once synchronously right after the fleet is positioned on a fresh
|
|
# Main.tscn load, so nearby asteroids exist immediately instead of
|
|
# only appearing ~check_interval seconds later - most noticeable as a
|
|
# jarring pop-in right after returning from a planet's surface.
|
|
var center_chunk: Vector2i = WorldGen.chunk_coords(fleet.get_centroid())
|
|
|
|
for dx in range(-spawn_radius_chunks, spawn_radius_chunks + 1):
|
|
for dy in range(-spawn_radius_chunks, spawn_radius_chunks + 1):
|
|
var chunk: Vector2i = center_chunk + Vector2i(dx, dy)
|
|
if populated_chunks.has(chunk):
|
|
continue
|
|
if WorldGen.biome_at_chunk(chunk) != WorldGen.Biome.ASTEROID_FIELD:
|
|
continue
|
|
_spawn_chunk_asteroids(chunk)
|
|
|
|
var to_remove: Array = []
|
|
for chunk in populated_chunks.keys():
|
|
if _chebyshev_chunk_distance(chunk, center_chunk) > despawn_radius_chunks:
|
|
for asteroid in populated_chunks[chunk]:
|
|
if is_instance_valid(asteroid):
|
|
asteroid.queue_free()
|
|
to_remove.append(chunk)
|
|
for chunk in to_remove:
|
|
populated_chunks.erase(chunk)
|
|
|
|
|
|
func _chebyshev_chunk_distance(a: Vector2i, b: Vector2i) -> int:
|
|
return max(abs(a.x - b.x), abs(a.y - b.y))
|
|
|
|
|
|
# The area a new asteroid must stay out of: whatever is on screen, or the
|
|
# fallback bubble around the fleet when there is no screen to measure.
|
|
#
|
|
# Public since #139: the prologue lays its own debris belt (IntroDirector)
|
|
# with its own arithmetic and had the same bug this fixed - rocks appearing
|
|
# inside the view. One rule, in one place, borrowed rather than restated.
|
|
#
|
|
# Chunks are populated around wherever the fleet happens to be, including the
|
|
# chunk it is standing in, so without this a rock could appear directly on a
|
|
# ship - worst on the frame a scene loads, where arriving back from a planet
|
|
# could cost a vessel instantly. #126 widens that from "not on the fleet" to
|
|
# "not in view", which is the same rule the player actually notices.
|
|
func keep_out_rect(centre: Vector2) -> Rect2:
|
|
var fallback := Rect2(centre - Vector2(safe_spawn_radius, safe_spawn_radius),
|
|
Vector2(safe_spawn_radius, safe_spawn_radius) * 2.0)
|
|
if get_viewport() == null:
|
|
return fallback
|
|
var visible_rect: Rect2 = ViewUtils.get_visible_world_rect(self)
|
|
if visible_rect.size.x < 1.0 or visible_rect.size.y < 1.0:
|
|
return fallback
|
|
visible_rect = visible_rect.grow(offscreen_margin)
|
|
# Never smaller than the old bubble: on a heavily zoomed-in view the
|
|
# screen can be narrower than the distance a rock needs to be safe.
|
|
return visible_rect.merge(fallback)
|
|
|
|
|
|
func safe_position(candidate: Vector2, keep_out: Rect2) -> Vector2:
|
|
if not keep_out.has_point(candidate):
|
|
return candidate
|
|
# Pushed out through the nearest edge rather than dropped, so the field
|
|
# keeps its density around the fleet instead of thinning out where the
|
|
# player is looking.
|
|
var centre: Vector2 = keep_out.get_center()
|
|
var away: Vector2 = candidate - centre
|
|
if absf(away.x) < 0.001 and absf(away.y) < 0.001:
|
|
away = Vector2.RIGHT.rotated(randf() * TAU)
|
|
var half: Vector2 = keep_out.size * 0.5
|
|
# The smallest scaling that puts the point on the boundary along `away`:
|
|
# whichever axis it would leave through first decides.
|
|
var scale_x: float = half.x / absf(away.x) if absf(away.x) > 0.001 else INF
|
|
var scale_y: float = half.y / absf(away.y) if absf(away.y) > 0.001 else INF
|
|
var factor: float = minf(scale_x, scale_y)
|
|
if is_inf(factor):
|
|
return centre + Vector2(half.x + 1.0, 0.0)
|
|
return centre + away * factor * 1.02
|
|
|
|
|
|
func _spawn_chunk_asteroids(chunk: Vector2i) -> void:
|
|
var origin: Vector2 = WorldGen.chunk_origin(chunk)
|
|
var spawned: Array = []
|
|
# Measured once per chunk rather than per asteroid: it cannot change
|
|
# between two rocks placed in the same frame, and it is a viewport
|
|
# transform rather than a field read.
|
|
var keep_out: Rect2 = keep_out_rect(fleet.get_centroid())
|
|
|
|
for i in range(asteroids_per_chunk):
|
|
var local_pos: Vector2 = Vector2(randf() * WorldGen.CHUNK_SIZE, randf() * WorldGen.CHUNK_SIZE)
|
|
var asteroid: Node2D = asteroid_scene.instantiate()
|
|
asteroid.position = safe_position(origin + local_pos, keep_out)
|
|
var angle: float = randf() * TAU
|
|
var speed: float = randf_range(min_speed, max_speed)
|
|
asteroid.velocity = Vector2(cos(angle), sin(angle)) * speed
|
|
asteroid.rotation_speed = randf_range(-0.4, 0.4)
|
|
# Deferred: update_chunks() can run synchronously from inside a
|
|
# parent's own _ready() chain (forced once right after the fleet
|
|
# is positioned, to avoid a pop-in on scene load) - Godot refuses
|
|
# a direct add_child() while the tree is still "busy setting up
|
|
# children" in that situation, so this must be deferred either way.
|
|
get_parent().add_child.call_deferred(asteroid)
|
|
spawned.append(asteroid)
|
|
|
|
populated_chunks[chunk] = spawned
|