A day of deep technical work across four sessions. The day started with adding mothership colour variants and performance optimisation, then pivoted to a major ship architecture overhaul that spanned three iterations and three sessions, ending with the correct dynamic per-variant scaling solution that accounts for the 8:1 range in ship texture sizes.

14 new mothership sprites were added alongside the original, giving 15 total colour variants. Each time a mothership spawns it picks one at random, so no two waves look the same. The three source sizes (230×230, 370×385, 1024×1024) would render at wildly different sizes with a fixed scale, so the same dynamic scaling pattern used across the codebase was applied.

const DISPLAY_SIZE: float = 150.0  # target longest-side size in px

var tex: Texture2D = load(TEXTURE_PATHS[randi() % TEXTURE_PATHS.size()])
if tex:
    _sprite.texture = tex
    var longest: float = maxf(tex.get_width(), tex.get_height())
    var s: float = DISPLAY_SIZE / longest if longest > 0.0 else 1.0
    _sprite.scale = Vector2(s, s)

To adjust mothership size: change DISPLAY_SIZE in EnemyMothership.gd. To add variants: append the path to TEXTURE_PATHS.

A full audit of the gameplay-hot scripts was run. Five issues identified and fixed, ranked by impact:

1. Cache GameManager Reference in Player.gd

_physics_process called get_node_or_null("/root/GameManager") on every frame (60+ times/sec). A _gm: Node instance var is now populated once in _ready() and reused everywhere. All four separate get_node* calls replaced.

2. Shared Texture Cache in EnemyBullet.gd

Every bullet called load(path) for all 6 animation frames in _ready(). Two static var arrays (_small_tex_cache and _big_tex_cache) are now shared across all instances, loaded only once on the first instantiation.

3. Preloaded Font in GameScene.gd

Both _show_wave_warning() and _show_sector_banner() called load(neuropol.ttf) each time they ran. Replaced with a class-level const _NEUROPOL: FontFile = preload(...), at zero runtime cost.

4. Cached Edge Spawn Points in GameScene.gd

_fixed_edge_point() allocated a typed Array[Vector2] with 8 entries on every call (36+ per wave). The 8 spawn points are now computed once in _ready() and stored in _edge_points. The function is now a single-line array index.

5. Crystal Double-Collect Guard

A _collected: bool = false flag was added. If two physics frames fire collision callbacks simultaneously (possible at high frame-rate peaks), the second call returns immediately before touching the GameManager. Signal disconnect remains as secondary safety.

Remaining Deferred Audit Items

The root problem: it was impossible to visually edit player ship collision shapes and gun barrel positions in the Godot editor because ship sprites load at runtime from GameManager, so the editor showed a blank Sprite2D. The session went through three iterations to arrive at a clean, warning-free solution.

Final Architecture: Two-Layer Split

Layer 1: 18 Ship Scenes (pure visuals, no warnings): Located in scenes/entities/ships/. Each is a Node2D with: Sprite2D (texture baked in), ThrusterCenter/Left/Right (visible=false), GunBarrel/GunBarrelLeft/GunBarrelRight Marker2Ds.

Layer 2: Player.tscn (physics shell): Contains only ThrustAudio, ShipBody placeholder Node2D (ship scene instanced at runtime), and 18 Col_* CollisionPolygon2D nodes as direct CharacterBody2D children.

Player.gd: Key Changes

• @tool editor preview:@export_range(-1,7) var editor_ship_series and @export_range(0,2) var editor_ship_level. Changing either slider shows the correct ship sprite in the editor without affecting runtime.
• SHIP_SCENE_PATHS: Changed from flat Array[String] to 2D array indexed [series][level].
• _apply_ship_setup(): Loads SHIP_SCENE_PATHS[series][level] directly. Old get_ship_texture() call removed; the correct sprite is baked into each variant scene.
• Ship node refs: Changed from @onready to plain vars populated after instantiation, with null guards throughout.

Editor Workflows

Gun barrels and thrusters: Open the relevant ship scene (e.g. Ship_CX16_X2.tscn). Sprite is already visible. Drag marker nodes to the correct positions. Save.

Collision polygons: Open Player.tscn. Set editor_ship_series and editor_ship_level in Inspector and the sprite appears live. Select the matching Col_* node and drag vertices. Set editor_ship_series back to -1 when done.

Bug 1 (Session 6): Ships Rendering 2× Too Large

The original Player.tscn had scale = Vector2(0.5, 0.5) on its Sprite2D. New ship scenes defaulted to Vector2(1,1), so ships appeared at twice the intended size in-game.

Session 6 Fix: Applied scale = Vector2(0.5, 0.5) once to the ShipBodyNode2D in Player.tscn, which fixes all 18 scenes simultaneously. The @tool preview sprite also inherits the scale so collision polygon editing shows the ship at the correct in-game size.

Bug 2 (Session 6): Thrusters Always Visible

Some ship scenes had thruster nodes temporarily made visible during editor positioning then saved without re-hiding. Godot 4 never writes visible = true (it’s the default), so visible = false was missing from those files.

Fixed by adding visible = false to: Ship_CX16_X1.tscn (ThrusterCenter), Ship_CX16_X2.tscn (ThrusterLeft, ThrusterRight), Ship_WO84_X3.tscn (all three thrusters).

Bug 3 (Session 7): Fixed Scale Fails for Large-Texture Ships

The Session 6 fix (scale = 0.5 on ShipBody) works for CX16, DKO, and WO84 (all 160×160 px textures), but CP2 is 609px, PTM X2 is 1178px, Viper is 957px, BGS ships are 1057px, so at 0.5 scale these would render 4–7× too large.

The fixed scale was replaced with a runtime calculation: each ship is scaled so its longest axis always renders at exactly 80 px on screen, regardless of original texture dimensions. Same pattern used in Crystal.gd and EnemyMothership.gd.

const SHIP_DISPLAY_SIZE: float = 80.0

# Inside _apply_ship_setup(), after caching sprite ref:
if sprite and sprite.texture:
    var longest: float = maxf(float(sprite.texture.get_width()),
                              float(sprite.texture.get_height()))
    if longest > 0.0:
        var s: float = SHIP_DISPLAY_SIZE / longest
        _ship_body.scale = Vector2(s, s)

The same calculation is applied in _editor_update_preview() so the @tool viewport preview also scales correctly, so collision polygon vertices sit on the ship at the exact size they will appear in-game.

Ship Tuning Status After All Sessions