#118/#121: the speed fader and the formation editor under a mouse

Both read raw touches, and the project no longer turns clicks into them - the
same routing gap #93 fixed in the research tree. The boost was unreachable on
a desktop and the formation could not be rearranged at all.

Wrappers over the same press/drag logic in each case, never a second
implementation, so the touch and mouse paths cannot drift apart. The wheel
replaces the pinch in the formation editor: a mouse has no second finger, and
zoom is the other half of what that panel does.

The fader gets first refusal on a mouse press in GameController, so dragging
the boost does not also pan or zoom the world behind it.

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

ui/FormationEditor.gd

@@ -47,11 +47,78 @@ func _screen_to_formation(p: Vector2) -> Vector2:
 
 # Returns true when the event was consumed. Called from BuildController,
 # which forwards input while the editor is open.
+# #121: the formation could not be rearranged on a desktop at all. Like the
+# research tree (#93) and the speed fader (#118), this control reads raw
+# touches, and the project no longer turns clicks into them. Wrappers over
+# the same press/drag logic, never a second implementation.
+#
+# The wheel replaces the pinch: a mouse has no second finger, and zoom is
+# the other half of what the panel does.
+const MOUSE_TOUCH_INDEX: int = -2
+const WHEEL_ZOOM_STEP: float = 1.12
+
+
+func handle_mouse_button(event: InputEventMouseButton) -> bool:
+	if not visible:
+		return false
+	if event.button_index == MOUSE_BUTTON_WHEEL_UP and event.pressed:
+		return _zoom_by(WHEEL_ZOOM_STEP)
+	if event.button_index == MOUSE_BUTTON_WHEEL_DOWN and event.pressed:
+		return _zoom_by(1.0 / WHEEL_ZOOM_STEP)
+	if event.button_index != MOUSE_BUTTON_LEFT:
+		return false
+	if event.pressed:
+		return _grab(event.position, MOUSE_TOUCH_INDEX)
+	if drag_touch_index != MOUSE_TOUCH_INDEX:
+		return false
+	dragging_index = -1
+	drag_touch_index = -1
+	queue_redraw()
+	return true
+
+
+func handle_mouse_motion(event: InputEventMouseMotion) -> bool:
+	if drag_touch_index != MOUSE_TOUCH_INDEX or dragging_index == -1:
+		return false
+	_move_slot(event.position)
+	return true
+
+
+func _zoom_by(factor: float) -> bool:
+	scale_factor = clamp(scale_factor * factor, min_scale, max_scale)
+	queue_redraw()
+	return true
+
+
+func _grab(at: Vector2, index: int) -> bool:
+	if dragging_index != -1:
+		return false
+	var local: Vector2 = at - global_position
+	for i in range(GameState.max_fleet_size()):
+		if local.distance_to(_slot_screen_pos(i)) <= marker_radius * 1.4:
+			dragging_index = i
+			drag_touch_index = index
+			queue_redraw()
+			return true
+	return false
+
+
+func _move_slot(at: Vector2) -> void:
+	var local: Vector2 = at - global_position
+	# Clamped so a slot can't be dragged off the panel and become
+	# unreachable (and so the fleet can't be spread absurdly far apart).
+	var f: Vector2 = _screen_to_formation(local)
+	var limit: float = min(size.x, size.y) / (2.0 * scale_factor) - marker_radius / scale_factor
+	GameState.formation[dragging_index] = Vector2(
+		clamp(f.x, -limit, limit), clamp(f.y, -limit, limit)
+	)
+	queue_redraw()
+	formation_changed.emit()
+
+
 func handle_touch(event: InputEventScreenTouch) -> bool:
 	if not visible:
 		return false
-	var local: Vector2 = event.position - global_position
-
 	if event.pressed:
 		touches[event.index] = event.position
 		if touches.size() == 2:
@@ -65,15 +132,7 @@ func handle_touch(event: InputEventScreenTouch) -> bool:
 			pinch_active = true
 			queue_redraw()
 			return true
