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 0fb8f9300b Twin-stick combat: aim and fire with a second stick, MOBA-style ability ring 
The fleet's guns picked their own targets and fired on their own, so combat
happened whether or not the player did anything - there was nothing to aim and
nothing to decide, and the right half of the screen held nothing at all.
Firing is now an action. VesselWeaponComponent no longer seeks a target; it
shoots along a heading, and the only thing that supplies one is the new
right-hand stick via FireStickController. A fleet arriving from another scene
starts with its guns silent, which is the correct resting state.

A subtle dashed guide runs from the fleet along the aimed heading while the
stick is held, out to the guns' OWN range - read from a weapon that is
actually aboard, so the line can never promise reach the fleet does not have.

Layout: the two sticks take the bottom corners, the pivot pair is centred
between them at the bottom edge, and the laser and gas bomb sit on an arc up
and left of the fire stick where a thumb already is. Those four are now round
- IconButton grew a round_frame mode, and the in-world action controls use it
while panel and menu buttons stay square, so the two kinds of button read as
different kinds of thing.

Worth recording, because it cost a screenshot to find: a script-declared
property set BEFORE the `script = ExtResource(...)` line in a .tscn is
silently dropped. Godot's parser has no idea the property exists yet. The
round frames were all correctly set in both scenes and none of them applied.

Also fixed researtch_lab_garrison.tres, which was authored under the void
profile - that is the black hole surface, so a lab garrison was spawning on
black holes.

Suite 110/110. test_enemy_combat's whole premise was auto-fire; it now holds
the real stick toward the enemy rather than poking weapon components, so it
exercises the path the player uses. test_fire_stick is new and covers the
change itself: an idle stick leaves a target parked well inside range
untouched, which is precisely what the old gun would never have done.

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

729 lines
33 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: a warped ring reads as a space-time distortion rather than a hull.
DISTORDER_VESSEL,
}
# 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.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:
# A ring whose radius wobbles with angle instead of a plain circle -
# reads as warped space rather than a hull silhouette.
var points: PackedVector2Array = PackedVector2Array()
for i in range(17):
var a: float = TAU * float(i) / 16.0
var r: float = (10.0 + 3.0 * sin(a * 3.0)) * s
points.append(center + Vector2(cos(a), sin(a)) * r)
NeonDraw.draw_glowing_path(self, points, _active_color(), pulse, 0.8, core_color)
NeonDraw.draw_glowing_circle(self, center, 2.5 * s, _active_color(), pulse, 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_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