Initial commit: SpaceshipTest, a top-down space RTS in Godot 4.7.1

A fleet of neon-outlined ships explores a procedurally generated, seeded
infinite world: tap/joystick steering, pinch zoom, formation pivoting,
planet landings, an ore economy with extractors and haulers, and player
built structures (mothership, ship crafter, command centre).

All art is hand-drawn with draw_* calls rather than textures, and the
backgrounds are camera-relative shaders so they stay precise at large
world coordinates.

Includes a 35-test headless suite (tests/run_tests.sh) plus screenshot
tooling that renders real frames through Xvfb and Mesa softpipe, since
--headless has no GPU.

Excluded from version control: .godot/ (import cache, and it holds
export credentials), builds/, android/build/ and packaged APKs - all
regenerable, and ~325 MB combined.

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

tests/test_camera_settles.gd

@@ -0,0 +1,98 @@
+extends SceneTree
+
+# Headless gameplay test: run with
+#   godot --headless -s res://tests/test_camera_settles.gd
+# Regression test for a permanently-drifting camera. GameController followed
+# the fleet with an exponential lerp and no snap threshold, so it approached
+# the fleet centroid asymptotically and NEVER arrived - the camera kept
+# moving by a fraction of a pixel every single frame, forever, even with the
+# fleet completely stationary. That kept the background shaders' camera_pos
+# uniform changing every frame, which made screen tearing permanently visible
+# as horizontal bands of the background sliding sideways against each other.
+#
+# Verifies the camera reaches an EXACTLY stable position (bit-identical
+# frame to frame) once the fleet has stopped, not merely a nearly-stable one.
+
+var main_scene: Node
+var fleet: Node
+var camera: Camera2D
+var elapsed: float = 0.0
+var stage: int = 0
+var last_pos: Vector2
+var identical_frames: int = 0
+
+
+func _initialize() -> void:
+	var packed: PackedScene = load("res://Main.tscn")
+	main_scene = packed.instantiate()
+	root.add_child(main_scene)
+	fleet = main_scene.get_node("Fleet")
+	camera = main_scene.get_node("Camera2D")
+
+
+func _process(delta: float) -> bool:
+	elapsed += delta
+	match stage:
+		0:
+			main_scene.get_node("AsteroidField").set_process(false)
+			main_scene.get_node("EnemySpawner").set_process(false)
+			# Send the fleet somewhere well away from the camera so the
+			# follow actually has distance to close.
+			fleet.move_to(Vector2(1500, 900))
+			elapsed = 0.0
+			stage = 1
+			return false
+		1:
+			# Wait for the fleet to genuinely arrive AND the camera to close
+			# the remaining distance - a fixed delay is unreliable here, since
+			# the trip length depends on the ships' braking curve.
+			if elapsed > 30.0:
+				print("TEST_CAMERA_SETTLES: FAIL (fleet/camera never arrived)")
+				quit(1)
+				return true
+			for ship in fleet.ships:
+				if ship.position.distance_to(ship.move_target) > ship.arrive_radius:
+					return false
+			# Wait for the snap itself to fire, not merely for the camera to
+			# get close: the final approach is still an active lerp, and
+			# sampling during it would just measure normal convergence rather
+			# than the perpetual drift this test is about.
+			if camera.global_position.distance_to(fleet.get_centroid()) > 0.0001:
+				return false
+			last_pos = camera.global_position
+			identical_frames = 0
+			elapsed = 0.0
+			stage = 2
+			return false
+		2:
+			# With the fleet settled, the camera must be BIT-IDENTICAL frame
+			# to frame. Any residual drift (however small) means the lerp is
+			# still creeping and the tearing-visibility bug is back.
+			if camera.global_position == last_pos:
+				identical_frames += 1
+			else:
+				print("camera still drifting: %s -> %s (delta=%.9f)" % [
+					last_pos, camera.global_position,
+					last_pos.distance_to(camera.global_position)
+				])
+				print("TEST_CAMERA_SETTLES: FAIL (camera never stops moving)")
+				quit(1)
+				return true
+
+			last_pos = camera.global_position
+			if identical_frames < 30:
+				return false
+
+			var centroid: Vector2 = fleet.get_centroid()
+			var on_target: bool = camera.global_position.distance_to(centroid) <= 1.0
+			print("camera stable for %d frames at %s (fleet centroid %s)" % [
+				identical_frames, camera.global_position, centroid
+			])
+			if on_target:
+				print("TEST_CAMERA_SETTLES: PASS")
+				quit(0)
+			else:
+				print("TEST_CAMERA_SETTLES: FAIL (settled, but not on the fleet)")
+				quit(1)
+			return true
+	return false