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>
82 lines
2.8 KiB
GDScript
82 lines
2.8 KiB
GDScript
class_name ExplosionVFXBase
|
|
extends Node2D
|
|
|
|
# Shared particle motion/fade/lifetime logic for all explosion VFX types.
|
|
# Subclasses fix their own visual style and color as facts about
|
|
# themselves (see LightBurstVFX/AsteroidExplosionVFX), not as parameters
|
|
# passed in by whatever destroyed the object - so "ships always explode
|
|
# blue" is guaranteed by the class hierarchy, not by remembering to pass
|
|
# the right Color() at each call site.
|
|
|
|
@export var particle_count: int = 12
|
|
@export var lifetime: float = 0.5
|
|
@export var min_speed: float = 60.0
|
|
@export var max_speed: float = 220.0
|
|
|
|
var age: float = 0.0
|
|
var particles: Array = []
|
|
|
|
|
|
func _ready() -> void:
|
|
randomize()
|
|
for i in range(particle_count):
|
|
var angle: float = randf() * TAU
|
|
var speed: float = randf_range(min_speed, max_speed)
|
|
var p: Dictionary = {
|
|
"pos": Vector2.ZERO,
|
|
"vel": Vector2(cos(angle), sin(angle)) * speed,
|
|
"rot": randf() * TAU,
|
|
"rot_speed": randf_range(-6.0, 6.0),
|
|
"size": _random_particle_size(),
|
|
}
|
|
# Each particle is its own child CanvasItem, drawn once at its own
|
|
# fixed local shape (subclass decides the shape via
|
|
# _configure_particle). From here on the "animation" is just this
|
|
# child's position/rotation, exactly like Ship.gd/Asteroid.gd - no
|
|
# redraw, no re-tessellating four polylines per particle per frame.
|
|
var visual: ExplosionParticle = ExplosionParticle.new()
|
|
_configure_particle(visual, p)
|
|
if _particle_spins():
|
|
visual.rotation = p["rot"]
|
|
add_child(visual)
|
|
p["visual"] = visual
|
|
particles.append(p)
|
|
|
|
|
|
func _process(delta: float) -> void:
|
|
age += delta
|
|
if age >= lifetime:
|
|
queue_free()
|
|
return
|
|
# CanvasItem modulate is inherited down the tree, so setting it once
|
|
# here fades every particle's already-drawn shape for free - no need
|
|
# to recompute or re-draw a single one of them.
|
|
modulate.a = clamp(1.0 - (age / lifetime), 0.0, 1.0)
|
|
for p in particles:
|
|
p["pos"] += p["vel"] * delta
|
|
p["vel"] *= 0.9
|
|
p["rot"] += p["rot_speed"] * delta
|
|
var visual: ExplosionParticle = p["visual"]
|
|
visual.position = p["pos"]
|
|
if _particle_spins():
|
|
visual.rotation = p["rot"]
|
|
|
|
|
|
func _random_particle_size() -> float:
|
|
return randf_range(10.0, 20.0)
|
|
|
|
|
|
# Called once per particle at spawn time. Subclasses set visual.draw_callable
|
|
# to a closure that draws their own fixed local shape (a streak, a rock
|
|
# chunk, ...) - it must not depend on `p` beyond values fixed at spawn (size,
|
|
# initial velocity direction), since it never runs again.
|
|
func _configure_particle(_visual: ExplosionParticle, _p: Dictionary) -> void:
|
|
pass
|
|
|
|
|
|
# True for particle styles whose shape itself spins independently of its
|
|
# direction of travel (tumbling debris). Energy streaks are drawn already
|
|
# aligned to their (fixed) velocity direction, so giving them this unrelated
|
|
# per-particle spin as well would visibly rotate them off their travel line.
|
|
func _particle_spins() -> bool:
|
|
return false
|