Garrison laser vessels and gas bombers, on a shared ability seam

#105 shipped with interceptors as the only garrisonable vessel, and the
reason was a design fault rather than a decision: firing the laser and the
gas bomb lived in the player's fleet controllers, so a stationed laser would
have held its position and never shot.

The shot is now a thing in the world rather than something a controller
draws. LaserBeamEffect and GasBombEffect are self-contained, self-animating
and self-freeing, added to the tree root - the same shape EnemyBigLaserBeam
and ArtilleryShell already had on the enemy side - and they outlive the
vessel that fired them.

Above them sits one seam, on VesselCooldownFillComponent: ability_range(),
ability_ammo_resource(), ability_ammo_cost() and fire_ability(). A beam and a
bomb are now the same shape of thing to whoever pulls the trigger, so the
garrison AI never names an ability - the test asserts that literally, by
reading the AI's own source. A third armed vessel needs to implement the
seam and nothing else.

Ammunition is the CALLER's business, deliberately: the fleet spends from its
hold, a garrison from its outpost's store, and neither concern belongs in
the component. A garrison with an empty magazine holds fire rather than
falling back on the fleet's hold.

Outpost storage: 50 gas per stationed bomber and 50 energy per stationed
laser, off the VESSEL definitions, so an outpost never learns which vessel
needs what. It is a capacity, not a stock - hub transporters fill it exactly
as they fill a gas burner's buffer, because building_logistics_deficit now
takes the larger of the definition's static buffer and the garrison's
magazine. Every other resource is capped at zero: an outpost is not a depot,
and ore parked at one has nothing to do there and no transporter coming for
it.

Also restores two properties the Godot editor dropped from
GasBurnerBuildingDefinition.tres when it re-saved the file:
collected_outputs and capabilities. Without the first, nothing ever collects
the burner's energy - test_gas_burner caught it.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

vfx/GasBombEffect.gd

@@ -0,0 +1,107 @@
+class_name GasBombEffect
+extends Node2D
+
+# The gas bomb itself: the flight, the blast and the picture of both, with
+# nothing in it about who threw it.
+#
+# Lifted out of GasBombController for the same reason LaserBeamEffect was
+# lifted out of LaserController - the shot was something only the FLEET could
+# do, and a garrisoned bomber needs the same shot from a different trigger
+# and a different magazine. Added to the tree root, self-animating,
+# self-freeing, and it outlives the vessel that threw it.
+
+signal struck(hit_count: int)
+
+const BOMB_COLOR := Color(0.96, 0.22, 0.72)
+const AOE_RADIUS := 180.0
+const PROJECTILE_SPEED := 720.0
+const EXPLOSION_DURATION := 0.8
+
+var target: Vector2 = Vector2.ZERO
+var damage: int = 3
+var trail: PackedVector2Array = PackedVector2Array()
+var exploded: bool = false
+var explosion_time: float = 0.0
+var hit_count: int = 0
+
+
+static func launch(world: Node, origin: Vector2, at: Vector2,
+		blast_damage: int = 3) -> GasBombEffect:
+	var effect := GasBombEffect.new()
+	effect.position = origin
+	effect.target = at
+	effect.damage = blast_damage
+	effect.trail = PackedVector2Array([origin])
+	world.add_child(effect)
+	return effect
+
+
+func in_flight() -> bool:
+	return not exploded
+
+
+func _process(delta: float) -> void:
+	if not exploded:
+		_advance_flight(delta)
+		queue_redraw()
+		return
+	explosion_time = maxf(explosion_time - delta, 0.0)
+	queue_redraw()
+	if explosion_time <= 0.0:
+		queue_free()
+
+
+func _advance_flight(delta: float) -> void:
+	var distance: float = position.distance_to(target)
+	if distance <= PROJECTILE_SPEED * delta:
+		position = target
+		_explode()
+		return
+	position = position.move_toward(target, PROJECTILE_SPEED * delta)
+	trail.append(position)
+	while trail.size() > 12:
+		trail.remove_at(0)
+
+
+func _explode() -> void:
+	exploded = true
+	explosion_time = EXPLOSION_DURATION
+	hit_count = 0
+	# Asteroids too - a blast that clears everything around it but leaves the
+	# rocks untouched would need explaining, and they take damage the same way.
+	for enemy in get_tree().get_nodes_in_group("enemies") \
+			+ get_tree().get_nodes_in_group("asteroids"):
+		if is_instance_valid(enemy) and enemy is Node2D \
+				and enemy.global_position.distance_to(target) <= AOE_RADIUS:
+			enemy.take_damage(damage)
+			hit_count += 1
+	struck.emit(hit_count)
+
+
+func _draw() -> void:
+	# Drawn in this node's own space while it flies (it moves), and around the
+	# blast point once it lands (it does not).
+	if not exploded:
+		if trail.size() >= 2:
+			for i in range(1, trail.size()):
+				var alpha: float = float(i) / trail.size()
+				draw_line(trail[i - 1] - position, trail[i] - position,
+					Color(BOMB_COLOR, alpha * 0.65), 4.0 + alpha * 4.0, true)
+		draw_circle(Vector2.ZERO, 12.0, Color(BOMB_COLOR, 0.35))
+		NeonDraw.draw_glowing_circle(self, Vector2.ZERO, 7.0, BOMB_COLOR, 1.0)
+		return
+	var progress: float = 1.0 - explosion_time / EXPLOSION_DURATION
+	var radius: float = lerpf(24.0, AOE_RADIUS, minf(progress * 1.5, 1.0))
+	draw_circle(Vector2.ZERO, radius, Color(BOMB_COLOR, (1.0 - progress) * 0.16))
+	draw_ring(Vector2.ZERO, radius, BOMB_COLOR, 1.0 - progress)
+	for i in range(7):
+		var angle: float = TAU * float(i) / 7.0 + progress
+		var cloud_at: Vector2 = Vector2(cos(angle), sin(angle)) * radius * 0.55
+		draw_circle(cloud_at, 18.0 + 14.0 * progress,
+			Color(BOMB_COLOR, (1.0 - progress) * 0.22))
+
+
+func draw_ring(center: Vector2, radius: float, color: Color, alpha: float) -> void:
+	draw_arc(center, radius, 0.0, TAU, 64, Color(color, 0.16 * alpha), 16.0, true)
+	draw_arc(center, radius, 0.0, TAU, 64, Color(color, 0.5 * alpha), 6.0, true)
+	draw_arc(center, radius, 0.0, TAU, 64, Color(1.0, 0.86, 0.96, 0.9 * alpha), 2.0, true)

