137e4e528d
The web export reached the main menu and went no further. Two separate bugs,
one hiding the other.
BUTTONS NEVER FIRED. A browser on a phone delivers the touch DOWN and never
the release. IconButton emits `pressed` only on release, deliberately, so
that dragging off cancels - so on the web it never emitted at all, on every
button in the game. fire_on_press (default OS.has_feature("web")) completes
the press there instead, and does not latch, since nothing is coming to
unlatch it. The cost is drag-off-to-cancel, which every other platform keeps.
Measured on the device rather than guessed: an on-screen probe reported
`touch=1 mouse=1 held=y` after one tap - one down, one emulated mouse down,
the button latched through ordinary GUI routing, then nothing.
THE ENGINE THEN TRAPPED. With the button working, pressing Play loaded and
built Main.tscn and the whole engine stopped mid-frame, page still alive.
An error overlay in a custom HTML shell finally showed why:
Uncaught RuntimeError: remainder by zero
An integer % 0. Wasm TRAPS on that; native builds silently tolerate it. So
the bug was equally present on Android and in all 100 tests, doing nothing
in both - which is why nothing runnable here could ever have caught it, and
why reasoning from frozen screenshots got nowhere for several rounds. Every
variable modulo is now guarded: the hangar grid's `i % columns`, planet
naming's `% names.size()`, and two in the map editor.
WHAT IS KEPT, AND WHY
- web_shell.html mirrors console errors onto the page, hidden until one
occurs. Godot's errors go to the browser console, which is unreachable on
a phone; this found in one shot what inference had failed to find all
evening. It costs nothing when there is nothing to report.
- MainMenu._start does load -> instantiate -> add_child by hand instead of
change_scene_to_file. That call does all three opaquely, so a failure is
indistinguishable from an unpressed button; split, each step reports.
- PlanetAtmosphereController defers the forced world populate out of the
frame that builds Main.tscn. It did not fix the hang - the trap did - but
25 chunks of asteroids and 49 of planets do not belong in the one frame
that already constructs 197 nodes, and nothing can paint until it ends.
Removed the direct-input-routing experiment and its test: it was written on
the theory that touches were not reaching Controls, which `held=y` later
disproved, and its set_input_as_handled() swallowed the very events the
probe was reading.
Full suite green at 100/100.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
133 lines
5.7 KiB
GDScript
133 lines
5.7 KiB
GDScript
extends Node2D
|
|
|
|
# Space-side: bootstraps the fleet on Main.tscn startup (a fresh 5-ship
|
|
# fleet at the origin on first launch, or GameState's surviving ship
|
|
# count/position if we just returned from a planet's surface), shows an
|
|
# "enter atmosphere" prompt (name + button) when the fleet is standing on
|
|
# a landable planet, and - on press - fades out and swaps to a completely
|
|
# separate PlanetSurface.tscn scene (not an overlay toggled in place), so
|
|
# asteroids/enemies genuinely cannot exist there rather than merely being
|
|
# hidden. Fleet size and the world position/zoom to return to are handed
|
|
# off via the GameState autoload, since change_scene_to_file() tears down
|
|
# this whole scene tree.
|
|
|
|
@export var fade_duration: float = 0.4
|
|
@export var prompt_debounce_time: float = 0.15
|
|
|
|
@onready var planet_field: Node2D = get_node("../PlanetField")
|
|
@onready var asteroid_field: Node2D = get_node("../AsteroidField")
|
|
@onready var fleet: Node2D = get_node("../Fleet")
|
|
@onready var camera: Camera2D = get_node("../Camera2D")
|
|
@onready var planet_name_label: Label = get_node("../UI/PlanetNameLabel")
|
|
@onready var enter_button: IconButton = get_node("../UI/EnterAtmosphereButton")
|
|
@onready var world_map: Control = get_node("../UI/WorldMap")
|
|
@onready var build_controller: Node2D = get_node("../BuildController")
|
|
@onready var fade_rect: ColorRect = get_node("../FadeOverlay/FadeRect")
|
|
|
|
var current_planet: Node2D = null
|
|
var transitioning: bool = false
|
|
var pending_planet: Node2D = null
|
|
var pending_time: float = 0.0
|
|
|
|
|
|
func _ready() -> void:
|
|
enter_button.pressed.connect(_on_enter_pressed)
|
|
|
|
if GameState.has_return_position:
|
|
fleet.spawn_ships(GameState.surviving_ship_count, GameState.return_world_position,
|
|
GameState.surviving_vessel_types)
|
|
camera.position = GameState.return_world_position
|
|
camera.zoom = Vector2(GameState.return_camera_zoom, GameState.return_camera_zoom)
|
|
GameState.has_return_position = false
|
|
else:
|
|
# A brand new game. STARTING_SHIP_COUNT rather than a literal: this
|
|
# said 5, which was the old BASE_FLEET_SIZE written out by hand, and
|
|
# it silently became "however many slots exist" once max_fleet_size()
|
|
# clamped it. The opening fleet size is one decision and it lives in
|
|
# GameState.
|
|
fleet.spawn_ships(GameState.STARTING_SHIP_COUNT, Vector2.ZERO)
|
|
|
|
# AsteroidField/PlanetField normally only populate nearby chunks once
|
|
# their own check_interval timer elapses (~1s) - fine during normal
|
|
# continuous play (things appear far off-screen, gradually), but
|
|
# right after a fresh scene load it means an empty-looking world for
|
|
# a second before asteroids/the planet visibly pop in. Force an
|
|
# immediate synchronous populate now that the fleet is correctly
|
|
# positioned, so nothing is missing on the very first visible frame.
|
|
# DEFERRED, not called straight through. Everything above runs inside the
|
|
# single frame that builds Main.tscn, and these two populate 25 and 49
|
|
# chunks of world on top of it - 150-odd asteroids plus planets and their
|
|
# visuals. On a phone browser that frame is where the scene appeared to
|
|
# hang forever: nothing can paint until it ends, so a slow frame and a
|
|
# freeze look identical. One frame later is still immediate to the eye,
|
|
# and it lets the scene draw first.
|
|
asteroid_field.update_chunks.call_deferred()
|
|
planet_field.update_chunks.call_deferred()
|
|
|
|
|
|
func _process(delta: float) -> void:
|
|
if transitioning:
|
|
return
|
|
|
|
if world_map.visible or build_controller.is_showing_building_prompt():
|
|
# Context actions belong to BuildController. This controller owns the
|
|
# debounced planet selection and label, and suppresses both while a modal
|
|
# screen is open.
|
|
current_planet = null
|
|
pending_planet = null
|
|
planet_name_label.visible = false
|
|
return
|
|
|
|
# Debounced: only commit a visible/hidden change once the raw
|
|
# landing-detection result has stayed the same for prompt_debounce_time
|
|
# in a row, instead of reacting to every single frame's reading. Belt
|
|
# and suspenders on top of get_planet_fleet_is_on() already using the
|
|
# fleet's centroid (a single stable number - see Planet.gd) rather
|
|
# than any individual ship's position, so this only has to absorb
|
|
# genuine sub-debounce-window boundary crossings, not constant noise.
|
|
var detected_planet: Node2D = planet_field.get_planet_fleet_is_on()
|
|
if detected_planet != pending_planet:
|
|
pending_planet = detected_planet
|
|
pending_time = 0.0
|
|
else:
|
|
pending_time += delta
|
|
|
|
if pending_time < prompt_debounce_time or pending_planet == current_planet:
|
|
return
|
|
|
|
current_planet = pending_planet
|
|
if current_planet != null:
|
|
planet_name_label.text = current_planet.planet_name
|
|
planet_name_label.visible = true
|
|
else:
|
|
planet_name_label.visible = false
|
|
|
|
|
|
func _on_enter_pressed() -> void:
|
|
if transitioning or current_planet == null:
|
|
return
|
|
transitioning = true
|
|
planet_name_label.visible = false
|
|
enter_button.visible = false
|
|
|
|
GameState.has_return_position = true
|
|
GameState.surviving_ship_count = fleet.ships.size()
|
|
GameState.surviving_vessel_types = fleet.vessel_types()
|
|
# The planet's own position, not fleet.get_centroid() - the fleet only
|
|
# needs to be somewhere within the planet's landing radius (not
|
|
# centered exactly on it) for the prompt to show, so the centroid can
|
|
# be tens of units off from the planet. Returning should always place
|
|
# the fleet back at the planet itself.
|
|
GameState.return_world_position = current_planet.position
|
|
GameState.return_camera_zoom = camera.zoom.x
|
|
GameState.planet_name = current_planet.planet_name
|
|
GameState.planet_id = current_planet.planet_id
|
|
GameState.planet_definition_id = current_planet.definition_id
|
|
|
|
var tween: Tween = create_tween()
|
|
tween.tween_property(fade_rect, "color:a", 1.0, fade_duration)
|
|
tween.tween_callback(_enter_surface)
|
|
|
|
|
|
func _enter_surface() -> void:
|
|
get_tree().change_scene_to_file("res://PlanetSurface.tscn")
|