-		if dragging_index != -1:
-			return false
-		for i in range(GameState.max_fleet_size()):
-			if local.distance_to(_slot_screen_pos(i)) <= marker_radius * 1.4:
-				dragging_index = i
-				drag_touch_index = event.index
-				queue_redraw()
-				return true
-		return false
+		return _grab(event.position, event.index)
 
 	touches.erase(event.index)
 	if touches.size() < 2:
@@ -105,16 +164,7 @@ func handle_drag(event: InputEventScreenDrag) -> bool:
 
 	if event.index != drag_touch_index or dragging_index == -1:
 		return false
-	var local: Vector2 = event.position - global_position
-	# Clamped so a slot can't be dragged off the panel and become
-	# unreachable (and so the fleet can't be spread absurdly far apart).
-	var f: Vector2 = _screen_to_formation(local)
-	var limit: float = min(size.x, size.y) / (2.0 * scale_factor) - marker_radius / scale_factor
-	GameState.formation[dragging_index] = Vector2(
-		clamp(f.x, -limit, limit), clamp(f.y, -limit, limit)
-	)
-	queue_redraw()
-	formation_changed.emit()
+	_move_slot(event.position)
 	return true
 
 
@@ -126,13 +176,46 @@ func _draw() -> void:
 	NeonDraw.draw_glowing_line(self, centre + Vector2(-tick, 0), centre + Vector2(tick, 0), Color(0.4, 0.45, 0.5), 0.5, 0.3)
 	NeonDraw.draw_glowing_line(self, centre + Vector2(0, -tick), centre + Vector2(0, tick), Color(0.4, 0.45, 0.5), 0.5, 0.3)
 
+	# #119: each slot is drawn as the vessel actually standing in it, in its
+	# own colour and its own hull, rather than as an identical placeholder
+	# dart. Arranging a formation means deciding where the shield sits
+	# relative to the guns, and that is impossible to see when every marker
+	# is the same triangle.
+	var crewed: PackedStringArray = GameState.fleet_vessel_types
 	for i in range(GameState.max_fleet_size()):
 		var p: Vector2 = _slot_screen_pos(i)
 		var held: bool = i == dragging_index
-		# Ship glyph, so the layout reads the way it will look in flight.
-		var points: PackedVector2Array = PackedVector2Array([
-			p + Vector2(0, -marker_radius),
-			p + Vector2(-marker_radius * 0.66, marker_radius * 0.72),
-			p + Vector2(marker_radius * 0.66, marker_radius * 0.72),
-		])
-		NeonDraw.draw_glowing_polygon(self, points, glow_color, 1.0 if held else 0.7)
+		var vessel_type: String = String(crewed[i]) if i < crewed.size() else ""
+		var definition: Resource = GameState.vessel_definition(vessel_type) \
+			if vessel_type != "" else null
+		if definition == null:
+			# An empty slot: the outline of a berth, not a ship. A hollow
+			# marker is how the panel says "nothing is standing here yet".
+			_draw_empty_slot(p, held)
+			continue
+		_draw_vessel_slot(p, definition, held)
+
+
+# Scaled so the biggest hull in the catalog still fits the marker, and drawn
+# from the definition's own points so a vessel reshaped in its .tres is
+# reshaped here too.
+func _draw_vessel_slot(at: Vector2, definition: Resource, held: bool) -> void:
+	var points: PackedVector2Array = definition.hull_points
+	var extent: float = 1.0
+	for point in points:
+		extent = maxf(extent, point.length())
+	var factor: float = marker_radius / extent
+	var shaped: PackedVector2Array = PackedVector2Array()
+	for point in points:
+		shaped.append(at + point * factor)
+	NeonDraw.draw_glowing_polygon(self, shaped, definition.glow_color,
+		1.0 if held else 0.75)
+
+
+func _draw_empty_slot(at: Vector2, held: bool) -> void:
+	var ring: PackedVector2Array = PackedVector2Array()
+	for i in range(12):
+		var a: float = (float(i) / 12.0) * TAU
+		ring.append(at + Vector2(cos(a), sin(a)) * marker_radius * 0.78)
+	NeonDraw.draw_glowing_polygon(self, ring, Color(0.42, 0.47, 0.58),
+		0.8 if held else 0.4)