metaheavens/spaceship
Watch
1
0
Fork
You've already forked spaceship
 0
Code Issues 4 Pull requests Projects 1 Releases Packages Wiki Activity
spaceship/IconButton.gd
Loïc Wisniewski 54287d27ea Implement #77, #78 and #79 
#77 - the Distorder becomes the Energy Propulser. Renamed everywhere the
player reads it, reskinned to match: a symmetric hull flaring into an engine
skirt instead of the lopsided warped lump, an engine bell with a thrust plume
instead of the wobbling ring glyph, and energy's own yellow instead of purple,
since energy is what it burns. The internal id stays "distorder" - it is the
capability string, the unlock key and the component scene name, and renaming
the wiring would be a large mechanical change with no player-visible effect.

Its speed ceiling now grows with the LOGARITHM of how many fly. Each one used
to add a flat 1.0, so a fleet that could afford six simply drove at six times
cruise and the vessel stopped being a choice. Base-2 makes the rule one
sentence - every doubling adds another 1.0 - and leaves two propulsers worth
exactly what they were worth before, so nothing already built is devalued.

#78 - a gas burner can be paused. It converts gas the player may want for
bombs into energy they may not need yet, and the only way to stop it was to
demolish it. The action is data-driven like every other: the visual's
ActionProvider lists "pause", and any converter can adopt it. Pause is the
burner's PRIMARY action, so it is one tap rather than a menu; the button shows
what it will DO, bars while running and a play triangle while stopped; and the
building itself goes visibly cold, because a paused building that looked
identical to a running one would be a setting to remember rather than see.
Conversion progress is left where it was rather than reset, so switching off
and on again does not discard a part-finished unit.

#79 - picking something up says so. A "+N" with the resource's own mark rises
and fades where it happened. Built from the SAME glyph the resource tables and
transfer rows use, so a material added to the catalog later cannot end up with
one mark in the HUD and a different one in the world. A pickup a full hold
REFUSES raises nothing.

Two Godot traps cost real time here and are now written down where the next
person will hit them:

  - a `#` comment inside a .tres [resource] block is not a comment. It parses
    as part of the preceding value and silently blanks the property after it.
    One in DistorderVesselDefinition.tres left definition_id empty, which
    surfaced as "<blank> did not resolve its definition" in a test far from
    the edit. The note lives in VesselDefinition.gd now.
  - a global class_name is not reliably resolvable, INCLUDING a script's own
    inside its own static function. ResourcePickupVFX.new() failed to compile
    when reached through a preview scene, taking Rock and the gas vents with
    it. It has no class_name now and constructs itself by path.

Suite 114/114.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-21 17:38:30 +02:00

771 lines
34 KiB
GDScript
Raw Blame History

