85814ce88c
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>
98 lines
3.4 KiB
GDScript
98 lines
3.4 KiB
GDScript
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
|