b641fa5891
Gameplay and UI - Research tree at the mothership gates which structures can be built and grants permanent fleet-capacity upgrades (GameState.SKILL_TREE, SkillTreeView). Node depth is derived from prerequisites, so the layout cannot drift out of step with the dependencies. - Building info popup before committing to a build, with per-building cost and description. - Ship crafter redrawn as a space factory with an assembly animation; mothership redrawn as a radial flagship; command centre as a plotting hub. - Keyboard and mouse support (WASD, Q/E pivot, wheel zoom) for the web build. - UI and font scaled up for phone use, via a custom Theme resource - gui/theme/default_font_size does not reach the default theme. - Asteroids no longer spawn on top of the fleet's start position. - Fleet formation origin derived from the layout's own offsets rather than the centroid, fixing the lurch when a lopsided formation started moving. - Fleet.stop() brakes from the ship's TRUE motion (velocity + fleet_velocity). Ship zeroes its velocity when seated in its slot even while the anchor drags that slot forward, so braking from velocity alone stopped the fleet dead instead of coasting - and whether it did depended on the frame rate. Animation architecture (issue #10) - Buildings, projectiles and explosion VFX no longer animate by redrawing. Static geometry is rasterised once in _draw(); moving parts are NeonPiece children animated through node properties, which reuse the cached geometry. Every NeonDraw call expands into four antialiased polylines, so redrawing to move something re-tessellated all of it. Test suite (issue #8): 1075s -> ~55s - Runs from a copy on Termux's own filesystem. The project lives on Android's FUSE bridge, read through proot, where load("res://Main.tscn") alone cost 8.5s per test against ~2s natively - and nearly every test loads it. - Runs 6 tests at a time, in a single proot-distro login, with output buffered per test and printed only on failure. - --fixed-fps 60 pins delta instead of measuring the wall clock, so a test's result no longer depends on how busy the machine is. Without it, parallelism made two tests fail on 2 of 3 runs. - A test passes only if it both exits 0 and prints ": PASS". - 38 tests, green on three consecutive runs. Bundles Carrois Gothic SC (Apache 2.0) with its licence text. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
107 lines
4.2 KiB
GDScript
107 lines
4.2 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
|
|
# No asteroid may be created within this distance of the fleet. At cruise
|
|
# speed this is well over a second of warning, so anything that reaches the
|
|
# fleet was visible on its way in.
|
|
@export var safe_spawn_radius: float = 420.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://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))
|
|
|
|
|
|
func _safe_position(candidate: Vector2, centre: Vector2) -> Vector2:
|
|
# Nothing may materialise on top of the fleet. Chunks are populated around
|
|
# wherever the fleet happens to be - including the chunk it is standing in
|
|
# - so without this an asteroid could appear directly on a ship and
|
|
# destroy it with no chance to react. That is worst on the frame a scene
|
|
# loads: arriving back from a planet could cost a ship instantly.
|
|
if candidate.distance_to(centre) >= safe_spawn_radius:
|
|
return candidate
|
|
# Push it out to the edge of the bubble rather than dropping it, so the
|
|
# field keeps its density near the fleet instead of thinning out.
|
|
var away: Vector2 = candidate - centre
|
|
if away.length() < 0.001:
|
|
away = Vector2.RIGHT.rotated(randf() * TAU)
|
|
return centre + away.normalized() * safe_spawn_radius
|
|
|
|
|
|
func _spawn_chunk_asteroids(chunk: Vector2i) -> void:
|
|
var origin: Vector2 = WorldGen.chunk_origin(chunk)
|
|
var spawned: Array = []
|
|
var fleet_centre: Vector2 = 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, fleet_centre)
|
|
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
|