class_name IconButton
extends Control
# Square neon-outlined button, hand-drawn to match the game's existing
# no-texture glowing look (same NeonDraw technique as ships/enemies) -
# no icon image assets, just a glyph drawn inside the frame.
signal pressed
# Scenes store `icon` as a plain int, so NEW ENTRIES MUST BE APPENDED -
# inserting one would silently repoint every button after it.
enum Icon {
MAP, CLOSE, SHIP, DOWN_ARROW, UP_ARROW, BUILD, ROTATE_CW, ROTATE_CCW,
# One per building, each a miniature of what actually gets placed. The
# build menu used to pick from the generic set, which left the mothership
# and the command centre sharing a folded-map glyph and neither of them
# looking anything like the structure they build.
MOTHERSHIP, CRAFTER, COMMAND_CENTER, EXTRACTOR, TRANSPORT_HUB, SHIP_LAB,
# Moving ore between the fleet and a building (#24). Two arrows passing
# each other: the single up/down arrows already mean "load" and "store"
# one way each, and this button is the place where both live.
TRANSFER,
# Ship-lab upgrade glyphs. These deliberately describe the effect rather
# than the building hosting it, so cards remain scannable at a glance.
UPGRADE_DAMAGE, UPGRADE_RATE, UPGRADE_RANGE, UPGRADE_THRUSTERS,
UPGRADE_SHIELD_HITS, UPGRADE_SHIELD_RECHARGE, UPGRADE_CARGO,
UPGRADE_ENGINES, UPGRADE_UNLOCK_SHIELD,
ACTION_MENU,
GAS,
LEFT_ARROW, RIGHT_ARROW,
MINUS, PLUS,
SHIELD_VESSEL,
GAS_BOMBER, GAS_BOMB,
# Appended, not inserted alongside the other building icons above -
# inserting there would silently renumber every icon int already
# stored in existing scenes (#54).
GAS_BURNER,
# Same append-only rule (#57): a wide hauler hull, distinct from every
# vessel glyph above.
CARRIER_VESSEL,
# #58: LASER_VESSEL is the ship glyph, LASER_SHOT the action button -
# same two-icon split as GAS_BOMBER/GAS_BOMB above.
LASER_VESSEL, LASER_SHOT,
# #59 drew this as a warped ring, for a vessel then called a space-time
# distorder. #77 renamed it the Energy Propulser and the glyph is now an
# engine bell; the enum name stays put because renumbering it would
# silently renumber every icon int stored in every scene.
DISTORDER_VESSEL,
# #78: switching a converter off and on. Appended, like everything above -
# inserting anywhere earlier renumbers every icon int already stored in a
# scene file.
PAUSE, RESUME,
}
# Size the glyphs were originally drawn against. Every glyph dimension is
# scaled by (actual size / this), so the button can be resized in the scene
# without the icon inside it staying small.
const REFERENCE_SIZE: float = 56.0
@export var icon: int = Icon.MAP
@export var glow_color: Color = Color(0.25, 0.85, 1.0)
# Selection is an additional frame, never a recolour. It lets menus retain
# semantic colours (vessel class, danger, cargo) while still making the
# active choice unmistakable.
@export var highlighted: bool = false: set = set_highlighted
# Colour of the bright core stroke. Defaults to near-white, which reads well
# on the dark space background; scenes drawing over a bright backdrop (the
# lunar surface) override this with a dark colour so the button doesn't wash
# out. See NeonDraw.
@export var core_color: Color = Color(1.0, 1.0, 1.0)
# When false the button is drawn greyed out, but STILL emits `pressed` -
# the caller decides what to do, which is what lets an unavailable option
# explain itself instead of silently doing nothing.
@export var enabled: bool = true: set = set_enabled
@export var disabled_color: Color = Color(0.42, 0.45, 0.5)
var pressed_down: bool = false
func set_enabled(value: bool) -> void:
if enabled == value:
return
enabled = value
queue_redraw()
func set_highlighted(value: bool) -> void:
if highlighted == value:
return
highlighted = value
queue_redraw()
func _ready() -> void:
queue_redraw()
func _blocked_by_modal() -> bool:
# A panel is open and this button is not part of it, so it is sitting
# BEHIND the panel and must not react.
#
# The panels cannot simply swallow GUI input with a mouse_filter of STOP:
# the skill tree and the formation editor are driven from raw
# _unhandled_input (see SkillTreeView), and a Control that consumes
# touches through the GUI system swallows them before they ever get
# there. So the panels stay transparent to input and the buttons check
# instead.
for menu in get_tree().get_nodes_in_group("modal_menus"):
# is_visible_in_tree(), NOT visible. Hiding a parent leaves the
# child's own `visible` flag true, and the build menu's info popup is
# itself a modal panel - so closing the build menu with the X left an
# invisible popup still claiming to be open, and every button in the
# game was blocked from then on. That is not a state a player can
# get out of.
if menu.is_visible_in_tree() and not menu.is_ancestor_of(self):
return true
return false
func _gui_input(event: InputEvent) -> void:
if _blocked_by_modal():
return
if event is InputEventScreenTouch:
_handle_press(event.pressed, event.position)
accept_event()
elif event is InputEventMouseButton and event.button_index == MOUSE_BUTTON_LEFT:
_handle_press(event.pressed, event.position)
accept_event()
# Complete the press immediately instead of waiting for a release.
#
# Measured on the device, in the web build: an on-screen probe reported
# `touch=1 mouse=1 held=y` after one tap - one touch down, one emulated mouse
# down, the button latched into its held state through ordinary GUI routing,
# and then nothing. The release is never delivered. A button that only emits
# on release therefore never emits at all.
#
# GUI routing itself works fine; `held=y` is the proof. An earlier attempt to
# bypass it made things worse and hid the evidence.
#
# The cost is the drag-off-to-cancel affordance below. Everywhere that
# delivers releases keeps it.
@export var fire_on_press: bool = OS.has_feature("web")
# Round rather than square. The in-world action controls - the abilities
# arranged around the fire stick, and the pivot pair - read as a different
# kind of thing from the square panel and menu buttons, and a round target is
# what a thumb reaching for an ability expects. Purely how the frame is drawn;
# the hit area is still the whole rect.
@export var round_frame: bool = false
# The frame outline, inset by `inset` pixels on every side. Round buttons trace
# a circle through the same inset box, so a round and a square button of the
# same size present the same footprint.
func _frame_points(inset: float) -> PackedVector2Array:
if not round_frame:
return PackedVector2Array([
Vector2(inset, inset),
Vector2(size.x - inset, inset),
Vector2(size.x - inset, size.y - inset),
Vector2(inset, size.y - inset),
])
var centre: Vector2 = size / 2.0
var radius: Vector2 = centre - Vector2(inset, inset)
var points: PackedVector2Array = PackedVector2Array()
for i in range(32):
var angle: float = TAU * float(i) / 32.0
points.append(centre + Vector2(cos(angle) * radius.x, sin(angle) * radius.y))
return points
func _handle_press(is_pressed: bool, at_position: Vector2) -> void:
if is_pressed:
pressed_down = true
queue_redraw()
if fire_on_press:
# Not latched: nothing is coming to clear it.
pressed_down = false
pressed.emit()
elif pressed_down:
pressed_down = false
queue_redraw()
# Only counts as a real press if the finger/cursor is still over
# the button when it lifts - dragging off before releasing (a
# common way to "cancel" a touch) must not still trigger it.
if Rect2(Vector2.ZERO, size).has_point(at_position):
pressed.emit()
func _active_color() -> Color:
return glow_color if enabled else disabled_color
func _draw() -> void:
var rect_size: Vector2 = size
var s: float = min(rect_size.x, rect_size.y) / REFERENCE_SIZE
# Constant glow, brighter while held. Only the press state changes it,
# so the button redraws on press/release instead of every frame.
var pulse: float = 1.0 if pressed_down else 0.85
var margin: float = 4.0 * s
NeonDraw.draw_glowing_polygon(self, _frame_points(margin), _active_color(), pulse, core_color)
if highlighted:
# The inset frame reads as a selection focus ring. It deliberately uses
# the bright core rather than the button's glow colour, so selecting a
# blue shield or pink transporter does not change what that colour means.
NeonDraw.draw_glowing_polygon(self, _frame_points(10.0 * s), core_color, 1.0,
core_color, 0.72 * s)
var center: Vector2 = rect_size / 2.0
match icon:
Icon.CLOSE:
_draw_close(center, pulse, s)
Icon.SHIP:
_draw_ship(center, pulse, s)
Icon.MAP:
_draw_map(center, pulse, s)
Icon.DOWN_ARROW:
_draw_arrow(center, pulse, 1.0, s)
Icon.UP_ARROW:
_draw_arrow(center, pulse, -1.0, s)
Icon.BUILD:
_draw_build(center, pulse, s)
Icon.ROTATE_CW:
_draw_rotate(center, pulse, s, 1.0)
Icon.ROTATE_CCW:
_draw_rotate(center, pulse, s, -1.0)
Icon.MOTHERSHIP:
_draw_mothership_icon(center, pulse, s)
Icon.CRAFTER:
_draw_crafter_icon(center, pulse, s)
Icon.COMMAND_CENTER:
_draw_command_icon(center, pulse, s)
Icon.EXTRACTOR:
_draw_extractor_icon(center, pulse, s)
Icon.TRANSPORT_HUB:
_draw_transport_hub_icon(center, pulse, s)
Icon.SHIP_LAB:
_draw_ship_lab_icon(center, pulse, s)
Icon.TRANSFER:
_draw_transfer_icon(center, pulse, s)
Icon.UPGRADE_DAMAGE:
_draw_upgrade_damage(center, pulse, s)
Icon.UPGRADE_RATE:
_draw_upgrade_rate(center, pulse, s)
Icon.UPGRADE_RANGE:
_draw_upgrade_range(center, pulse, s)
Icon.UPGRADE_THRUSTERS:
_draw_upgrade_thrusters(center, pulse, s)
Icon.UPGRADE_SHIELD_HITS:
_draw_upgrade_shield_hits(center, pulse, s)
Icon.UPGRADE_SHIELD_RECHARGE:
_draw_upgrade_shield_recharge(center, pulse, s)
Icon.UPGRADE_CARGO:
_draw_upgrade_cargo(center, pulse, s)
Icon.UPGRADE_ENGINES:
_draw_upgrade_engines(center, pulse, s)
Icon.UPGRADE_UNLOCK_SHIELD:
_draw_upgrade_unlock_shield(center, pulse, s)
Icon.ACTION_MENU:
_draw_action_menu(center, pulse, s)
Icon.GAS:
_draw_gas(center, pulse, s)
Icon.LEFT_ARROW:
_draw_horizontal_arrow(center, pulse, -1.0, s)
Icon.RIGHT_ARROW:
_draw_horizontal_arrow(center, pulse, 1.0, s)
Icon.MINUS:
_draw_minus(center, pulse, s)
Icon.PLUS:
_draw_plus(center, pulse, s)
Icon.SHIELD_VESSEL:
_draw_shield_vessel(center, pulse, s)
Icon.GAS_BOMBER:
_draw_gas_bomber(center, pulse, s)
Icon.GAS_BOMB:
_draw_gas_bomb(center, pulse, s)
Icon.GAS_BURNER:
_draw_gas_burner_icon(center, pulse, s)
Icon.PAUSE:
_draw_pause(center, pulse, s)
Icon.RESUME:
_draw_resume(center, pulse, s)
Icon.CARRIER_VESSEL:
_draw_carrier(center, pulse, s)
Icon.LASER_VESSEL:
_draw_laser_vessel(center, pulse, s)
Icon.LASER_SHOT:
_draw_laser_shot(center, pulse, s)
Icon.DISTORDER_VESSEL:
_draw_distorder_vessel(center, pulse, s)
func _draw_close(center: Vector2, pulse: float, s: float) -> void:
var r: float = 10.0 * s
NeonDraw.draw_glowing_line(self, center + Vector2(-r, -r), center + Vector2(r, r), _active_color(), pulse, 0.5 * s, core_color)
NeonDraw.draw_glowing_line(self, center + Vector2(-r, r), center + Vector2(r, -r), _active_color(), pulse, 0.5 * s, core_color)
func _draw_ship(center: Vector2, pulse: float, s: float) -> void:
var nose: Vector2 = center + Vector2(0, -11) * s
var left: Vector2 = center + Vector2(-7, 8) * s
var right: Vector2 = center + Vector2(7, 8) * s
var points: PackedVector2Array = PackedVector2Array([nose, left, right])
NeonDraw.draw_glowing_polygon(self, points, _active_color(), pulse, core_color)
func _draw_shield_vessel(center: Vector2, pulse: float, s: float) -> void:
var points: PackedVector2Array = PackedVector2Array()
for i in range(6):
var angle: float = -PI / 2.0 + float(i) * TAU / 6.0
points.append(center + Vector2(cos(angle), sin(angle)) * 11.0 * s)
NeonDraw.draw_glowing_polygon(self, points, _active_color(), pulse, core_color)
func _draw_carrier(center: Vector2, pulse: float, s: float) -> void:
# Wide and flat-bottomed rather than pointed - reads as a hauler, not a
# combat silhouette, matching the ship's own hull_points.
var hull := PackedVector2Array([
center + Vector2(-13, -4) * s,
center + Vector2(-7, -8) * s,
center + Vector2(7, -8) * s,
center + Vector2(13, -4) * s,
center + Vector2(13, 6) * s,
center + Vector2(-13, 6) * s,
])
NeonDraw.draw_glowing_polygon(self, hull, _active_color(), pulse, core_color)
func _draw_distorder_vessel(center: Vector2, pulse: float, s: float) -> void:
# #77: an engine bell with a thrust plume under it. The glyph used to be a
# ring with a wobbling radius, which read as warped space - correct for a
# "space-time distorder" and wrong for the Energy Propulser it now is.
var hull: PackedVector2Array = PackedVector2Array([
center + Vector2(0.0, -13.0) * s,
center + Vector2(5.0, -4.0) * s,
center + Vector2(7.0, 3.0) * s,
center + Vector2(10.0, 10.0) * s,
center + Vector2(-10.0, 10.0) * s,
center + Vector2(-7.0, 3.0) * s,
center + Vector2(-5.0, -4.0) * s,
])
NeonDraw.draw_glowing_polygon(self, hull, _active_color(), pulse, core_color)
# Three exhaust strokes, the middle one longest, so the thrust reads as
# coming OUT of the bell rather than as decoration beside it.
for offset in [-5.0, 0.0, 5.0]:
var length: float = 16.0 if is_zero_approx(offset) else 12.0
NeonDraw.draw_glowing_line(self,
center + Vector2(offset, 11.0) * s,
center + Vector2(offset, length) * s,
_active_color(), pulse * 0.8, 0.5, core_color)
func _draw_laser_vessel(center: Vector2, pulse: float, s: float) -> void:
# A slim dart rather than the interceptor's plain triangle - the notch at
# the nose reads as a fixed forward-facing emitter, not a hull point.
var hull := PackedVector2Array([
center + Vector2(0, -13) * s,
center + Vector2(-8, 9) * s,
center + Vector2(-3, 6) * s,
center + Vector2(3, 6) * s,
center + Vector2(8, 9) * s,
])
NeonDraw.draw_glowing_polygon(self, hull, _active_color(), pulse, core_color)
func _draw_laser_shot(center: Vector2, pulse: float, s: float) -> void:
var from: Vector2 = center + Vector2(-9, 9) * s
var to: Vector2 = center + Vector2(9, -9) * s
NeonDraw.draw_glowing_line(self, from, to, _active_color(), pulse, 1.1, core_color)
NeonDraw.draw_glowing_circle(self, to, 3.0 * s, _active_color(), pulse, core_color)
func _draw_gas_bomber(center: Vector2, pulse: float, s: float) -> void:
var hull := PackedVector2Array([
center + Vector2(0, -12) * s,
center + Vector2(-12, 7) * s,
center + Vector2(-5, 5) * s,
center + Vector2(0, 11) * s,
center + Vector2(5, 5) * s,
center + Vector2(12, 7) * s,
])
NeonDraw.draw_glowing_polygon(self, hull, _active_color(), pulse, core_color)
NeonDraw.draw_glowing_circle(self, center + Vector2(0, 2) * s, 4.0 * s,
_active_color(), pulse, core_color)
func _draw_gas_bomb(center: Vector2, pulse: float, s: float) -> void:
NeonDraw.draw_glowing_circle(self, center, 7.0 * s, _active_color(), pulse, core_color)
for direction in [Vector2.UP, Vector2.DOWN, Vector2.LEFT, Vector2.RIGHT]:
NeonDraw.draw_glowing_circle(self, center + direction * 9.0 * s, 3.5 * s,
_active_color(), pulse * 0.85, core_color)
func _draw_gas_burner_icon(center: Vector2, pulse: float, s: float) -> void:
# A hexagonal chamber with a hot core and vents, miniaturised from the
# building's own silhouette (BuildingVisualBase._draw_gas_burner_static)
# so the menu icon reads as the same structure being placed.
var outer: PackedVector2Array = PackedVector2Array()
var core: PackedVector2Array = PackedVector2Array()
for i in range(6):
var a: float = (float(i) / 6.0) * TAU + PI / 6.0
outer.append(center + Vector2(cos(a), sin(a)) * 11.0 * s)
core.append(center + Vector2(cos(a), sin(a)) * 5.5 * s)
NeonDraw.draw_glowing_polygon(self, outer, _active_color(), pulse, core_color)
NeonDraw.draw_glowing_polygon(self, core, _active_color(), pulse * 0.85, core_color)
for i in range(4):
var a: float = (float(i) / 4.0) * TAU + PI / 4.0
var dir: Vector2 = Vector2(cos(a), sin(a))
NeonDraw.draw_glowing_line(self, center + dir * 11.0 * s, center + dir * 15.5 * s,
_active_color(), pulse, 0.35 * s, core_color)
func _draw_arrow(center: Vector2, pulse: float, direction: float, s: float) -> void:
var r: float = 9.0 * s
var tip: Vector2 = center + Vector2(0, r * direction)
var shaft_top: Vector2 = center + Vector2(0, -r * direction)
NeonDraw.draw_glowing_line(self, shaft_top, tip, _active_color(), pulse, 0.5 * s, core_color)
NeonDraw.draw_glowing_line(self, tip, tip + Vector2(-r * 0.7, -r * 0.8 * direction), _active_color(), pulse, 0.5 * s, core_color)
NeonDraw.draw_glowing_line(self, tip, tip + Vector2(r * 0.7, -r * 0.8 * direction), _active_color(), pulse, 0.5 * s, core_color)
func _draw_horizontal_arrow(center: Vector2, pulse: float, direction: float, s: float) -> void:
var r: float = 10.0 * s
var tip: Vector2 = center + Vector2(r * direction, 0.0)
var tail: Vector2 = center + Vector2(-r * direction, 0.0)
NeonDraw.draw_glowing_line(self, tail, tip, _active_color(), pulse, 0.5 * s, core_color)
NeonDraw.draw_glowing_line(self, tip, tip + Vector2(-r * 0.8 * direction, -r * 0.7), _active_color(), pulse, 0.5 * s, core_color)
NeonDraw.draw_glowing_line(self, tip, tip + Vector2(-r * 0.8 * direction, r * 0.7), _active_color(), pulse, 0.5 * s, core_color)
func _draw_pause(center: Vector2, pulse: float, s: float) -> void:
# Two upright bars. Shown while something is RUNNING, because that is the
# action the button performs, not the state it is in.
for side in [-1.0, 1.0]:
var x: float = 5.0 * side * s
NeonDraw.draw_glowing_line(self, center + Vector2(x, -11.0 * s),
center + Vector2(x, 11.0 * s), _active_color(), pulse, 0.9, core_color)
func _draw_resume(center: Vector2, pulse: float, s: float) -> void:
# A play triangle, shown while something is stopped.
var play: PackedVector2Array = PackedVector2Array([
center + Vector2(-7.0, -11.0) * s,
center + Vector2(11.0, 0.0) * s,
center + Vector2(-7.0, 11.0) * s,
])
NeonDraw.draw_glowing_polygon(self, play, _active_color(), pulse, core_color)
func _draw_minus(center: Vector2, pulse: float, s: float) -> void:
var r: float = 9.0 * s
NeonDraw.draw_glowing_line(self, center + Vector2(-r, 0.0), center + Vector2(r, 0.0),
_active_color(), pulse, 0.55 * s, core_color)
func _draw_plus(center: Vector2, pulse: float, s: float) -> void:
_draw_minus(center, pulse, s)
var r: float = 9.0 * s
NeonDraw.draw_glowing_line(self, center + Vector2(0.0, -r), center + Vector2(0.0, r),
_active_color(), pulse, 0.55 * s, core_color)
func _draw_transfer_icon(center: Vector2, pulse: float, s: float) -> void:
# Two shafts side by side pointing opposite ways. Drawn as a pair rather
# than as one double-headed arrow because the button's whole job is that
# ore moves BOTH ways here, and a double-headed arrow reads as one thing
# sliding back and forth.
var r: float = 10.0 * s
var gap: float = 7.0 * s
for side in [-1.0, 1.0]:
# Left shaft points up (into the fleet), right shaft points down.
var direction: float = side
var x: float = gap * side
var tip: Vector2 = center + Vector2(x, r * direction)
var tail: Vector2 = center + Vector2(x, -r * direction)
NeonDraw.draw_glowing_line(self, tail, tip, _active_color(), pulse, 0.42 * s, core_color)
var head: float = 5.0 * s
NeonDraw.draw_glowing_line(self, tip, tip + Vector2(-head, -head * direction),
_active_color(), pulse, 0.42 * s, core_color)
NeonDraw.draw_glowing_line(self, tip, tip + Vector2(head, -head * direction),
_active_color(), pulse, 0.42 * s, core_color)
# --- ship-lab upgrade glyphs ---------------------------------------------
func _draw_upgrade_damage(center: Vector2, pulse: float, s: float) -> void:
# A heavy projectile striking a target.
NeonDraw.draw_glowing_line(self, center + Vector2(-13, 0) * s, center + Vector2(5, 0) * s, _active_color(), pulse, 0.7 * s, core_color)
for a in [0.0, PI * 0.5, PI, PI * 1.5]:
var dir := Vector2(cos(a), sin(a))
NeonDraw.draw_glowing_line(self, center + Vector2(8, 0) * s, center + Vector2(8, 0) * s + dir * 7.0 * s, _active_color(), pulse, 0.4 * s, core_color)
func _draw_upgrade_rate(center: Vector2, pulse: float, s: float) -> void:
# Three successive shots: more fire per second.
for x in [-9.0, 0.0, 9.0]:
NeonDraw.draw_glowing_line(self, center + Vector2(x - 3, 7) * s, center + Vector2(x + 3, -7) * s, _active_color(), pulse, 0.55 * s, core_color)
func _draw_upgrade_range(center: Vector2, pulse: float, s: float) -> void:
# Reticle with a long sight line.
var r := 10.0 * s
for i in range(12):
var a := TAU * float(i) / 12.0
var b := TAU * float(i + 1) / 12.0
NeonDraw.draw_glowing_line(self, center + Vector2(cos(a), sin(a)) * r, center + Vector2(cos(b), sin(b)) * r, _active_color(), pulse, 0.32 * s, core_color)
NeonDraw.draw_glowing_line(self, center + Vector2(-15, 0) * s, center + Vector2(15, 0) * s, _active_color(), pulse, 0.38 * s, core_color)
NeonDraw.draw_glowing_line(self, center + Vector2(0, -15) * s, center + Vector2(0, 15) * s, _active_color(), pulse, 0.38 * s, core_color)
func _draw_upgrade_thrusters(center: Vector2, pulse: float, s: float) -> void:
# Ship nozzle with two exhaust flames.
NeonDraw.draw_glowing_polygon(self, PackedVector2Array([center + Vector2(-10, -7) * s, center + Vector2(5, -7) * s, center + Vector2(11, 0) * s, center + Vector2(5, 7) * s, center + Vector2(-10, 7) * s]), _active_color(), pulse, core_color)
for y in [-4.0, 4.0]:
NeonDraw.draw_glowing_line(self, center + Vector2(-10, y) * s, center + Vector2(-17, y * 1.5) * s, _active_color(), pulse, 0.45 * s, core_color)
func _draw_upgrade_shield_hits(center: Vector2, pulse: float, s: float) -> void:
# Layered hexagonal shield walls.
for r in [8.0, 13.0]:
var hex := PackedVector2Array()
for i in range(6):
var a := TAU * float(i) / 6.0 + PI / 6.0
hex.append(center + Vector2(cos(a), sin(a)) * r * s)
NeonDraw.draw_glowing_polygon(self, hex, _active_color(), pulse, core_color)
func _draw_upgrade_shield_recharge(center: Vector2, pulse: float, s: float) -> void:
# A shield with a circular recovery arrow.
var arc := PackedVector2Array()
for i in range(10):
var a := lerpf(-PI * 0.2, PI * 1.35, float(i) / 9.0)
arc.append(center + Vector2(cos(a), sin(a)) * 11.0 * s)
NeonDraw.draw_glowing_path(self, arc, _active_color(), pulse, 0.45 * s, core_color)
var tip: Vector2 = arc[arc.size() - 1]
NeonDraw.draw_glowing_line(self, tip, tip + Vector2(6, -1) * s, _active_color(), pulse, 0.45 * s, core_color)
NeonDraw.draw_glowing_line(self, tip, tip + Vector2(1, 6) * s, _active_color(), pulse, 0.45 * s, core_color)
func _draw_upgrade_cargo(center: Vector2, pulse: float, s: float) -> void:
# Freight crate, with outward arrows suggesting expanded volume.
var box := 8.0 * s
NeonDraw.draw_glowing_polygon(self, PackedVector2Array([center + Vector2(-box, -box) , center + Vector2(box, -box), center + Vector2(box, box), center + Vector2(-box, box)]), _active_color(), pulse, core_color)
for side in [-1.0, 1.0]:
NeonDraw.draw_glowing_line(self, center + Vector2(side * 10, 0) * s, center + Vector2(side * 16, 0) * s, _active_color(), pulse, 0.38 * s, core_color)
func _draw_upgrade_engines(center: Vector2, pulse: float, s: float) -> void:
# Engine core with speed streaks.
NeonDraw.draw_glowing_polygon(self, PackedVector2Array([center + Vector2(-4, -8) * s, center + Vector2(7, -5) * s, center + Vector2(10, 0) * s, center + Vector2(7, 5) * s, center + Vector2(-4, 8) * s, center + Vector2(-8, 0) * s]), _active_color(), pulse, core_color)
for y in [-7.0, 0.0, 7.0]:
NeonDraw.draw_glowing_line(self, center + Vector2(-18, y) * s, center + Vector2(-9, y) * s, _active_color(), pulse, 0.4 * s, core_color)
func _draw_upgrade_unlock_shield(center: Vector2, pulse: float, s: float) -> void:
# A shield silhouette with a plus: unlock the whole vessel, not a stat.
NeonDraw.draw_glowing_polygon(self, PackedVector2Array([center + Vector2(0, -13) * s, center + Vector2(11, -7) * s, center + Vector2(8, 7) * s, center + Vector2(0, 13) * s, center + Vector2(-8, 7) * s, center + Vector2(-11, -7) * s]), _active_color(), pulse, core_color)
NeonDraw.draw_glowing_line(self, center + Vector2(-4, 0) * s, center + Vector2(4, 0) * s, _active_color(), pulse, 0.45 * s, core_color)
NeonDraw.draw_glowing_line(self, center + Vector2(0, -4) * s, center + Vector2(0, 4) * s, _active_color(), pulse, 0.45 * s, core_color)
func _draw_action_menu(center: Vector2, pulse: float, s: float) -> void:
# A small, intentionally neutral stack of choices. It marks a button that
# opens context actions rather than carrying out one particular action.
for y in [-8.0, 0.0, 8.0]:
NeonDraw.draw_glowing_line(self, center + Vector2(-10, y) * s, center + Vector2(10, y) * s, _active_color(), pulse, 0.42 * s, core_color)
NeonDraw.draw_glowing_polygon(self, PackedVector2Array([
center + Vector2(-15, y - 2) * s, center + Vector2(-11, y) * s,
center + Vector2(-15, y + 2) * s,
]), _active_color(), pulse, core_color)
func _draw_gas(center: Vector2, pulse: float, s: float) -> void:
# Three drifting bubbles: the visual language for gaseous resources.
for data in [[Vector2(-6,-3), 6.0], [Vector2(6,4), 8.0], [Vector2(4,-9), 4.0]]:
var ring := PackedVector2Array()
for i in range(10):
var a := TAU * float(i) / 10.0
ring.append(center + (data[0] + Vector2(cos(a), sin(a)) * data[1]) * s)
NeonDraw.draw_glowing_polygon(self, ring, _active_color(), pulse, core_color)
func _draw_build(center: Vector2, pulse: float, s: float) -> void:
# A plus inside a frame - "add a structure".
var r: float = 11.0 * s
var frame: PackedVector2Array = PackedVector2Array([
center + Vector2(-r, -r), center + Vector2(r, -r),
center + Vector2(r, r), center + Vector2(-r, r),
])
NeonDraw.draw_glowing_polygon(self, frame, _active_color(), pulse, core_color)
var arm: float = r * 0.55
NeonDraw.draw_glowing_line(self, center + Vector2(-arm, 0), center + Vector2(arm, 0), _active_color(), pulse, 0.4 * s, core_color)
NeonDraw.draw_glowing_line(self, center + Vector2(0, -arm), center + Vector2(0, arm), _active_color(), pulse, 0.4 * s, core_color)
func _draw_rotate(center: Vector2, pulse: float, s: float, direction: float) -> void:
# Three-quarter arc with an arrowhead on the leading end, mirrored for
# the counter-clockwise variant.
var r: float = 11.0 * s
var segments: int = 14
var sweep: float = TAU * 0.75
var start: float = -PI * 0.5
var arc: PackedVector2Array = PackedVector2Array()
for i in range(segments + 1):
var t: float = float(i) / segments
var a: float = start + sweep * t * direction
arc.append(center + Vector2(cos(a), sin(a)) * r)
for i in range(segments):
NeonDraw.draw_glowing_line(self, arc[i], arc[i + 1], _active_color(), pulse, 0.34 * s, core_color)
var tip: Vector2 = arc[arc.size() - 1]
var tangent: Vector2 = (tip - arc[arc.size() - 2]).normalized()
var normal: Vector2 = Vector2(-tangent.y, tangent.x)
var head: float = 5.0 * s
NeonDraw.draw_glowing_line(self, tip, tip - tangent * head + normal * head, _active_color(), pulse, 0.34 * s, core_color)
NeonDraw.draw_glowing_line(self, tip, tip - tangent * head - normal * head, _active_color(), pulse, 0.34 * s, core_color)
# --- building glyphs, each echoing the placed structure's silhouette ------
func _draw_mothership_icon(center: Vector2, pulse: float, s: float) -> void:
# Radial flagship: a reactor core with six swept talons around it, the
# same silhouette as the placed structure.
for i in range(6):
var base: float = (float(i) / 6.0) * TAU
var talon: PackedVector2Array = PackedVector2Array()
for step in [0.0, 0.5, 1.0]:
var a: float = base + 0.72 * pow(step, 1.3)
talon.append(center + Vector2(cos(a), sin(a)) * lerpf(7.0, 16.0, step) * s)
for step in [1.0, 0.5, 0.0]:
var a: float = base + 0.72 * pow(step, 1.3) - (0.34 * (1.0 - step) + 0.05)
talon.append(center + Vector2(cos(a), sin(a)) * lerpf(7.0, 16.0, step) * s)
NeonDraw.draw_glowing_polygon(self, talon, _active_color(), pulse, core_color)
for radius in [6.5, 3.0]:
var ring: PackedVector2Array = PackedVector2Array()
for i in range(6):
var a: float = (float(i) / 6.0) * TAU + PI / 6.0
ring.append(center + Vector2(cos(a), sin(a)) * radius * s)
NeonDraw.draw_glowing_polygon(self, ring, _active_color(), pulse, core_color)
func _draw_ship_lab_icon(center: Vector2, pulse: float, s: float) -> void:
# A vessel inside brackets: something being examined, not built.
NeonDraw.draw_glowing_polygon(self, PackedVector2Array([
center + Vector2(0, -9) * s, center + Vector2(5, 5) * s,
center + Vector2(0, 2) * s, center + Vector2(-5, 5) * s,
]), _active_color(), pulse, core_color)
for sx in [-1.0, 1.0]:
var x: float = sx * 11.0 * s
NeonDraw.draw_glowing_line(self, center + Vector2(x, -11 * s), center + Vector2(x, 11 * s),
_active_color(), pulse, 0.35 * s, core_color)
NeonDraw.draw_glowing_line(self, center + Vector2(x, -11 * s), center + Vector2(x - sx * 4.0 * s, -11 * s),
_active_color(), pulse, 0.35 * s, core_color)
NeonDraw.draw_glowing_line(self, center + Vector2(x, 11 * s), center + Vector2(x - sx * 4.0 * s, 11 * s),
_active_color(), pulse, 0.35 * s, core_color)
func _draw_transport_hub_icon(center: Vector2, pulse: float, s: float) -> void:
# A ring of docking cradles with a freight box in the middle: reads as
# "things are stationed here and go out from here", which is what the hub
# does, and shares no silhouette with the crafter's open cradle.
var ring_r: float = 11.0 * s
var ring: PackedVector2Array = PackedVector2Array()
for i in range(8):
var a: float = (float(i) / 8.0) * TAU + PI / 8.0
ring.append(center + Vector2(cos(a), sin(a)) * ring_r)
NeonDraw.draw_glowing_polygon(self, ring, _active_color(), pulse, core_color)
var box: float = 4.2 * s
NeonDraw.draw_glowing_polygon(self, PackedVector2Array([
center + Vector2(-box, -box), center + Vector2(box, -box),
center + Vector2(box, box), center + Vector2(-box, box),
]), _active_color(), pulse, core_color)
# Three stubby berths, so the ring reads as occupied rather than as a
# plain octagon.
for i in range(3):
var a: float = (float(i) / 3.0) * TAU - PI / 2.0
var dir: Vector2 = Vector2(cos(a), sin(a))
NeonDraw.draw_glowing_line(self, center + dir * (box * 1.5),
center + dir * (ring_r - 1.5 * s), _active_color(), pulse, 0.35 * s, core_color)
func _draw_crafter_icon(center: Vector2, pulse: float, s: float) -> void:
# Reactor core, truss spine, and an open cradle holding a hull.
var core_centre: Vector2 = center + Vector2(-11, 0) * s
var core: PackedVector2Array = PackedVector2Array()
for i in range(6):
var a: float = (float(i) / 6.0) * TAU + PI / 6.0
core.append(core_centre + Vector2(cos(a), sin(a)) * 5.0 * s)
NeonDraw.draw_glowing_polygon(self, core, _active_color(), pulse, core_color)
NeonDraw.draw_glowing_line(self, center + Vector2(-6, 0) * s,
center + Vector2(-2, 0) * s, _active_color(), pulse, 0.35 * s, core_color)
var bay: Vector2 = center + Vector2(6, 0) * s
var cradle: PackedVector2Array = PackedVector2Array()
for i in range(13):
var a: float = lerpf(-0.25 * PI, 1.25 * PI, float(i) / 12.0)
cradle.append(bay + Vector2(cos(a), sin(a)) * 10.0 * s)
NeonDraw.draw_glowing_path(self, cradle, _active_color(), pulse, 0.4 * s, core_color)
NeonDraw.draw_glowing_polygon(self, PackedVector2Array([
bay + Vector2(0, -6) * s, bay + Vector2(-5, 4) * s, bay + Vector2(5, 4) * s,
]), _active_color(), pulse, core_color)
func _draw_command_icon(center: Vector2, pulse: float, s: float) -> void:
# Hex plotting rim with spokes to a diamond hub, echoing the placed
# structure's silhouette: half the ports carry a formation token.
var hex_r: float = 11.0 * s
var hub_r: float = 4.0 * s
var hex: PackedVector2Array = PackedVector2Array()
for i in range(6):
var a: float = (float(i) / 6.0) * TAU + PI / 6.0
hex.append(center + Vector2(cos(a), sin(a)) * hex_r)
NeonDraw.draw_glowing_polygon(self, hex, _active_color(), pulse, core_color)
for i in range(6):
var a: float = (float(i) / 6.0) * TAU + PI / 6.0
var dir: Vector2 = Vector2(cos(a), sin(a))
NeonDraw.draw_glowing_line(self, center + dir * hub_r, center + dir * hex_r, _active_color(), pulse, 0.32 * s, core_color)
if i % 2 == 0:
var tip: Vector2 = center + dir * hex_r
var t: float = 2.6 * s
NeonDraw.draw_glowing_polygon(self, PackedVector2Array([
tip + Vector2(0, -t), tip + Vector2(t, 0), tip + Vector2(0, t), tip + Vector2(-t, 0),
]), _active_color(), pulse, core_color)
NeonDraw.draw_glowing_polygon(self, PackedVector2Array([
center + Vector2(0, -hub_r), center + Vector2(hub_r, 0),
center + Vector2(0, hub_r), center + Vector2(-hub_r, 0),
]), _active_color(), pulse, core_color)
func _draw_extractor_icon(center: Vector2, pulse: float, s: float) -> void:
# A derrick standing on a planet's limb, with ore lifting off it - the
# one building that only works over a planet, so the planet is the point.
var limb: PackedVector2Array = PackedVector2Array()
for i in range(11):
var a: float = lerpf(-0.82 * PI, -0.18 * PI, float(i) / 10.0)
limb.append(center + (Vector2(0, 22) + Vector2(cos(a), sin(a)) * 17.0) * s)
NeonDraw.draw_glowing_path(self, limb, _active_color(), pulse, 0.45 * s, core_color)
NeonDraw.draw_glowing_line(self, center + Vector2(-6, 5) * s, center + Vector2(0, -9) * s, _active_color(), pulse, 0.4 * s, core_color)
NeonDraw.draw_glowing_line(self, center + Vector2(6, 5) * s, center + Vector2(0, -9) * s, _active_color(), pulse, 0.4 * s, core_color)
NeonDraw.draw_glowing_line(self, center + Vector2(-3.5, -1) * s, center + Vector2(3.5, -1) * s, _active_color(), pulse, 0.35 * s, core_color)
# Shaft driven down through the limb - without it the derrick reads as a
# tower standing on a hill rather than as something mining the planet.
NeonDraw.draw_glowing_line(self, center + Vector2(0, -1) * s, center + Vector2(0, 14) * s, _active_color(), pulse, 0.3 * s, core_color)
var ore_centre: Vector2 = center + Vector2(0, -15) * s
var ore: PackedVector2Array = PackedVector2Array()
for i in range(6):
var a: float = (float(i) / 6.0) * TAU + PI / 6.0
ore.append(ore_centre + Vector2(cos(a), sin(a)) * 4.0 * s)
NeonDraw.draw_glowing_polygon(self, ore, _active_color(), pulse, core_color)
func _draw_map(center: Vector2, pulse: float, s: float) -> void:
var w: float = 11.0 * s
var h: float = 9.0 * s
var outline: PackedVector2Array = PackedVector2Array([
center + Vector2(-w, -h), center + Vector2(w, -h * 0.7),
center + Vector2(w, h), center + Vector2(-w, h * 0.7),
])
NeonDraw.draw_glowing_polygon(self, outline, _active_color(), pulse, core_color)
NeonDraw.draw_glowing_line(self, center + Vector2(-w * 0.34, -h * 0.9), center + Vector2(-w * 0.34, h * 0.77), _active_color(), pulse, 0.4 * s, core_color)
NeonDraw.draw_glowing_line(self, center + Vector2(w * 0.34, -h * 0.77), center + Vector2(w * 0.34, h * 0.9), _active_color(), pulse, 0.4 * s, core_color)
Reference in a new issue View git blame Copy permalink