#116: the Spacial Workshop, and the drones that mend what waves break

Modelled on the transport hub, deliberately and closely: drones belong to a
workshop rather than to the player, are provisioned when it is built, are
never a production order, and are upgraded at a ship lab like any other
vessel. Anything that already knows how hub transporters behave knows how
these do, and Drone Bays raises the count at workshops already standing -
the same shape as Freight Yards and Garrison Bays.

What a repair COSTS is the one new idea. It is a share of the building's own
price, in proportion to how much of its health is gone: levelling a crafter
and rebuilding it costs its full price, and patching one up after a wave
costs a fraction, the fraction being the damage. The ore is spent when a
drone LEAVES, so two drones cannot be sent to the same wall and spend twice
for one load of repair, and a building demolished in transit sends its load
home rather than swallowing it.

"Required resources are sent to the spacial workshop": the workshop asks hub
logistics for the ore its outstanding repairs will need, exactly as a gas
burner asks for gas, because building_logistics_deficit now takes the larger
of the definition's static buffer and what the world actually demands. There
is a ceiling on that, so one badly-mauled base cannot pull the whole bank
into a single workshop and starve everything else.

Worst first: the structure closest to coming down is the one a repair is
worth most on.

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

logistics/RepairDrone.gd

@@ -0,0 +1,40 @@
+extends Node2D
+
+# #116: purely visual - a repair drone on its way out to a damaged structure
+# or back to its workshop. Carries no state of its own; GameState owns the
+# simulation and RepairDroneField creates, positions and frees this to match.
+
+const HULL_COLOR: Color = Color(0.5, 0.95, 0.8)
+
+var laden: bool = false
+
+
+func _ready() -> void:
+	add_to_group("repair_drones")
+	# #91: behind the fleet, like every other piece of ground furniture.
+	z_index = -1
+	queue_redraw()
+
+
+func set_laden(value: bool) -> void:
+	if laden == value:
+		return
+	laden = value
+	queue_redraw()
+
+
+func _draw() -> void:
+	# Small and blunt, with a tool arm out front, in the workshop's own
+	# green-teal: it should read as a tender belonging to a building rather
+	# than as a fleet vessel or a hub's magenta hauler.
+	var hull: PackedVector2Array = PackedVector2Array([
+		Vector2(0, -11), Vector2(8, -3), Vector2(6, 10), Vector2(-6, 10), Vector2(-8, -3),
+	])
+	NeonDraw.draw_glowing_polygon(self, hull, HULL_COLOR, 1.0)
+	NeonDraw.draw_glowing_line(self, Vector2(0, -11), Vector2(0, -18), HULL_COLOR, 0.9, 0.35)
+	NeonDraw.draw_glowing_line(self, Vector2(-5, -18), Vector2(5, -18), HULL_COLOR, 0.9, 0.35)
+	if laden:
+		# The load it is carrying out, in ore's own colour so it reads as
+		# material rather than as a light on the hull.
+		NeonDraw.draw_glowing_circle(self, Vector2(0, 3), 5.0,
+			GameState.resource_color(GameState.RESOURCE_ORE), 1.0)

logistics/RepairDrone.tscn

@@ -0,0 +1,6 @@
+[gd_scene load_steps=2 format=3]
+
+[ext_resource type="Script" path="res://logistics/RepairDrone.gd" id="1"]
+
+[node name="RepairDrone" type="Node2D"]
+script = ExtResource("1")

logistics/RepairDroneField.gd

@@ -0,0 +1,59 @@
+extends Node2D
+
+# #116: draws the repair drones GameState is simulating, and only while they
+# are somewhere the player could see them.
+#
+# Same arrangement as TransporterField, and for the same reason: the
+# simulation is authoritative and the visuals are optional, so a repair run
+# happening far away costs nothing but still puts the building back together.
+# Position comes from the very same `progress` that decides when the repair
+# actually lands.
+
+@export var visible_radius: float = 2600.0
+
+@onready var fleet: Node2D = get_node("../Fleet")
+
+var drone_scene: PackedScene = preload("res://logistics/RepairDrone.tscn")
+# index into GameState.repair_drones -> live node
+var active: Dictionary = {}
+
+
+func _process(_delta: float) -> void:
+	var centre: Vector2 = fleet.get_centroid()
+
+	for i in range(GameState.repair_drones.size()):
+		var drone: Dictionary = GameState.repair_drones[i]
+		# An idle drone is parked inside its workshop's own art; drawing it
+		# there adds a dot sitting on a building rather than a vessel doing
+		# something.
+		if String(drone.state) == GameState.DRONE_IDLE:
+			_despawn(i)
+			continue
+		var pos: Vector2 = GameState.repair_drone_position(drone)
+		if pos.distance_to(centre) > visible_radius:
+			_despawn(i)
+			continue
+
+		var node: Node2D = active.get(i)
+		if node == null or not is_instance_valid(node):
+			node = drone_scene.instantiate()
+			get_parent().add_child(node)
+			active[i] = node
+
+		var previous: Vector2 = node.position
+		node.position = pos
+		node.set_laden(int(drone.carrying) > 0)
+		var travel: Vector2 = pos - previous
+		if travel.length() > 0.5:
+			node.rotation = travel.angle() + PI / 2.0
+
+	for key in active.keys():
+		if key >= GameState.repair_drones.size():
+			_despawn(key)
+
+
+func _despawn(index: int) -> void:
+	var node: Node2D = active.get(index)
+	if node != null and is_instance_valid(node):
+		node.queue_free()
+	active.erase(index)