2239235993
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_019AJMdB7iuHuLFZM1aBu3GD
300 lines
13 KiB
GDScript
300 lines
13 KiB
GDScript
extends SceneTree
|
|
|
|
# Headless gameplay test: run with
|
|
# godot --headless -s res://tests/test_laser_vessel.gd
|
|
# Forgejo #58: a manually aimed instant beam, modelled closely on the gas
|
|
# bomber's press-drag-release skill shot (GasBombController/
|
|
# VesselGasBomberComponent) but firing the instant the touch releases -
|
|
# there is no projectile travel time to wait out.
|
|
#
|
|
# Covers:
|
|
# A. the control is absent with no laser ship in the fleet, and appears
|
|
# the moment one joins
|
|
# B. the beam damages every enemy along its line, within beam_half_width,
|
|
# and nothing off it or beyond its range
|
|
# C. cooldown is per SHIP, not per fleet: two laser ships fire two shots
|
|
# before the control disables (the exact bug fixed in eb79efd for
|
|
# bombers)
|
|
# D. the camera zooms out while aiming and restores afterward
|
|
|
|
var game_state: Node
|
|
var main: Node
|
|
var fleet: Node
|
|
var skill: Node
|
|
# Mirrors LaserController.BEAM_HALF_WIDTH's value rather than referencing
|
|
# the class constant directly - a bare ClassName.CONST reference elsewhere
|
|
# in a test script has been observed to corrupt method resolution for the
|
|
# WHOLE script. See tests/test_gas_bomber_cooldowns.gd's identical fix (#60).
|
|
const BEAM_HALF_WIDTH: float = 38.0
|
|
# Mirrored for the same reason, and it bites exactly as documented: a bare
|
|
# DRAG_RADIUS here made every method call in this script
|
|
# resolve against a plain Node2D.
|
|
const DRAG_RADIUS: float = 260.0
|
|
var on_line_enemies: Array = []
|
|
var off_line_enemy: Node
|
|
var beyond_range_enemy: Node
|
|
var first_shooter: Node2D
|
|
var second_shooter: Node2D
|
|
var stage: int = 0
|
|
var elapsed: float = 0.0
|
|
var original_zoom: float = 2.5
|
|
|
|
|
|
func _initialize() -> void:
|
|
game_state = root.get_node("GameState")
|
|
game_state.buildings.clear()
|
|
game_state.extractors.clear()
|
|
game_state.transporters.clear()
|
|
game_state.stored_vessels.clear()
|
|
game_state.reset_progression()
|
|
# Direct unlock, same shortcut unlock_vessel() itself uses internally -
|
|
# this ticket is about the laser's own behaviour, not re-proving the
|
|
# ship-lab research flow (already covered generically elsewhere).
|
|
game_state.vessel_levels["unlock_laser"] = 1
|
|
# #61: shots draw energy from the fleet hold now - stock enough for two
|
|
# fires. Set BEFORE the first spawn_ships() call (inside Main.tscn's own
|
|
# _ready(), triggered by instantiate() below): the fleet hold has no
|
|
# capacity cap yet at this point (#56's cap is only computed once a
|
|
# fleet composition exists), so this deposit can't be clamped by the
|
|
# soon-to-exist all-laser fleet having zero "cargo" capability.
|
|
game_state.deposit_fleet_resource(GameState.RESOURCE_ENERGY, 20)
|
|
main = load("res://world/Main.tscn").instantiate()
|
|
root.add_child(main)
|
|
fleet = main.get_node("Fleet")
|
|
skill = main.get_node("LaserController")
|
|
|
|
|
|
func _process(delta: float) -> bool:
|
|
elapsed += delta
|
|
match stage:
|
|
0:
|
|
if elapsed < 0.2:
|
|
return false
|
|
main.get_node("EnemySpawner").set_process(false)
|
|
main.get_node("AsteroidField").set_process(false)
|
|
# Asteroids are shootable now, and the laser and the bomb both
|
|
# sweep them alongside enemies - so whatever the field already
|
|
# spawned would be counted as a hit. Silencing the spawner is not
|
|
# enough; what it placed before that has to go too. Same
|
|
# clean-slate idiom as test_ship_lab.gd.
|
|
for hazard in get_nodes_in_group("asteroids"):
|
|
if is_instance_valid(hazard):
|
|
hazard.free()
|
|
|
|
# --- A. absent, then appears -------------------------------------
|
|
if main.get_node("UI/LaserButton").visible:
|
|
return _fail_now("laser control appeared without a laser ship")
|
|
|
|
fleet.spawn_ships(2, Vector2.ZERO, PackedStringArray([
|
|
GameState.VESSEL_LASER, GameState.VESSEL_LASER]))
|
|
main.get_node("Camera2D").zoom = Vector2(original_zoom, original_zoom)
|
|
skill._process(0.0)
|
|
if not main.get_node("UI/LaserButton").visible:
|
|
return _fail_now("a laser ship in the fleet did not reveal the laser control")
|
|
print("control hidden with no laser ship, visible once one joins")
|
|
|
|
# The beam fires FROM the specific ship LaserController picks, not
|
|
# the fleet centroid (same discrepancy GasBombController already
|
|
# has) - enemies are placed relative to that ship's own position,
|
|
# not the centroid, so a non-zero formation offset can't put them
|
|
# off the real beam line.
|
|
first_shooter = skill._next_ready_laser_ship()
|
|
if first_shooter == null:
|
|
return _fail_now("no laser ship is ready right after spawning")
|
|
if absf(first_shooter.get_component("laser").beam_range - 2900.0) > 0.1:
|
|
return _fail_now("laser ship beam range was not doubled to 2900")
|
|
# #201 tripled the beam's damage. Read off the COMPONENT rather
|
|
# than off the definition, so a stat that stops reaching the hull
|
|
# fails here instead of passing on the strength of its own file.
|
|
if first_shooter.get_component("laser").damage != 6:
|
|
return _fail_now("laser damage is %d, expected the tripled 6" \
|
|
% first_shooter.get_component("laser").damage)
|
|
|
|
var press := InputEventScreenTouch.new()
|
|
press.index = 7
|
|
var laser_button: Control = main.get_node("UI/LaserButton")
|
|
press.position = laser_button.global_position + laser_button.size * 0.5
|
|
press.pressed = true
|
|
main._handle_touch(press)
|
|
if not skill.aiming:
|
|
return _fail_now("laser control did not begin aiming")
|
|
|
|
# --- D. zoom-out while aiming --------------------------------
|
|
var drag := InputEventScreenDrag.new()
|
|
drag.index = 7
|
|
drag.position = press.position + Vector2(300.0, 0.0)
|
|
main._handle_drag(drag)
|
|
# The aim view eases to its framing rather than cutting to it, so
|
|
# the drag alone has not moved the camera yet.
|
|
if not is_equal_approx(main.get_node("Camera2D").zoom.x, original_zoom):
|
|
return _fail_now("the aim zoom jumped instead of easing")
|
|
for _step in range(40):
|
|
skill._process(0.05)
|
|
if main.get_node("Camera2D").zoom.x >= original_zoom:
|
|
return _fail_now("aiming did not zoom out")
|
|
print("aiming eased the camera out instead of cutting to it")
|
|
|
|
# #203: framed to twice the distance of the chosen target, so what
|
|
# stands behind it is on screen too. The drag above is horizontal,
|
|
# so the screen's narrow half is the binding one.
|
|
var half_screen: Vector2 = skill.get_viewport_rect().size * 0.5 \
|
|
- Vector2(54.0, 54.0)
|
|
var aimed_distance: float = skill._aim_origin().distance_to(skill.aim_target)
|
|
var framed: float = (aimed_distance * 2.0 + BEAM_HALF_WIDTH) \
|
|
* main.get_node("Camera2D").zoom.x
|
|
if framed > half_screen.x + 1.0:
|
|
return _fail_now("framed %.0fpx of aim on %.0fpx of screen" \
|
|
% [framed, half_screen.x])
|
|
print("aiming framed twice the distance to the target")
|
|
|
|
# --- B. targets: two on the line, one off it, one past range ---
|
|
for offset in [Vector2(200.0, 0.0), Vector2(500.0, 0.0)]:
|
|
var enemy: Node = load("res://enemies/Enemy.tscn").instantiate()
|
|
enemy.position = first_shooter.global_position + offset
|
|
main.add_child(enemy)
|
|
enemy.speed = 0.0
|
|
on_line_enemies.append(enemy)
|
|
|
|
off_line_enemy = load("res://enemies/Enemy.tscn").instantiate()
|
|
off_line_enemy.position = first_shooter.global_position \
|
|
+ Vector2(200.0, BEAM_HALF_WIDTH + 60.0)
|
|
main.add_child(off_line_enemy)
|
|
off_line_enemy.speed = 0.0
|
|
|
|
beyond_range_enemy = load("res://enemies/Enemy.tscn").instantiate()
|
|
beyond_range_enemy.position = first_shooter.global_position + Vector2(3400.0, 0.0)
|
|
main.add_child(beyond_range_enemy)
|
|
beyond_range_enemy.speed = 0.0
|
|
|
|
var release := InputEventScreenTouch.new()
|
|
release.index = 7
|
|
release.position = drag.position
|
|
release.pressed = false
|
|
main._handle_touch(release)
|
|
|
|
# Instant beam: the hit already landed by the time _handle_touch
|
|
# returns, no travel time to wait out like the bomb's projectile.
|
|
if skill.last_hit_count != 2:
|
|
return _fail_now("beam hit %d enemies, expected 2" % skill.last_hit_count)
|
|
for enemy in on_line_enemies:
|
|
if not is_instance_valid(enemy) or enemy.hp >= enemy.max_hp:
|
|
return _fail_now("an enemy on the beam line was not damaged")
|
|
if not is_instance_valid(off_line_enemy) or off_line_enemy.hp != off_line_enemy.max_hp:
|
|
return _fail_now("the beam damaged an enemy off its line")
|
|
if not is_instance_valid(beyond_range_enemy) or beyond_range_enemy.hp != beyond_range_enemy.max_hp:
|
|
return _fail_now("the beam damaged an enemy beyond its range")
|
|
print("beam damaged exactly the 2 enemies on its line within range")
|
|
|
|
# --- C. cooldown is per ship, not per fleet ---------------------
|
|
if not main.get_node("UI/LaserButton").enabled:
|
|
return _fail_now("firing one laser ship disabled the control with a second ship still ready")
|
|
print("one ship fired; control stays enabled with the second ready")
|
|
|
|
stage = 1
|
|
elapsed = 0.0
|
|
return false
|
|
1:
|
|
if elapsed < 0.3:
|
|
return false
|
|
second_shooter = skill._next_ready_laser_ship()
|
|
if second_shooter == null or second_shooter == first_shooter:
|
|
return _fail_now("the second shot was not offered to the other ship")
|
|
|
|
var press2 := InputEventScreenTouch.new()
|
|
press2.index = 8
|
|
var laser_button: Control = main.get_node("UI/LaserButton")
|
|
press2.position = laser_button.global_position + laser_button.size * 0.5
|
|
press2.pressed = true
|
|
main._handle_touch(press2)
|
|
if not skill.aiming:
|
|
return _fail_now("laser control did not re-open aiming for the second shot")
|
|
var drag2 := InputEventScreenDrag.new()
|
|
drag2.index = 8
|
|
drag2.position = press2.position + Vector2(0.0, 300.0)
|
|
main._handle_drag(drag2)
|
|
var release2 := InputEventScreenTouch.new()
|
|
release2.index = 8
|
|
release2.position = drag2.position
|
|
release2.pressed = false
|
|
main._handle_touch(release2)
|
|
|
|
if main.get_node("UI/LaserButton").enabled:
|
|
return _fail_now("both laser ships fired but the control is still enabled")
|
|
print("second shot fired from the other ship - two ships, two shots, now disabled")
|
|
|
|
stage = 2
|
|
elapsed = 0.0
|
|
return false
|
|
2:
|
|
# --- D continued: zoom restores after aiming ends ---------------
|
|
if elapsed < 1.0:
|
|
return false
|
|
if absf(main.get_node("Camera2D").zoom.x - original_zoom) > 0.03:
|
|
return _fail_now("camera did not restore its pre-aim zoom")
|
|
print("camera zoom restored")
|
|
|
|
# --- E. #201: the beam gets ordinary fire's aim helper ----------
|
|
# Checked on the resolution itself rather than by firing again:
|
|
# both hulls are still cooling down, and what the ticket asks for
|
|
# is exactly that a drag resolves onto a nearby enemy.
|
|
for spent in on_line_enemies + [off_line_enemy, beyond_range_enemy]:
|
|
if is_instance_valid(spent):
|
|
spent.free()
|
|
var origin: Vector2 = skill._aim_origin()
|
|
var in_cone: Node = load("res://enemies/Enemy.tscn").instantiate()
|
|
in_cone.position = origin + Vector2(800.0, 0.0).rotated(deg_to_rad(20.0))
|
|
main.add_child(in_cone)
|
|
in_cone.speed = 0.0
|
|
# Nearer than the one in the cone, and deliberately outside it:
|
|
# the assist must not treat "closest" as "aimed at".
|
|
var out_of_cone: Node = load("res://enemies/Enemy.tscn").instantiate()
|
|
out_of_cone.position = origin + Vector2(600.0, 0.0).rotated(deg_to_rad(60.0))
|
|
main.add_child(out_of_cone)
|
|
out_of_cone.speed = 0.0
|
|
|
|
var assisted: Vector2 = skill._calculate_aim_target(Vector2(300.0, 0.0), origin)
|
|
if assisted.distance_to(in_cone.global_position) > 1.0:
|
|
return _fail_now("a drag past an enemy inside the assist cone did not snap onto it")
|
|
print("aiming snapped onto the enemy inside the assist cone")
|
|
|
|
in_cone.free()
|
|
var unassisted: Vector2 = skill._calculate_aim_target(Vector2(300.0, 0.0), origin)
|
|
if unassisted.distance_to(origin + Vector2(2900.0, 0.0)) > 1.0:
|
|
return _fail_now("the aim bent toward an enemy outside the assist cone")
|
|
print("an enemy outside the cone left the aim where it was pointed")
|
|
|
|
# --- F. the drag names a DEPTH, so the aim can reach past a
|
|
# nearer target instead of always settling on the closest one.
|
|
var near_enemy: Node = load("res://enemies/Enemy.tscn").instantiate()
|
|
near_enemy.position = origin + Vector2(700.0, 0.0)
|
|
main.add_child(near_enemy)
|
|
near_enemy.speed = 0.0
|
|
# Further out and off to one side, but still inside the assist
|
|
# cone: without depth this one is unreachable, because the nearer
|
|
# enemy wins the cone every time.
|
|
var far_enemy: Node = load("res://enemies/Enemy.tscn").instantiate()
|
|
far_enemy.position = origin + Vector2(2000.0, 0.0).rotated(deg_to_rad(10.0))
|
|
main.add_child(far_enemy)
|
|
far_enemy.speed = 0.0
|
|
|
|
var near_drag := Vector2(700.0 / 2900.0 * DRAG_RADIUS, 0.0)
|
|
var near_pick: Vector2 = skill._calculate_aim_target(near_drag, origin)
|
|
if near_pick.distance_to(near_enemy.global_position) > 1.0:
|
|
return _fail_now("a short drag did not settle on the nearer enemy")
|
|
var far_drag := Vector2(2000.0 / 2900.0 * DRAG_RADIUS, 0.0) \
|
|
.rotated(deg_to_rad(10.0))
|
|
var far_pick: Vector2 = skill._calculate_aim_target(far_drag, origin)
|
|
if far_pick.distance_to(far_enemy.global_position) > 1.0:
|
|
return _fail_now("dragging further did not reach past the nearer enemy")
|
|
print("drag depth selects between a near and a far target in the same cone")
|
|
|
|
print("TEST_LASER_VESSEL: PASS")
|
|
quit(0)
|
|
return true
|
|
return false
|
|
|
|
|
|
func _fail_now(message: String) -> bool:
|
|
print("TEST_LASER_VESSEL: FAIL (%s)" % message)
|
|
quit(1)
|
|
return true
|