3f5e7ac80b
#85 - on a computer the sticks and the pivot pair are dead weight: WASD steers, the mouse aims, Q/E pivot. All four go together the first time a keyboard or a mouse is used, and only where there is no touchscreen. A touch device with a keyboard attached keeps everything, because a finger is still a way to play it. #86 - the default gun shoots faster (500 -> 850) and further (320 -> 620). The interesting half is that a bolt now STOPS where the gun's range ends. Projectile lifetime is derived from fire_range at launch rather than set independently, so the distance a shot covers and the distance the aim guide draws are one number. They were two, and they disagreed: the guide promised 320 while a bolt actually flew speed * lifetime = 750, so shots landed on things well past the line saying where they would stop. #87 - the ship that fires throws sparks, so a shot is visibly attached to the vessel it came from; with a whole fleet shooting there was nothing tying the two together, which started mattering once the player had to aim. Enemy deaths gained a shockwave ring and roughly double the debris - a kill used to read as a small red puff that was easy to miss in a fight. #88 - everything moves 1.5x faster: fleet cruise, every vessel's max_speed and acceleration, and every enemy's. Scaling the enemies too keeps it a change of TEMPO rather than a difficulty cut, and scaling acceleration alongside speed keeps the handling from #77's tuning intact. Three tests carried assertions that were really about one balance pass: test_enemy_mothership pinned a literal 35.0 and now compares against the chaser, which is what "never reaches ramming speed" actually means; test_planet_atmosphere_transition flew far enough at the new speed to reach the landed garrison, and now clears it, since that test is about the handoff and not about a fight it never meant to pick. Also repaired real data loss, caught only because test_gas_burner failed: Godot had silently re-serialised GasBurnerBuildingDefinition.tres and dropped collected_outputs, capabilities, map_radius and map_phase, and had recreated a stale copy of it at the pre-#84 root path. Without collected_outputs no transporter ever collects a burner's energy. Both files restored from git. It had also resurrected pre-#84 SNAPSHOTS of Main.tscn, Planet.tscn and lunar_surface.gdshader at their old root paths - the root Main.tscn still carried 27 references to the flat layout. They are dead weight the engine never loads, since project.godot and every preload point into the folders, but they are exactly the kind of thing that wastes an hour later when someone edits the wrong copy. Deleted, and the root is now down to ui_theme.tres, icon.svg, web_shell.html and the two config files. Suite 119/119. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
331 lines
12 KiB
GDScript
331 lines
12 KiB
GDScript
extends Node2D
|
|
|
|
# Formation slots come from GameState.formation (editable at a command
|
|
# centre) rather than being fixed here, so a layout the player arranged
|
|
# survives scene swaps and fleet rebuilds. Ships are always
|
|
# spawned programmatically (spawn_ships), using however many of these
|
|
# offsets are needed. The optional vessel-type list preserves the exact
|
|
# mixed fleet through scene swaps; a fresh start still defaults each slot
|
|
# to an interceptor.
|
|
# The fleet's cruise speed. This is the speed of the FLEET as a whole: the
|
|
# anchor below advances at exactly this rate, and individual ships are
|
|
# allowed to fly faster than it (Ship.max_speed) so they can close on their
|
|
# formation slot - which is what makes a pivot while under way look sharp
|
|
# instead of sluggish.
|
|
# #88: the whole game moves 1.5x faster. This is the figure the pace is
|
|
# actually set by - vessel max_speed and acceleration were scaled with it,
|
|
# and so were the enemies, so it is a change of TEMPO rather than a
|
|
# difficulty cut.
|
|
@export var cruise_speed: float = 390.0
|
|
|
|
# Per-scene neon palette for the fleet. PlanetSurface.tscn overrides these
|
|
# with darker values, since the lunar surface is bright grey and the default
|
|
# near-white core would wash out against it. See NeonDraw.
|
|
@export var ship_glow_color: Color = Color(0.25, 0.85, 1.0)
|
|
@export var ship_core_color: Color = Color(1.0, 1.0, 1.0)
|
|
|
|
var ship_scene: PackedScene = preload("res://vessels/Ship.tscn")
|
|
|
|
var ships: Array = []
|
|
var formation_offsets: Array = []
|
|
var fleet_target: Vector2 = Vector2.ZERO
|
|
# Formation centre while under joystick steering, and the heading it is
|
|
# travelling along. Zero heading means the fleet is not being steered.
|
|
var anchor: Vector2 = Vector2.ZERO
|
|
var steer_direction: Vector2 = Vector2.ZERO
|
|
|
|
|
|
func _ready() -> void:
|
|
# Lets anything resolve "the fleet" without a hardcoded ../Fleet sibling
|
|
# path - enemies parented under different hosts (e.g. a planet surface's
|
|
# SurfaceFeatures) need this to find their target.
|
|
add_to_group("player_fleet")
|
|
# Researching a vessel upgrade improves the ships already flying, not
|
|
# just the next one built (#5).
|
|
GameState.vessel_upgraded.connect(_on_vessel_upgraded)
|
|
|
|
|
|
func _on_vessel_upgraded(_id: String) -> void:
|
|
for ship in ships:
|
|
if is_instance_valid(ship):
|
|
ship.apply_vessel_stats()
|
|
|
|
|
|
func spawn_ships(count: int, center: Vector2 = Vector2.ZERO,
|
|
vessel_types: PackedStringArray = PackedStringArray()) -> void:
|
|
for ship in ships:
|
|
if is_instance_valid(ship):
|
|
ship.queue_free()
|
|
ships.clear()
|
|
formation_offsets.clear()
|
|
|
|
var spawn_types: PackedStringArray = PackedStringArray()
|
|
if vessel_types.is_empty():
|
|
for i in range(count):
|
|
spawn_types.append(GameState.VESSEL_INTERCEPTOR)
|
|
else:
|
|
for vessel_type in vessel_types:
|
|
if GameState.vessel_is_fleet_eligible(vessel_type):
|
|
spawn_types.append(vessel_type)
|
|
if spawn_types.is_empty():
|
|
spawn_types.append(GameState.VESSEL_INTERCEPTOR)
|
|
var n: int = clamp(spawn_types.size(), 1, GameState.max_fleet_size())
|
|
for i in range(n):
|
|
var offset: Vector2 = GameState.formation[i]
|
|
var ship: Area2D = ship_scene.instantiate()
|
|
ship.vessel_type = spawn_types[i]
|
|
ship.position = center + offset
|
|
ship.glow_color = ship_glow_color
|
|
ship.core_color = ship_core_color
|
|
add_child(ship)
|
|
ships.append(ship)
|
|
formation_offsets.append(offset)
|
|
if ship.has_signal("destroyed"):
|
|
ship.destroyed.connect(_on_ship_destroyed.bind(ship))
|
|
|
|
fleet_target = center
|
|
_sync_composition_state()
|
|
|
|
|
|
func vessel_types() -> PackedStringArray:
|
|
var result: PackedStringArray = PackedStringArray()
|
|
for ship in ships:
|
|
if is_instance_valid(ship):
|
|
result.append(String(ship.vessel_type))
|
|
return result
|
|
|
|
|
|
func _sync_composition_state() -> void:
|
|
GameState.sync_fleet_cargo_capacity(vessel_types())
|
|
# Composition changes are authoritative; scene teardown is not. Keeping
|
|
# this out of SpeedFader prevents an outgoing scene's empty fleet from
|
|
# resetting a boost while the same vessels are being restored on a surface.
|
|
# Each distorder vessel past the first widens the speed ceiling, so the
|
|
# COUNT matters, not merely whether one is present.
|
|
GameState.set_distorder_vessel_count(count_ships_with_capability("distorder"))
|
|
if not has_capability("distorder"):
|
|
GameState.set_fleet_speed_multiplier(1.0)
|
|
|
|
|
|
func has_vessel_type(vessel_type: String) -> bool:
|
|
for ship in ships:
|
|
if is_instance_valid(ship) and String(ship.vessel_type) == vessel_type:
|
|
return true
|
|
return false
|
|
|
|
|
|
func first_vessel_of_type(vessel_type: String) -> Node2D:
|
|
for ship in ships:
|
|
if is_instance_valid(ship) and String(ship.vessel_type) == vessel_type:
|
|
return ship
|
|
return null
|
|
|
|
|
|
func has_capability(capability: String) -> bool:
|
|
return first_ship_with_capability(capability) != null
|
|
|
|
|
|
func count_ships_with_capability(capability: String) -> int:
|
|
var total: int = 0
|
|
for ship in ships:
|
|
if is_instance_valid(ship) and ship.has_capability(capability):
|
|
total += 1
|
|
return total
|
|
|
|
|
|
func first_ship_with_capability(capability: String) -> Node2D:
|
|
for ship in ships:
|
|
if is_instance_valid(ship) and ship.has_capability(capability):
|
|
return ship
|
|
return null
|
|
|
|
|
|
func add_ship(vessel_type: String = GameState.VESSEL_INTERCEPTOR) -> bool:
|
|
# Adds one vessel in the next free formation slot (bought from a ship
|
|
# crafter). Returns false when the wedge is already full.
|
|
if not GameState.vessel_is_fleet_eligible(vessel_type) \
|
|
or ships.size() >= GameState.max_fleet_size():
|
|
return false
|
|
var offset: Vector2 = GameState.formation[ships.size()]
|
|
var ship: Area2D = ship_scene.instantiate()
|
|
# Before add_child, so Ship._ready() builds the right vessel - the shield
|
|
# ring is created there and only for a shield vessel.
|
|
ship.vessel_type = vessel_type
|
|
# From the formation origin, not the centroid: with a lopsided layout the
|
|
# centroid is already displaced by the average offset, so adding the new
|
|
# ship's own offset to it would drop it well outside the wedge.
|
|
ship.position = get_formation_origin() + offset
|
|
ship.glow_color = ship_glow_color
|
|
ship.core_color = ship_core_color
|
|
add_child(ship)
|
|
ships.append(ship)
|
|
formation_offsets.append(offset)
|
|
if ship.has_signal("destroyed"):
|
|
ship.destroyed.connect(_on_ship_destroyed.bind(ship))
|
|
ship.set_move_target(fleet_target + offset)
|
|
_sync_composition_state()
|
|
return true
|
|
|
|
|
|
func store_ship(index: int) -> String:
|
|
# A fleet always keeps one ship deployed. Removing the last one would trip
|
|
# the wiped-out-fleet safety net on the next frame and immediately spawn a
|
|
# replacement, which is the opposite of storing it at the mothership.
|
|
if ships.size() <= 1 or index < 0 or index >= ships.size():
|
|
return ""
|
|
var ship: Node = ships[index]
|
|
if not is_instance_valid(ship):
|
|
return ""
|
|
var vessel_type: String = String(ship.vessel_type)
|
|
ships.remove_at(index)
|
|
formation_offsets.remove_at(index)
|
|
ship.queue_free()
|
|
apply_formation()
|
|
_sync_composition_state()
|
|
return vessel_type
|
|
|
|
|
|
func apply_formation() -> void:
|
|
# Re-seats the EXISTING ships into the current GameState.formation.
|
|
# Without this, editing the layout at a command centre (or pivoting it)
|
|
# only affected ships built later, which read as the edit doing nothing.
|
|
for i in range(ships.size()):
|
|
if i >= GameState.max_fleet_size():
|
|
break
|
|
formation_offsets[i] = GameState.formation[i]
|
|
_assign_slot_targets()
|
|
|
|
|
|
func move_to(world_pos: Vector2) -> void:
|
|
steer_direction = Vector2.ZERO
|
|
fleet_target = world_pos
|
|
anchor = world_pos
|
|
_assign_slot_targets()
|
|
|
|
|
|
func move_in_direction(direction: Vector2) -> void:
|
|
# Joystick steering. Sets the heading; _process advances the anchor.
|
|
#
|
|
# This used to park a target 2000 units ahead and let the ships chase
|
|
# it. That made formation changes barely register while flying: with
|
|
# the aim point that far away, a 60-unit formation offset moved a
|
|
# ship's heading by under two degrees, so pivoting mid-flight looked
|
|
# like it did almost nothing. Anchoring the formation and having each
|
|
# ship hold its own slot relative to it fixes that.
|
|
if direction == Vector2.ZERO:
|
|
stop()
|
|
return
|
|
if steer_direction == Vector2.ZERO:
|
|
anchor = get_formation_origin()
|
|
steer_direction = direction.normalized()
|
|
|
|
|
|
func _process(delta: float) -> void:
|
|
if steer_direction == Vector2.ZERO:
|
|
return
|
|
# The anchor - the fleet's formation centre - travels at cruise_speed.
|
|
# Ships may exceed it individually to reach their slots. #59: multiplied
|
|
# at the point of use, not baked into cruise_speed itself, so the base
|
|
# value stays stable regardless of the current boost.
|
|
anchor += steer_direction * _effective_cruise_speed() * delta
|
|
fleet_target = anchor
|
|
_assign_slot_targets()
|
|
|
|
|
|
func _effective_cruise_speed() -> float:
|
|
return cruise_speed * GameState.fleet_speed_multiplier
|
|
|
|
|
|
func _assign_slot_targets() -> void:
|
|
var effective_cruise_speed: float = _effective_cruise_speed()
|
|
for i in range(ships.size()):
|
|
ships[i].set_move_target(fleet_target + formation_offsets[i])
|
|
# Context, not a command: the ship adds this to its own velocity to
|
|
# work out how it is really moving. See Ship.fleet_velocity.
|
|
ships[i].fleet_velocity = steer_direction * effective_cruise_speed
|
|
|
|
|
|
func stop() -> void:
|
|
steer_direction = Vector2.ZERO
|
|
# Aim each ship at the point where its own braking curve brings it to
|
|
# rest, so releasing the stick coasts to a halt instead of snapping to
|
|
# a dead stop (which is what targeting the current position would do,
|
|
# since that lands inside arrive_radius immediately).
|
|
fleet_target = get_formation_origin()
|
|
for ship in ships:
|
|
# A ship's `velocity` is already its true motion, including the
|
|
# fleet's travel, because Ship feeds the slot velocity forward into
|
|
# its own steering rather than carrying it in a separate field. So
|
|
# stopping is only a matter of telling it the slot has halted and
|
|
# aiming it at the point its own braking curve reaches.
|
|
#
|
|
# This used to do `ship.velocity += ship.fleet_velocity` here, to
|
|
# compensate for `velocity` reading zero while the ship was in fact
|
|
# cruising (Ship snapped to its slot every tick and zeroed it). That
|
|
# compensation was an unbounded ACCUMULATOR: every release added a
|
|
# whole cruise velocity, the next steer refilled fleet_velocity, and
|
|
# tapping a direction repeatedly stacked them up faster than
|
|
# `acceleration` could bleed them off - so a vessel could be flung
|
|
# along at many times its own top speed, and ships fell out of sync
|
|
# because each bled off at a rate set by its own distance to its
|
|
# slot. Ship now bounds its total speed every tick as well, so
|
|
# neither half of that can come back.
|
|
var motion: Vector2 = ship.velocity
|
|
# The fleet is not cruising any more, so the slot is standing still.
|
|
ship.fleet_velocity = Vector2.ZERO
|
|
var speed: float = motion.length()
|
|
if speed <= 0.001:
|
|
ship.set_move_target(ship.position)
|
|
continue
|
|
var braking_distance: float = (speed * speed) / (2.0 * ship.acceleration)
|
|
ship.set_move_target(ship.position + motion.normalized() * braking_distance)
|
|
|
|
|
|
func get_move_targets() -> Array:
|
|
var result: Array = []
|
|
for ship in ships:
|
|
result.append(ship.move_target)
|
|
return result
|
|
|
|
|
|
func restore(previous_fleet_target: Vector2, previous_move_targets: Array) -> void:
|
|
fleet_target = previous_fleet_target
|
|
for i in range(ships.size()):
|
|
ships[i].move_target = previous_move_targets[i]
|
|
|
|
|
|
func _on_ship_destroyed(ship: Node) -> void:
|
|
var idx: int = ships.find(ship)
|
|
if idx != -1:
|
|
ships.remove_at(idx)
|
|
formation_offsets.remove_at(idx)
|
|
_sync_composition_state()
|
|
|
|
|
|
func get_centroid() -> Vector2:
|
|
if ships.is_empty():
|
|
return fleet_target
|
|
var sum: Vector2 = Vector2.ZERO
|
|
for ship in ships:
|
|
sum += ship.position
|
|
return sum / ships.size()
|
|
|
|
|
|
func get_formation_origin() -> Vector2:
|
|
# Where the anchor must be for the ships to be standing in their slots
|
|
# right now. This is NOT the centroid: ships sit at anchor + offset, so
|
|
# the centroid is anchor + the AVERAGE offset, and the two only coincide
|
|
# when the layout happens to be balanced around its origin.
|
|
#
|
|
# The default wedge is balanced, which is why using the centroid as the
|
|
# anchor looked fine - until a layout dragged off to one corner at a
|
|
# command centre made the average offset large. Seeding the anchor from
|
|
# the centroid then displaced every slot by that average the instant
|
|
# steering began, so the fleet lurched towards the formation's own
|
|
# lopsided side before the anchor caught up and it flew the right way.
|
|
if ships.is_empty():
|
|
return fleet_target
|
|
var sum: Vector2 = Vector2.ZERO
|
|
for offset in formation_offsets:
|
|
sum += offset
|
|
return get_centroid() - sum / formation_offsets.size()
|