2f161621c3
Everything lived in one flat directory, so a diff gave no clue what area it touched and finding the file you wanted meant knowing its exact name. Twelve folders now, grouped by what a thing IS rather than what type it is - a vessel's definition, its component scenes and its upgrade resources sit together, because that is the set you read when you change one of them. buildings core controllers enemies logistics planets resources shaders surface ui vessels vfx world 332 files moved and every res:// reference rewritten - 306 files touched, including the autoload and main-scene paths in project.godot. Nothing renamed: this is purely where files sit, so the diff is a pile of pure moves and no behaviour is buried in it. ui_theme.tres, icon.svg and web_shell.html stay at the root, where Godot and the export preset expect them. Verified three ways, because a suite alone would not have caught all of it: the full 117 pass, the web export builds clean, and the game renders. The export is why that matters. The FIRST export after the move failed with "Attempt to open script 'res://GameState.gd'" - the old path - while project.godot on disk plainly said res://core/GameState.gd. That is this project's documented Android FUSE mtime trap: Godot served a cached copy of a file whose content had changed. A `touch` fixed it. Nothing in the test suite would have found that, because the suite runs from a copy on a native filesystem - the one place the bug cannot happen. 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://surface/PlanetSurface.tscn")
|