metaheavens/spaceship
Watch
1
0
Fork
You've already forked spaceship
 0
Code Issues 4 Pull requests Projects 1 Releases Packages Wiki Activity

Share one backdrop between game and editor, and fix three input/economy bugs

Browse source 
The setup editor and the landed surface drew different backgrounds for the
same planet. Each scene carried its own hand-written ShaderMaterial, and only
the game side ever swapped in a profile's shader, so a gas giant authored in
the editor showed recoloured craters while the game showed cloud bands. Both
now instance one SurfaceBackground.tscn and configure it through one method,
and every profile names its own shader - the old "null means keep whatever
the scene already had" convention was the drift, since each scene "already
had" something different. The shared material is resource_local_to_scene, or
two live surfaces would repaint each other.

The gas giant's bands broke into disjoint segments once per cell: the second
turbulence octave doubled only the INTEGER half of a lattice coordinate,
which is a different point in every cell rather than the same point at twice
the frequency. Measured, the old form steps 0.153 at a cell boundary against
0.0002 now. A second discontinuity went with it - the camera cell index
arrives pre-wrapped, so hashing it raw rearranged the whole sky every 32
cells; hashes are now wrapped per octave and the field is exactly periodic.
Bands also gained low-frequency octaves and per-row differential drift.

WorldMap swallowed every touch in _input(), which runs before the GUI system,
so CloseButton never saw one: the map could be opened and not closed. Android
and desktop hid it behind Godot's emulated mouse event, which this never
swallowed; a phone browser gives no such second chance. Its test had been
closing the map by calling the method the button was failing to reach.

Construction now draws on the fleet hold as well as the bank. With an empty
starting bank and ore bankable only at a mothership, charging construction to
the bank alone made the first mothership cost ore that could not yet exist.

Also: a conquered planet no longer re-spawns its garrison (guarded on having
capture points, since a setup with none registers as vacuously conquered);
planets keep the map they drew, with the candidate list sorted rather than
left in filesystem order and assignments pruned rather than cleared on
rescan; and the map editor lists setups at a tappable size and can delete
one, as an explicit armed mode rather than a tap away from destroying work.

Full suite 106/106.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
Loïc Wisniewski 2026-08-19 11:16:38 +02:00
commit f5a16a7b95
35 changed files with 1783 additions and 152 deletions
Download patch file Download diff file Expand all files Collapse all files

144
LunarBackground.gd
View file