vfx/LaserBeamEffect.gd

@@ -0,0 +1,139 @@
+class_name LaserBeamEffect
+extends Node2D
+
+# The laser shot itself: the strike and the picture of it, with nothing in it
+# about who fired or why.
+#
+# This used to live inside LaserController, which meant the beam was a thing
+# only the FLEET could do - the player's laser button, the fleet's hold, the
+# fleet's aim. Garrisoned vessels (#103 follow-up) need the same shot with a
+# different trigger and a different magazine, so the effect moved out here.
+# Same shape as EnemyBigLaserBeam and ArtilleryShell on the enemy side: added
+# to the tree root, self-animating, self-freeing, and it outlives the vessel
+# that fired it.
+#
+# The damage below is dealt at the INSTANT of the shot, in full, along the
+# whole beam. The extension in _draw is the picture of that, not a travelling
+# projectile - a beam that had to arrive would be a change to how the weapon
+# plays.
+
+signal struck(hit_count: int)
+
+const BEAM_COLOR := Color(0.3, 0.9, 1.0)
+const BEAM_HALF_WIDTH := 38.0
+# The DRAWN beam is scaled from the hit width rather than tuned separately.
+# The two were independent numbers and had drifted apart: the beam struck
+# anything within 22 units of the line while its outer glow spanned about 11,
+# so it killed things it visibly missed. NeonDraw's widest layer is 18px at
+# scale 1, so this makes the glow span exactly what the beam hits.
+const BEAM_WIDTH_SCALE := BEAM_HALF_WIDTH * 2.0 / 18.0
+# #90: the beam was one flat line that blinked on at full length and faded.
+# It now IGNITES - it runs out of the ship over the first slice of its life,
+# holds white-hot, and falls away.
+const FLASH_DURATION := 0.34
+const IGNITE_FRACTION := 0.3
+# The white-hot rod down the middle of the coloured glow. Drawn INSIDE the
+# beam's own width, never wider: the drawn beam is deliberately the same span
+# as the hit test, and a halo painted past that would put the "it visibly
+# missed" complaint back the other way round.
+const CORE_SCALE := 0.42
+const CORE_COLOR := Color(0.85, 0.99, 1.0)
+const TIP_RADIUS := BEAM_HALF_WIDTH * 0.55
+const MUZZLE_RADIUS := BEAM_HALF_WIDTH * 0.8
+# By path, not by class name - see the note at the top of MuzzleSparkVFX.
+const MUZZLE_SPARK = preload("res://vfx/MuzzleSparkVFX.gd")
+
+var from: Vector2 = Vector2.ZERO
+var to: Vector2 = Vector2.ZERO
+var time: float = FLASH_DURATION
+# Per beam, so two lasers firing together do not flicker in lockstep.
+var phase: float = 0.0
+var hit_count: int = 0
+
+
+static func fire(world: Node, origin: Vector2, direction: Vector2,
+		beam_range: float, damage: int) -> LaserBeamEffect:
+	var effect := LaserBeamEffect.new()
+	var heading: Vector2 = direction.normalized() if direction.length() > 0.001 else Vector2.UP
+	effect.from = origin
+	effect.to = origin + heading * beam_range
+	effect.phase = randf() * TAU
+	world.add_child(effect)
+	effect._strike(heading, damage)
+	# #90: something happens at the hull, not just out in space. The ordinary
+	# gun already does this (#87); the laser fired in complete silence at its
+	# own end, which is most of why a shot read as a line appearing rather
+	# than as a vessel firing.
+	MUZZLE_SPARK.spawn(world, origin, heading, BEAM_COLOR)
+	return effect
+
+
+func _strike(direction: Vector2, damage: int) -> void:
+	hit_count = 0
+	var range_along: float = from.distance_to(to)
+	# Asteroids share the enemies' take_damage() contract, so the beam sweeps
+	# both groups in one pass. Shooting a path clear through a field is a
+	# perfectly good use of a laser, and the ore it leaves behind is the point.
+	for enemy in get_tree().get_nodes_in_group("enemies") \
+			+ get_tree().get_nodes_in_group("asteroids"):
+		if not is_instance_valid(enemy) or not (enemy is Node2D):
+			continue
+		var to_enemy: Vector2 = enemy.global_position - from
+		var along: float = to_enemy.dot(direction)
+		if along < 0.0 or along > range_along:
+			continue
+		var perpendicular: float = (to_enemy - direction * along).length()
+		if perpendicular <= BEAM_HALF_WIDTH:
+			enemy.take_damage(damage)
+			hit_count += 1
+	struck.emit(hit_count)
+	queue_redraw()
+
+
+func _process(delta: float) -> void:
+	time = maxf(time - delta, 0.0)
+	queue_redraw()
+	if time <= 0.0:
+		queue_free()
+
+
+# How far along its length the beam is currently drawn. Cubic ease-out, so it
+# leaves the ship fast and settles into full reach rather than crawling.
+# Public because it is the whole of #90's "it comes out of the ship".
+func extension() -> float:
+	var progress: float = 1.0 - time / FLASH_DURATION
+	var out: float = clampf(progress / IGNITE_FRACTION, 0.0, 1.0)
+	return 1.0 - pow(1.0 - out, 3.0)
+
+
+func tip() -> Vector2:
+	return from.lerp(to, extension())
+
+
+func _draw() -> void:
+	var progress: float = 1.0 - time / FLASH_DURATION
+	# Full brightness while it extends, then away. Squared so it holds its
+	# light and drops at the end, instead of dimming from the first frame the
+	# way a plain linear fade did.
+	var decay: float = clampf((progress - IGNITE_FRACTION) / (1.0 - IGNITE_FRACTION), 0.0, 1.0)
+	var alpha: float = 1.0 - decay * decay
+	# A live blade hums. Small enough to be texture rather than a blink.
+	var flicker: float = 1.0 + 0.09 * sin(time * 70.0 + phase)
+	var at: Vector2 = tip()
+
+	NeonDraw.draw_glowing_line(self, from, at, BEAM_COLOR, alpha,
+		BEAM_WIDTH_SCALE * flicker * (1.0 - decay * 0.45))
+	# The white-hot rod, over the same span at a fraction of the width. This
+	# is where the extra light comes from: brighter through the middle, not
+	# broader across.
+	NeonDraw.draw_glowing_line(self, from, at, CORE_COLOR, alpha,
+		BEAM_WIDTH_SCALE * CORE_SCALE * flicker)
+	# The leading cap, brightest while the blade is still running out.
+	var cap: float = TIP_RADIUS * (0.7 + 0.3 * (1.0 - decay)) * flicker
+	NeonDraw.draw_glowing_circle(self, at, cap, CORE_COLOR, alpha)
+	# And the flare left at the emitter, which fades faster than the beam so
+	# the hull does not keep glowing after the shot is over.
+	var muzzle: float = MUZZLE_RADIUS * (1.0 - progress)
+	if muzzle > 1.0:
+		NeonDraw.draw_glowing_circle(self, from, muzzle, CORE_COLOR,
+			alpha * (1.0 - progress))