@ -1,144 +0,0 @@
extends ColorRect
# Feeds the lunar shader the camera's position split into a CELL INDEX plus
# a fraction within that cell, rather than a raw world position. See the
# long note in Starfield.gd for why - identical reasoning, identical split.
#
# Forgejo #68: also bakes the crater field once, at load, instead of letting
# it be re-derived per pixel per frame. The field is a fixed function of
# world position, so every frame was recomputing an identical answer. It is
# rendered once into a square texture covering one period of the field (the
# field is periodic - see the cell wrap in lunar_surface.gdshader) and
# lunar_tiled.gdshader then scrolls that texture with repeat wrapping, which
# keeps the canvas infinite while the per-frame cost drops to one fetch.
# Single source of truth for the tile period, shared with BOTH shaders. The
# field repeats every TILE_CELLS * cell_size world units - at 32 cells of
# 220 that is 7040 units, several screens wide at default zoom.
const TILE_CELLS: float = 32.0
# Texture resolution for the bake, in pixels per cell. One cell is cell_size
# (220) world units, so this is a ~3.4x magnification at default zoom. That
# is affordable because the field is smooth by construction: the sharpest
# feature is the rim band, roughly 0.12 cells wide, which still lands across
# ~8 texels here and so survives bilinear magnification as a gradient rather
# than as steps.
const BAKE_PIXELS_PER_CELL: int = 64
# The palette, sampled from a NASA Artemis lunar photograph. These live on
# the node rather than as parameters of the drawing material because the
# shader that actually consumes them is the BAKE shader, which the scene
# never references directly - leaving them as orphan parameters on the tiled
# material would make them look live when they are only read once at load.
@export var base_color: Color = Color(0.75, 0.75, 0.76)
@export var crater_color: Color = Color(0.44, 0.44, 0.45)
@export var highlight_color: Color = Color(0.89, 0.89, 0.90)
@onready var camera: Camera2D = get_node("../../Camera2D")
func _ready() -> void:
_bake_field()
# Asked of the shader itself rather than by comparing against a known path,
# so this keeps working whichever shader a surface profile swaps in: the
# question is only ever "does what is drawing this background actually
# sample a baked field".
func _material_wants_baked_field() -> bool:
if material == null or material.shader == null:
return false
for uniform in material.shader.get_shader_uniform_list():
if String(uniform.get("name", "")) == "field_texture":
return true
return false
func _process(_delta: float) -> void:
var viewport_size: Vector2 = get_viewport_rect().size
var cell_size: float = material.get_shader_parameter("cell_size")
var p: Vector2 = camera.global_position / cell_size
var cell: Vector2 = Vector2(floor(p.x), floor(p.y))
# The tiled shader samples a repeating texture, so only the camera's
# position WITHIN the tile matters. Wrapping here rather than in the
# shader keeps the raw cell index - which reaches the thousands after a
# while - out of a mobile float entirely: GDScript does this in double
# precision. fposmod, not fmod, so flying into negative coordinates
# wraps to the far side of the tile instead of mirroring.
material.set_shader_parameter("camera_cell", Vector2(
fposmod(cell.x, TILE_CELLS), fposmod(cell.y, TILE_CELLS)))
material.set_shader_parameter("camera_frac", p - cell)
material.set_shader_parameter("camera_zoom", 1.0 / camera.zoom.x)
material.set_shader_parameter("viewport_size", viewport_size)
material.set_shader_parameter("tile_cells", TILE_CELLS)
# Renders exactly one period of the procedural field into a texture and hands
# it to the tiled shader. Runs once, during the planet-arrival fade, where a
# single expensive frame is invisible.
func _bake_field() -> void:
# Headless runs - every scene-based test - rasterize nothing, so a bake
# would allocate a render target, await a draw that never produces
# anything readable, and leave this coroutine suspended forever holding
# the SubViewport alive. Nothing is lost by skipping: there is no display
# for the background to appear on.
if DisplayServer.get_name() == "headless":
return
# One frame of grace before committing to the bake. A surface profile can
# replace this material's shader outright - a gas giant brings its own
# background (#51) - and PlanetSurfaceController does that in _ready(),
# alongside this one, with no ordering guarantee between them. Rendering
# a 2048-square lunar tile for a shader that will never sample it would
# waste exactly the frame the player is already waiting on to land.
await get_tree().process_frame
if not _material_wants_baked_field():
return
var procedural: Shader = load("res://lunar_surface.gdshader")
if procedural == null:
push_warning("lunar background: could not load the field shader to bake")
return
var side: int = int(TILE_CELLS) * BAKE_PIXELS_PER_CELL
var bake_material := ShaderMaterial.new()
bake_material.shader = procedural
# Carry the look across from whatever the scene configured, so the tile
# is baked with the colours actually set on this node rather than the
# shader's own defaults.
bake_material.set_shader_parameter("base_color", base_color)
bake_material.set_shader_parameter("crater_color", crater_color)
bake_material.set_shader_parameter("highlight_color", highlight_color)
bake_material.set_shader_parameter("cell_size", material.get_shader_parameter("cell_size"))
bake_material.set_shader_parameter("tile_cells", TILE_CELLS)
# Non-zero switches the field shader into bake mode: UV maps straight
# onto one tile and the per-screen-pixel dither is left out.
bake_material.set_shader_parameter("bake_cells", TILE_CELLS)
var sub_viewport := SubViewport.new()
sub_viewport.size = Vector2i(side, side)
sub_viewport.disable_3d = true
sub_viewport.transparent_bg = false
sub_viewport.render_target_update_mode = SubViewport.UPDATE_ONCE
var bake_rect := ColorRect.new()
bake_rect.material = bake_material
bake_rect.size = Vector2(side, side)
sub_viewport.add_child(bake_rect)
add_child(sub_viewport)
# One frame for the SubViewport to actually draw, then read it back.
await RenderingServer.frame_post_draw
var image: Image = sub_viewport.get_texture().get_image()
sub_viewport.queue_free()
# Headless runs (every scene-based test) render nothing at all, so there
# is no image to read back. That is not a failure: the background simply
# has nothing to show, and the rest of the scene is unaffected.
if image == null or image.is_empty():
return
# Mipmaps are what keep a crater field from shimmering when the camera
# zooms out and each screen pixel starts covering many texels.
image.generate_mipmaps()
var texture := ImageTexture.create_from_image(image)
material.set_shader_parameter("field_texture", texture)