// Defender — Classic 1981 Williams side-scrolling shooter.
// Protect humanoids from alien landers across a scrolling terrain world.
import { BaseScene, W, H } from './BaseScene.js';
/* ------------------------------------------------------------------ */
/*  Constants                                                          */
/* ------------------------------------------------------------------ */
let SCALE = Math.min(W / 1920, H / 1080);
let PX = Math.max(3, Math.round(4 * SCALE));
const WORLD_W_SCREENS = 6;
let WORLD_W = W * WORLD_W_SCREENS;
const PLAYER_THRUST = 1400;
const PLAYER_MAX_VX = 900;
const PLAYER_VY_SPEED = 500;
const PLAYER_FRICTION = 0.985; // high inertia — ship coasts like original
const BULLET_SPEED = 1200;
const MAX_BULLETS = 8;
const INVINCIBLE_TIME = 2000;
const RESPAWN_DELAY = 800;
const EXTRA_LIFE_SCORE = 10000;
const TERRAIN_SAMPLE = 20; // pixels between terrain height samples
const TERRAIN_MIN_Y = 0.65; // fraction of H for highest peak
const TERRAIN_MAX_Y = 0.88; // fraction of H for lowest valley
const RADAR_H = 50; // taller for visibility
const RADAR_Y = 105; // well below HUD bar (~91px tall)
const ENEMY_BULLET_SPEED = 400;
const RESPAWN_SAFE_RADIUS = 300;
const RESPAWN_SAFE_RADIUS_BAITER = 600;
const RESPAWN_PUSH_OFFSET = 150;
/* ------------------------------------------------------------------ */
/*  Pixel Art Data — dimensions matched to original ROM sprite list    */
/*  Reference: https://www.seanriddle.com/defendersprites.txt          */
/* ------------------------------------------------------------------ */
// Ship: ROM = 16×6 px (8 bytes × 6 rows)
// From MAME screenshots: sleek profile facing right
// - Tapers at top and bottom (rows 0,5 are narrow)
// - Widest at center rows (1-4)
// - Magenta engine block at rear left
// - White body, cyan nose tip at right
// - Green exhaust pixels at bottom-left
const SHIP_PIXELS = [
    // Row 0 — top taper (narrow, no engine visible)
    [6, 0, 0xffffff], [7, 0, 0xffffff], [8, 0, 0xffffff], [9, 0, 0xffffff],
    [10, 0, 0xffffff], [11, 0, 0xffffff], [12, 0, 0xffffff], [13, 0, 0xffffff],
    // Row 1 — wider, engine appears
    [2, 1, 0xff00ff], [3, 1, 0xff44ff],
    [4, 1, 0xffffff], [5, 1, 0xffffff], [6, 1, 0xffffff], [7, 1, 0xffffff],
    [8, 1, 0xffffff], [9, 1, 0xffffff], [10, 1, 0xffffff], [11, 1, 0xffffff],
    [12, 1, 0xffffff], [13, 1, 0xffffff], [14, 1, 0xffffff],
    // Row 2 — full width (widest), engine + body + nose tip
    [0, 2, 0xff00ff], [1, 2, 0xff00ff], [2, 2, 0xff00ff], [3, 2, 0xff44ff],
    [4, 2, 0xffffff], [5, 2, 0xffffff], [6, 2, 0xffffff], [7, 2, 0xffffff],
    [8, 2, 0xffffff], [9, 2, 0xffffff], [10, 2, 0xffffff], [11, 2, 0xffffff],
    [12, 2, 0xffffff], [13, 2, 0xffffff], [14, 2, 0xffffff], [15, 2, 0x00ccff],
    // Row 3 — full width (widest), engine + body + nose tip
    [0, 3, 0xff00ff], [1, 3, 0xff00ff], [2, 3, 0xff00ff], [3, 3, 0xff44ff],
    [4, 3, 0xffffff], [5, 3, 0xffffff], [6, 3, 0xffffff], [7, 3, 0xffffff],
    [8, 3, 0xffffff], [9, 3, 0xffffff], [10, 3, 0xffffff], [11, 3, 0xffffff],
    [12, 3, 0xffffff], [13, 3, 0xffffff], [14, 3, 0xffffff], [15, 3, 0x00ccff],
    // Row 4 — wider, engine appears
    [2, 4, 0xff00ff], [3, 4, 0xff44ff],
    [4, 4, 0xffffff], [5, 4, 0xffffff], [6, 4, 0xffffff], [7, 4, 0xffffff],
    [8, 4, 0xffffff], [9, 4, 0xffffff], [10, 4, 0xffffff], [11, 4, 0xffffff],
    [12, 4, 0xffffff], [13, 4, 0xffffff], [14, 4, 0xffffff],
    // Row 5 — bottom taper + green exhaust trail
    [4, 5, 0xffffff], [5, 5, 0xffffff], [6, 5, 0xffffff], [7, 5, 0xffffff],
    [8, 5, 0xffffff], [9, 5, 0xffffff], [10, 5, 0xffffff], [11, 5, 0xffffff],
    [0, 5, 0x00ff00], [1, 5, 0x00ff00],
];
// Lander: ROM = 10×8 px (5 bytes × 8 rows)
// H-shaped: diamond body with grabber legs below
const LANDER_PIXELS = [
    // Row 0 — top center
    [4, 0, 0x00ff00], [5, 0, 0x00ff00],
    // Row 1 — upper diamond
    [3, 1, 0x00ff00], [4, 1, 0xffff00], [5, 1, 0xffff00], [6, 1, 0x00ff00],
    // Row 2 — widest body
    [2, 2, 0x00ff00], [3, 2, 0x00ff00], [4, 2, 0x00ff00], [5, 2, 0x00ff00], [6, 2, 0x00ff00], [7, 2, 0x00ff00],
    // Row 3 — full width with side detail
    [1, 3, 0x00ff00], [2, 3, 0x00ff00], [3, 3, 0xffff00], [4, 3, 0x00ff00], [5, 3, 0x00ff00], [6, 3, 0xffff00], [7, 3, 0x00ff00], [8, 3, 0x00ff00],
    // Row 4 — lower body
    [2, 4, 0x00ff00], [3, 4, 0x00ff00], [4, 4, 0x00ff00], [5, 4, 0x00ff00], [6, 4, 0x00ff00], [7, 4, 0x00ff00],
    // Row 5 — narrowing
    [3, 5, 0x00ff00], [4, 5, 0x00ff00], [5, 5, 0x00ff00], [6, 5, 0x00ff00],
    // Row 6 — legs
    [1, 6, 0xffff00], [2, 6, 0xffff00], [7, 6, 0xffff00], [8, 6, 0xffff00],
    // Row 7 — leg tips
    [0, 7, 0xffff00], [1, 7, 0xffff00], [8, 7, 0xffff00], [9, 7, 0xffff00],
];
// Mutant: ROM = 10×8 px (5 bytes × 8 rows)
// Composite of lander + humanoid overlay, blobby organic look
const MUTANT_PIXELS = [
    // Row 0
    [3, 0, 0xff00ff], [4, 0, 0xff00ff], [5, 0, 0xff00ff], [6, 0, 0xff00ff],
    // Row 1
    [2, 1, 0xff00ff], [3, 1, 0xcc00cc], [4, 1, 0xcc00cc], [5, 1, 0xcc00cc], [6, 1, 0xcc00cc], [7, 1, 0xff00ff],
    // Row 2 — yellow-green eyes
    [1, 2, 0xff00ff], [2, 2, 0xff00ff], [3, 2, 0xaaff00], [4, 2, 0xff00ff], [5, 2, 0xff00ff], [6, 2, 0xaaff00], [7, 2, 0xff00ff], [8, 2, 0xff00ff],
    // Row 3 — widest
    [0, 3, 0xff00ff], [1, 3, 0xff00ff], [2, 3, 0xff00ff], [3, 3, 0xff00ff], [4, 3, 0xff00ff], [5, 3, 0xff00ff], [6, 3, 0xff00ff], [7, 3, 0xff00ff], [8, 3, 0xff00ff], [9, 3, 0xff00ff],
    // Row 4 — widest
    [0, 4, 0xff00ff], [1, 4, 0xff00ff], [2, 4, 0xff00ff], [3, 4, 0xff00ff], [4, 4, 0xff00ff], [5, 4, 0xff00ff], [6, 4, 0xff00ff], [7, 4, 0xff00ff], [8, 4, 0xff00ff], [9, 4, 0xff00ff],
    // Row 5
    [1, 5, 0xcc00cc], [2, 5, 0xff00ff], [3, 5, 0xff00ff], [4, 5, 0xff00ff], [5, 5, 0xff00ff], [6, 5, 0xff00ff], [7, 5, 0xff00ff], [8, 5, 0xcc00cc],
    // Row 6
    [2, 6, 0xcc00cc], [3, 6, 0xff00ff], [4, 6, 0xff00ff], [5, 6, 0xff00ff], [6, 6, 0xff00ff], [7, 6, 0xcc00cc],
    // Row 7
    [3, 7, 0xcc00cc], [4, 7, 0xcc00cc], [5, 7, 0xcc00cc], [6, 7, 0xcc00cc],
];
// Humanoid: ROM = 4×8 px (2 bytes × 8 rows)
// Multi-colored: green upper body, magenta/pink lower half
const HUMANOID_PIXELS = [
    // Row 0 — head (green)
    [1, 0, 0x00ff00], [2, 0, 0x00ff00],
    // Row 1 — neck (green)
    [1, 1, 0x00ff00], [2, 1, 0x00ff00],
    // Row 2 — arms + torso (green)
    [0, 2, 0x00ff00], [1, 2, 0x00ff00], [2, 2, 0x00ff00], [3, 2, 0x00ff00],
    // Row 3 — torso (green)
    [1, 3, 0x00ff00], [2, 3, 0x00ff00],
    // Row 4 — waist (magenta transition)
    [1, 4, 0xff00ff], [2, 4, 0xff00ff],
    // Row 5 — hips (magenta)
    [1, 5, 0xff00ff], [2, 5, 0xff00ff],
    // Row 6 — legs (magenta)
    [0, 6, 0xff00ff], [3, 6, 0xff00ff],
    // Row 7 — feet (magenta)
    [0, 7, 0xff00ff], [3, 7, 0xff00ff],
];
// Bomber: ROM = 8×8 px (4 bytes × 8 rows)
// Compact square block with segmented look, NOT a wide rectangle
const BOMBER_PIXELS = [
    // Row 0 — top edge
    [1, 0, 0xffff00], [2, 0, 0xffff00], [3, 0, 0xffff00], [4, 0, 0xffff00], [5, 0, 0xffff00], [6, 0, 0xffff00],
    // Row 1 — top stripe with detail
    [0, 1, 0xffff00], [1, 1, 0xff4400], [2, 1, 0xffff00], [3, 1, 0xff4400], [4, 1, 0xffff00], [5, 1, 0xff4400], [6, 1, 0xffff00], [7, 1, 0xffff00],
    // Row 2 — solid
    [0, 2, 0xffff00], [1, 2, 0xffff00], [2, 2, 0xffff00], [3, 2, 0xffff00], [4, 2, 0xffff00], [5, 2, 0xffff00], [6, 2, 0xffff00], [7, 2, 0xffff00],
    // Row 3 — center detail
    [0, 3, 0xffff00], [1, 3, 0xffff00], [2, 3, 0xff4400], [3, 3, 0xffff00], [4, 3, 0xffff00], [5, 3, 0xff4400], [6, 3, 0xffff00], [7, 3, 0xffff00],
    // Row 4 — center detail
    [0, 4, 0xffff00], [1, 4, 0xffff00], [2, 4, 0xff4400], [3, 4, 0xffff00], [4, 4, 0xffff00], [5, 4, 0xff4400], [6, 4, 0xffff00], [7, 4, 0xffff00],
    // Row 5 — solid
    [0, 5, 0xffff00], [1, 5, 0xffff00], [2, 5, 0xffff00], [3, 5, 0xffff00], [4, 5, 0xffff00], [5, 5, 0xffff00], [6, 5, 0xffff00], [7, 5, 0xffff00],
    // Row 6 — bottom stripe
    [0, 6, 0xffff00], [1, 6, 0xff4400], [2, 6, 0xffff00], [3, 6, 0xff4400], [4, 6, 0xffff00], [5, 6, 0xff4400], [6, 6, 0xffff00], [7, 6, 0xffff00],
    // Row 7 — bottom edge
    [1, 7, 0xffff00], [2, 7, 0xffff00], [3, 7, 0xffff00], [4, 7, 0xffff00], [5, 7, 0xffff00], [6, 7, 0xffff00],
];
// Baiter: ROM = 12×4 px (6 bytes × 4 rows)
// Thin horseshoe/C shape — narrow and aggressive
const BAITER_PIXELS = [
    // Row 0 — top bar
    [0, 0, 0x00ff44], [1, 0, 0x00ff44], [2, 0, 0x00ff44], [3, 0, 0x00ff44], [4, 0, 0x00ff44], [5, 0, 0x00ff44], [6, 0, 0x00ff44], [7, 0, 0x00ff44], [8, 0, 0x00ff44], [9, 0, 0x00ff44], [10, 0, 0x00ff44], [11, 0, 0x00ff44],
    // Row 1 — gap in middle
    [0, 1, 0x00ff44], [1, 1, 0x00ff44], [10, 1, 0x00ff44], [11, 1, 0x00ff44],
    // Row 2 — gap in middle
    [0, 2, 0x00ff44], [1, 2, 0x00ff44], [10, 2, 0x00ff44], [11, 2, 0x00ff44],
    // Row 3 — bottom bar
    [0, 3, 0x00ff44], [1, 3, 0x00ff44], [2, 3, 0x00ff44], [3, 3, 0x00ff44], [4, 3, 0x00ff44], [5, 3, 0x00ff44], [6, 3, 0x00ff44], [7, 3, 0x00ff44], [8, 3, 0x00ff44], [9, 3, 0x00ff44], [10, 3, 0x00ff44], [11, 3, 0x00ff44],
];
// Pod: ROM = 8×8 px (4 bytes × 8 rows)
// Compact oval/circle shape, not a large egg
const POD_PIXELS = [
    // Row 0
    [2, 0, 0xcc00cc], [3, 0, 0xcc00cc], [4, 0, 0xcc00cc], [5, 0, 0xcc00cc],
    // Row 1
    [1, 1, 0xcc00cc], [2, 1, 0xff00ff], [3, 1, 0xff00ff], [4, 1, 0xff00ff], [5, 1, 0xff00ff], [6, 1, 0xcc00cc],
    // Row 2
    [0, 2, 0xcc00cc], [1, 2, 0xff00ff], [2, 2, 0xff00ff], [3, 2, 0xff44ff], [4, 2, 0xff44ff], [5, 2, 0xff00ff], [6, 2, 0xff00ff], [7, 2, 0xcc00cc],
    // Row 3
    [0, 3, 0xcc00cc], [1, 3, 0xff00ff], [2, 3, 0xff44ff], [3, 3, 0xff00ff], [4, 3, 0xff00ff], [5, 3, 0xff44ff], [6, 3, 0xff00ff], [7, 3, 0xcc00cc],
    // Row 4
    [0, 4, 0xcc00cc], [1, 4, 0xff00ff], [2, 4, 0xff44ff], [3, 4, 0xff00ff], [4, 4, 0xff00ff], [5, 4, 0xff44ff], [6, 4, 0xff00ff], [7, 4, 0xcc00cc],
    // Row 5
    [0, 5, 0xcc00cc], [1, 5, 0xff00ff], [2, 5, 0xff00ff], [3, 5, 0xff44ff], [4, 5, 0xff44ff], [5, 5, 0xff00ff], [6, 5, 0xff00ff], [7, 5, 0xcc00cc],
    // Row 6
    [1, 6, 0xcc00cc], [2, 6, 0xff00ff], [3, 6, 0xff00ff], [4, 6, 0xff00ff], [5, 6, 0xff00ff], [6, 6, 0xcc00cc],
    // Row 7
    [2, 7, 0xcc00cc], [3, 7, 0xcc00cc], [4, 7, 0xcc00cc], [5, 7, 0xcc00cc],
];
// Swarmer: ROM = 6×4 px (3 bytes × 4 rows)
// Wider than tall cross/star shape
const SWARMER_PIXELS = [
    // Row 0
    [2, 0, 0xffff00], [3, 0, 0xffff00],
    // Row 1 — full width
    [0, 1, 0xffff00], [1, 1, 0xffff00], [2, 1, 0xffff00], [3, 1, 0xffff00], [4, 1, 0xffff00], [5, 1, 0xffff00],
    // Row 2 — full width
    [0, 2, 0xffff00], [1, 2, 0xffff00], [2, 2, 0xffff00], [3, 2, 0xffff00], [4, 2, 0xffff00], [5, 2, 0xffff00],
    // Row 3
    [2, 3, 0xffff00], [3, 3, 0xffff00],
];
/* ------------------------------------------------------------------ */
/*  Scene                                                              */
/* ------------------------------------------------------------------ */
export class PlanetGuardianScene extends BaseScene {
    /* Player state */
    playerX = 0;
    playerY = 0;
    playerVx = 0;
    playerVy = 0;
    facingRight = true;
    shipAlive = true;
    invincibleTimer = 0;
    respawnTimer = 0;
    smartBombs = 3;
    carriedHumanoid = -1; // index of humanoid being carried, -1 = none
    nextExtraLife = EXTRA_LIFE_SCORE;
    /* Game objects */
    enemies = [];
    humanoids = [];
    bullets = [];
    mines = [];
    stars = [];
    /* Terrain */
    terrainHeights = [];
    planetDestroyed = false;
    /* Camera / scroll */
    cameraX = 0;
    spriteScale = 1; // calculated in create()
    /* Game state */
    wave = 0;
    gameOver = false;
    waveTimer = 0; // time elapsed in current wave (for baiter spawning)
    waveDelay = 0;
    baiterSpawned = false;
    /* Graphics objects */
    gameGfx; // main game graphics
    radarGfx; // radar minimap
    terrainGfx; // terrain graphics
    hudExtraGfx; // smart bomb display
    shipSprite; // player ship sprite
    /* Input */
    cursors;
    fireKey;
    bombKey;
    fireWasDown = false;
    bombWasDown = false;
    fireCooldown = 0; // rapid-fire rate limiter
    thrustSoundPlaying = false;
    constructor() { super('defender'); }
    get displayName() { return 'Planet Guardian'; }
    getDescription() {
        return 'Defend humanoids from alien landers. Rescue the falling and destroy all enemies!';
    }
    getControls() {
        return [
            { key: '← →', action: 'Thrust / Reverse' },
            { key: '↑ ↓', action: 'Move Up / Down' },
            { key: 'SPACE', action: 'Fire Laser (hold)' },
            { key: 'Z', action: 'Smart Bomb' },
        ];
    }
    /* ================================================================
       LIFECYCLE
       ================================================================ */
    preload() {
        // Load sprite PNGs (generated pixel art, CC0-compatible original designs)
        this.load.image('def-ship-r', '../assets/defender/ship.png');
        this.load.image('def-ship-l', '../assets/defender/ship_left.png');
        this.load.image('def-lander', '../assets/defender/lander.png');
        this.load.image('def-mutant', '../assets/defender/mutant.png');
        this.load.image('def-humanoid', '../assets/defender/humanoid.png');
        this.load.image('def-bomber', '../assets/defender/bomber.png');
        this.load.image('def-pod', '../assets/defender/pod.png');
        this.load.image('def-swarmer', '../assets/defender/swarmer.png');
        this.load.image('def-baiter', '../assets/defender/baiter.png');
        // Sounds from OpenDefender
        this.load.audio('snd_laser', '../assets/defender/sounds/sound_laser.wav');
        this.load.audio('snd_enemydead', '../assets/defender/sounds/sound_enemydead.wav');
        this.load.audio('snd_explode', '../assets/defender/sounds/sound_explode.wav');
        this.load.audio('snd_playerdead', '../assets/defender/sounds/sound_playerdead.wav');
        this.load.audio('snd_bonus', '../assets/defender/sounds/sound_bonus.wav');
        this.load.audio('snd_humanoiddead', '../assets/defender/sounds/sound_humanoiddead.wav');
        this.load.audio('snd_start', '../assets/defender/sounds/sound_start.wav');
        this.load.audio('snd_thrust', '../assets/defender/sounds/sound_thurst.wav');
        this.load.audio('snd_warning', '../assets/defender/sounds/sound_warning.wav');
        this.load.audio('snd_baiterwarning', '../assets/defender/sounds/sound_baiterwarning.wav');
        this.load.audio('snd_player1up', '../assets/defender/sounds/sound_player1up.wav');
        this.load.audio('snd_enemyshoot', '../assets/defender/sounds/sound_enemyshoot.wav');
        this.load.audio('snd_enemyshoot2', '../assets/defender/sounds/sound_enemyshoot2.wav');
    }
    create() {
        this.initBase();
        // Switch Planet Guardian textures to linear filtering for smoother scaling
        const defKeys = ['def-ship-r', 'def-ship-l', 'def-lander', 'def-mutant',
            'def-humanoid', 'def-bomber', 'def-pod', 'def-swarmer', 'def-baiter'];
        for (const k of defKeys) {
            const tex = this.textures.get(k);
            if (tex && tex.source[0]?.glTexture) {
                tex.setFilter(Phaser.Textures.FilterMode.LINEAR);
            }
        }
        // Recalculate screen-dependent constants
        SCALE = Math.min(W / 1920, H / 1080);
        PX = Math.max(3, Math.round(4 * SCALE));
        WORLD_W = W * WORLD_W_SCREENS;
        // Reset state
        this.score = 0;
        this.lives = 3;
        this.wave = 0;
        this.gameOver = false;
        this.planetDestroyed = false;
        this.smartBombs = 3;
        this.carriedHumanoid = -1;
        this.nextExtraLife = EXTRA_LIFE_SCORE;
        this.playerX = WORLD_W / 2;
        this.playerY = H * 0.4;
        this.playerVx = 0;
        this.playerVy = 0;
        this.facingRight = true;
        this.shipAlive = true;
        this.invincibleTimer = 0;
        this.respawnTimer = 0;
        this.enemies = [];
        this.humanoids = [];
        this.bullets = [];
        this.mines = [];
        this.stars = [];
        this.activeEmitters = [];
        this.waveTimer = 0;
        this.waveDelay = 0;
        this.baiterSpawned = false;
        this.ensureSparkTexture();
        // Starfield
        this.stars = this.createStarfield([
            { count: 50, speed: 0, size: 1, alpha: 0.25 },
            { count: 30, speed: 0, size: 1.5, alpha: 0.35 },
            { count: 15, speed: 0, size: 2, alpha: 0.45 },
        ]);
        // Generate terrain
        this.generateTerrain();
        // Sprite scale — ensure sprites are visible across all monitor sizes
        // At 1080p (SCALE=1.0): scale ~0.8 → ship 94px, enemies 55-64px
        // At 720p (SCALE=0.67): scale ~0.6 → ship 71px, enemies 40-50px
        // Floor of 0.55 ensures minimum ~46px ship, ~28px swarmer on small monitors
        this.spriteScale = Math.max(0.35, 0.55 * SCALE);
        // Graphics layers
        this.terrainGfx = this.add.graphics().setDepth(5);
        this.gameGfx = this.add.graphics().setDepth(10);
        this.radarGfx = this.add.graphics().setDepth(800);
        this.hudExtraGfx = this.add.graphics().setDepth(801);
        // Player ship sprite (scale to match screen)
        this.shipSprite = this.add.image(0, 0, 'def-ship-r').setDepth(10).setOrigin(0.5, 0.5).setScale(this.spriteScale);
        // Input — set up references but don't capture yet (ready screen needs keydown)
        this.cursors = this.input.keyboard.createCursorKeys();
        this.fireKey = this.input.keyboard.addKey('SPACE');
        this.bombKey = this.input.keyboard.addKey('Z');
        this.fireWasDown = false;
        this.bombWasDown = false;
        this.fireCooldown = 0;
        this.thrustSoundPlaying = false;
        this.syncLivesToHUD();
        this.syncScoreToHUD();
        this.loadHighScore();
        this.startWithReadyScreen(() => {
            // Capture keys only after ready screen dismisses
            this.input.keyboard.addCapture('UP,DOWN,LEFT,RIGHT,SPACE,Z');
            this.startWave();
        });
    }
    update(_t, dtMs) {
        if (this.gameOver || !this.cursors)
            return;
        const dt = Math.min(dtMs, 33);
        const dtSec = dt / 1000;
        // Respawn timer
        if (this.respawnTimer > 0) {
            this.respawnTimer -= dt;
            if (this.respawnTimer <= 0)
                this.respawnPlayer();
        }
        // Fire cooldown
        if (this.fireCooldown > 0)
            this.fireCooldown -= dt;
        // Player input & physics
        if (this.shipAlive) {
            this.updatePlayerInput(dtSec);
            this.updatePlayerPhysics(dtSec);
        }
        // Update camera to follow player
        this.updateCamera(dtSec);
        // Update entities
        this.updateEnemies(dtSec);
        this.updateHumanoids(dtSec);
        this.updateBulletsPhysics(dtSec);
        this.updateMines(dt);
        this.checkCollisions();
        // Wave management
        this.waveTimer += dt;
        if (!this.baiterSpawned && this.wave >= 2 && this.waveTimer > 30000) {
            this.spawnBaiter();
            this.baiterSpawned = true;
        }
        if (this.waveDelay > 0) {
            this.waveDelay -= dt;
            if (this.waveDelay <= 0)
                this.startWave();
        }
        else if (this.enemies.filter(e => e.alive).length === 0 && this.mines.length === 0 && this.waveDelay <= 0 && this.wave > 0) {
            // Wave complete
            this.onWaveComplete();
        }
        // Invincibility blink
        if (this.invincibleTimer > 0) {
            this.invincibleTimer -= dt;
        }
        // Clean up expired emitters (handled by delayed destroy in spawnExplosion)
        // Render everything
        this.renderGame();
    }
    /* ================================================================
       TERRAIN
       ================================================================ */
    generateTerrain() {
        const numSamples = Math.ceil(WORLD_W / TERRAIN_SAMPLE) + 1;
        this.terrainHeights = [];
        // Generate raw heights
        for (let i = 0; i < numSamples; i++) {
            const t = i / numSamples;
            const base = H * (TERRAIN_MIN_Y + (TERRAIN_MAX_Y - TERRAIN_MIN_Y) * 0.5);
            const variation = H * (TERRAIN_MAX_Y - TERRAIN_MIN_Y) * 0.5;
            const h = base +
                Math.sin(t * Math.PI * 12) * variation * 0.4 +
                Math.sin(t * Math.PI * 25 + 1.3) * variation * 0.3 +
                Math.sin(t * Math.PI * 50 + 2.7) * variation * 0.2 +
                (Math.random() - 0.5) * variation * 0.3;
            this.terrainHeights.push(h);
        }
        // Smooth
        for (let pass = 0; pass < 3; pass++) {
            const smoothed = [...this.terrainHeights];
            for (let i = 1; i < smoothed.length - 1; i++) {
                smoothed[i] = (this.terrainHeights[i - 1] + this.terrainHeights[i] + this.terrainHeights[i + 1]) / 3;
            }
            // Wrap edges
            smoothed[0] = (this.terrainHeights[this.terrainHeights.length - 1] + this.terrainHeights[0] + this.terrainHeights[1]) / 3;
            smoothed[smoothed.length - 1] = (this.terrainHeights[this.terrainHeights.length - 2] + this.terrainHeights[this.terrainHeights.length - 1] + this.terrainHeights[0]) / 3;
            this.terrainHeights = smoothed;
        }
    }
    getTerrainY(worldX) {
        // Wrap x into world range
        let wx = this.wrapWorldX(worldX);
        const idx = wx / TERRAIN_SAMPLE;
        const i0 = Math.floor(idx) % this.terrainHeights.length;
        const i1 = (i0 + 1) % this.terrainHeights.length;
        const frac = idx - Math.floor(idx);
        return this.terrainHeights[i0] * (1 - frac) + this.terrainHeights[i1] * frac;
    }
    wrapWorldX(x) {
        return ((x % WORLD_W) + WORLD_W) % WORLD_W;
    }
    /* ================================================================
       PLAYER
       ================================================================ */
    updatePlayerInput(dtSec) {
        // Original Defender controls:
        // - UP/DOWN = vertical movement (joystick)
        // - LEFT = reverse (flip ship facing)
        // - RIGHT = thrust (forward in facing direction)
        // Adapted for keyboard: LEFT/RIGHT still control direction,
        // but pressing opposite to facing FIRST reverses, THEN thrusts
        // with a brief acceleration delay to simulate reverse→thrust feel.
        const leftDown = this.cursors.left.isDown;
        const rightDown = this.cursors.right.isDown;
        if (rightDown && !leftDown) {
            if (!this.facingRight) {
                // Reversing: flip first, apply reduced thrust
                this.facingRight = true;
                this.playerVx += PLAYER_THRUST * dtSec * 0.3;
            }
            else {
                // Thrusting forward
                this.playerVx += PLAYER_THRUST * dtSec;
            }
        }
        else if (leftDown && !rightDown) {
            if (this.facingRight) {
                // Reversing: flip first, apply reduced thrust
                this.facingRight = false;
                this.playerVx -= PLAYER_THRUST * dtSec * 0.3;
            }
            else {
                // Thrusting forward
                this.playerVx -= PLAYER_THRUST * dtSec;
            }
        }
        // Vertical movement (direct, like original joystick)
        if (this.cursors.up.isDown) {
            this.playerVy = -PLAYER_VY_SPEED;
        }
        else if (this.cursors.down.isDown) {
            this.playerVy = PLAYER_VY_SPEED;
        }
        else {
            this.playerVy *= 0.9;
        }
        // Fire — RAPID-FIRE when held down (original Defender behavior)
        if (this.fireKey.isDown) {
            this.fireBullet();
        }
        // Smart bomb — single press
        const bombDown = this.bombKey.isDown;
        if (bombDown && !this.bombWasDown) {
            this.useSmartBomb();
        }
        this.bombWasDown = bombDown;
        // Thrust sound
        const isThrusting = this.cursors.left.isDown || this.cursors.right.isDown;
        if (isThrusting && !this.thrustSoundPlaying) {
            try {
                this.sound.play('snd_thrust', { volume: 0.15, loop: true });
            }
            catch { }
            this.thrustSoundPlaying = true;
        }
        else if (!isThrusting && this.thrustSoundPlaying) {
            try {
                this.sound.stopByKey('snd_thrust');
            }
            catch { }
            this.thrustSoundPlaying = false;
        }
    }
    updatePlayerPhysics(dtSec) {
        // Friction on horizontal
        this.playerVx *= Math.pow(PLAYER_FRICTION, dtSec * 60);
        // Clamp
        if (this.playerVx > PLAYER_MAX_VX)
            this.playerVx = PLAYER_MAX_VX;
        if (this.playerVx < -PLAYER_MAX_VX)
            this.playerVx = -PLAYER_MAX_VX;
        this.playerX += this.playerVx * dtSec;
        this.playerY += this.playerVy * dtSec;
        // World wrap X
        this.playerX = this.wrapWorldX(this.playerX);
        // Clamp Y — only prevent going off-screen, NOT above terrain
        // In original Defender, ship can fly below the mountain line
        const topLimit = RADAR_Y + RADAR_H + 10;
        if (this.playerY < topLimit)
            this.playerY = topLimit;
        if (this.playerY > H - 10)
            this.playerY = H - 10;
        // Carry humanoid
        if (this.carriedHumanoid >= 0) {
            const h = this.humanoids[this.carriedHumanoid];
            if (h && h.state === 'rescued') {
                h.x = this.playerX;
                h.y = this.playerY + 10 * PX / 3;
                // Check if touching terrain to return humanoid
                if (!this.planetDestroyed) {
                    const tY = this.getTerrainY(h.x);
                    if (h.y >= tY - 5) {
                        h.y = tY - 3;
                        h.state = 'walking';
                        h.vx = (Math.random() > 0.5 ? 1 : -1) * 15;
                        this.carriedHumanoid = -1;
                        this.addScore(500, this.worldToScreenX(h.x), h.y);
                    }
                }
            }
        }
    }
    respawnPlayer() {
        this.shipAlive = true;
        this.invincibleTimer = INVINCIBLE_TIME;
        this.smartBombs = 3;
        this.carriedHumanoid = -1;
        this.playerVx = 0;
        this.playerVy = 0;
        this.playerY = H * 0.4;
        // Safety: push nearby enemies away from spawn point
        // Baiters get pushed much further since they home aggressively
        for (const e of this.enemies) {
            if (!e.alive)
                continue;
            const safeRadius = e.type === 'baiter' ? RESPAWN_SAFE_RADIUS_BAITER : RESPAWN_SAFE_RADIUS;
            const d = this.worldDist(e.x, e.y, this.playerX, this.playerY);
            if (d < safeRadius) {
                const angle = Math.atan2(e.y - this.playerY, e.x - this.playerX) || Math.random() * Math.PI * 2;
                e.x = this.playerX + Math.cos(angle) * (safeRadius + RESPAWN_PUSH_OFFSET);
                e.y = this.playerY + Math.sin(angle) * (safeRadius * 0.4);
                e.x = this.wrapWorldX(e.x);
                // Kill velocity so they don't rush back immediately
                e.vx *= 0.1;
                e.vy *= 0.1;
                // Reset baiter to dormant phase so player has time to orient
                if (e.type === 'baiter') {
                    e.zigPhase = 0;
                }
            }
        }
    }
    killPlayer() {
        if (!this.shipAlive || this.invincibleTimer > 0)
            return;
        this.shipAlive = false;
        if (this.shipSprite)
            this.shipSprite.setVisible(false);
        try {
            this.sound.play('snd_playerdead', { volume: 0.5 });
        }
        catch { }
        // Stop thrust sound
        try {
            this.sound.stopByKey('snd_thrust');
        }
        catch { }
        this.thrustSoundPlaying = false;
        // Drop carried humanoid
        if (this.carriedHumanoid >= 0) {
            const h = this.humanoids[this.carriedHumanoid];
            if (h) {
                h.state = 'falling';
                h.vy = 0;
            }
            this.carriedHumanoid = -1;
        }
        // Explosion
        this.spawnExplosion(this.playerX, this.playerY, 0xff00ff, 16);
        this.lives--;
        this.syncLivesToHUD();
        if (this.lives <= 0) {
            this.gameOver = true;
            this.checkHighScore();
            // Release keyboard captures so game-over overlay can receive key events
            try {
                this.input.keyboard.removeCapture('SPACE,Z,UP,DOWN,LEFT,RIGHT');
            }
            catch { }
            this.time.delayedCall(1000, () => {
                this.showGameOver(this.score, () => this.scene.restart());
            });
        }
        else {
            this.respawnTimer = RESPAWN_DELAY;
        }
    }
    /* ================================================================
       CAMERA
       ================================================================ */
    updateCamera(dtSec) {
        // Camera tries to keep player slightly off-center in the direction of movement
        let targetCamX = this.playerX - W * 0.35;
        if (!this.facingRight) {
            targetCamX = this.playerX - W * 0.65;
        }
        // Lerp
        const lerpSpeed = 5;
        let diff = targetCamX - this.cameraX;
        // Handle wrapping
        if (diff > WORLD_W / 2)
            diff -= WORLD_W;
        if (diff < -WORLD_W / 2)
            diff += WORLD_W;
        this.cameraX += diff * lerpSpeed * dtSec;
        this.cameraX = this.wrapWorldX(this.cameraX);
    }
    worldToScreenX(worldX) {
        let sx = worldX - this.cameraX;
        if (sx > WORLD_W / 2)
            sx -= WORLD_W;
        if (sx < -WORLD_W / 2)
            sx += WORLD_W;
        return sx;
    }
    isOnScreen(worldX, margin = 100) {
        const sx = this.worldToScreenX(worldX);
        return sx > -margin && sx < W + margin;
    }
    /* ================================================================
       BULLETS
       ================================================================ */
    fireBullet() {
        if (this.fireCooldown > 0)
            return;
        const playerBullets = this.bullets.filter(b => !b.isEnemy);
        if (playerBullets.length >= MAX_BULLETS)
            return;
        this.fireCooldown = 80; // ms between shots (rapid fire ~12/sec)
        const dir = this.facingRight ? 1 : -1;
        // Spawn bullet at the nose of the ship (half the rendered ship width ahead)
        const shipHalfW = 118 * this.spriteScale / 2;
        const bx = this.playerX + dir * (shipHalfW + 5);
        try {
            this.sound.play('snd_laser', { volume: 0.3 });
        }
        catch { }
        this.bullets.push({
            x: bx, y: this.playerY,
            vx: BULLET_SPEED * dir + this.playerVx * 0.5,
            vy: 0,
            life: 1500,
            isEnemy: false,
        });
    }
    fireEnemyBullet(ex, ey) {
        if (!this.shipAlive)
            return;
        let adjDx = this.playerX - ex;
        if (adjDx > WORLD_W / 2)
            adjDx -= WORLD_W;
        if (adjDx < -WORLD_W / 2)
            adjDx += WORLD_W;
        const dy = this.playerY - ey;
        const dist = Math.sqrt(adjDx * adjDx + dy * dy) || 1;
        // Predictive lead: compensate for player velocity
        const leadTime = dist / ENEMY_BULLET_SPEED;
        const predictX = adjDx + this.playerVx * leadTime * 0.5;
        const predictY = dy + this.playerVy * leadTime * 0.5;
        // Add slight random spread (±10°)
        const spread = (Math.random() - 0.5) * 0.35;
        const angle = Math.atan2(predictY, predictX) + spread;
        try {
            this.sound.play('snd_enemyshoot', { volume: 0.2 });
        }
        catch { }
        this.bullets.push({
            x: ex, y: ey,
            vx: Math.cos(angle) * ENEMY_BULLET_SPEED,
            vy: Math.sin(angle) * ENEMY_BULLET_SPEED,
            life: 3000,
            isEnemy: true,
        });
    }
    updateBulletsPhysics(dtSec) {
        for (let i = this.bullets.length - 1; i >= 0; i--) {
            const b = this.bullets[i];
            b.x += b.vx * dtSec;
            b.y += b.vy * dtSec;
            b.life -= dtSec * 1000;
            // World wrap
            b.x = this.wrapWorldX(b.x);
            if (b.life <= 0 || b.y < 0 || b.y > H) {
                this.bullets.splice(i, 1);
            }
        }
    }
    /* ================================================================
       SMART BOMB
       ================================================================ */
    useSmartBomb() {
        if (this.smartBombs <= 0)
            return;
        this.smartBombs--;
        try {
            this.sound.play('snd_explode', { volume: 0.5 });
        }
        catch { }
        // Destroy all on-screen enemies
        for (const e of this.enemies) {
            if (!e.alive)
                continue;
            if (this.isOnScreen(e.x)) {
                this.destroyEnemy(e);
            }
        }
        // Destroy on-screen mines
        for (let i = this.mines.length - 1; i >= 0; i--) {
            if (this.isOnScreen(this.mines[i].x)) {
                this.mines.splice(i, 1);
            }
        }
        // Screen flash
        const flash = this.add.graphics().setDepth(900);
        flash.fillStyle(0xffffff, 0.7);
        flash.fillRect(0, 0, W, H);
        this.tweens.add({
            targets: flash,
            alpha: 0,
            duration: 400,
            onComplete: () => flash.destroy(),
        });
    }
    /* ================================================================
       ENEMIES
       ================================================================ */
    createEnemy(type, x, y) {
        const textureKey = 'def-' + type;
        const sprite = this.add.image(0, 0, textureKey).setDepth(10).setOrigin(0.5, 0.5).setScale(this.spriteScale);
        return {
            type, x, y,
            vx: 0, vy: 0,
            alive: true,
            shootTimer: 2000 + Math.random() * 3000,
            targetHumanoid: -1,
            hasHumanoid: false,
            zigTimer: 0,
            mineTimer: 3000 + Math.random() * 1000,
            zigPhase: Math.random() * Math.PI * 2,
            sprite,
        };
    }
    spawnLanders(count) {
        for (let i = 0; i < count; i++) {
            const x = Math.random() * WORLD_W;
            const y = 50 + Math.random() * 80;
            const e = this.createEnemy('lander', x, y);
            e.vy = 30 + Math.random() * 20;
            e.vx = (Math.random() - 0.5) * 60;
            this.enemies.push(e);
        }
    }
    spawnBombers(count) {
        for (let i = 0; i < count; i++) {
            const x = Math.random() * WORLD_W;
            const y = 100 + Math.random() * (H * 0.3);
            const e = this.createEnemy('bomber', x, y);
            e.vx = (Math.random() > 0.5 ? 1 : -1) * (40 + Math.random() * 30);
            e.vy = (Math.random() - 0.5) * 10;
            this.enemies.push(e);
        }
    }
    spawnPods(count) {
        for (let i = 0; i < count; i++) {
            const x = Math.random() * WORLD_W;
            const y = 80 + Math.random() * (H * 0.3);
            const e = this.createEnemy('pod', x, y);
            e.vx = (Math.random() - 0.5) * 40;
            e.vy = (Math.random() - 0.5) * 20;
            this.enemies.push(e);
        }
    }
    spawnSwarmers(x, y, count) {
        for (let i = 0; i < count; i++) {
            const e = this.createEnemy('swarmer', x + (Math.random() - 0.5) * 30, y + (Math.random() - 0.5) * 30);
            e.vx = (Math.random() - 0.5) * 200;
            e.vy = (Math.random() - 0.5) * 200;
            this.enemies.push(e);
        }
    }
    spawnBaiter() {
        // Spawn off-screen
        const x = (this.playerX + W * (Math.random() > 0.5 ? 1 : -1)) % WORLD_W;
        const y = 80 + Math.random() * (H * 0.3);
        const e = this.createEnemy('baiter', x, y);
        e.zigPhase = 0; // Start in dormant phase
        e.shootTimer = 1500; // Don't shoot during dormant phase
        try {
            this.sound.play('snd_baiterwarning', { volume: 0.4 });
        }
        catch { }
        this.enemies.push(e);
    }
    updateEnemies(dtSec) {
        const speedMult = 1 + (Math.min(this.wave, 15) - 1) * 0.12; // OpenDefender-style: 1.0 at wave 1, ~2.7 at wave 15
        for (const e of this.enemies) {
            if (!e.alive)
                continue;
            switch (e.type) {
                case 'lander':
                    this.updateLander(e, dtSec, speedMult);
                    break;
                case 'mutant':
                    this.updateMutant(e, dtSec, speedMult);
                    break;
                case 'bomber':
                    this.updateBomber(e, dtSec, speedMult);
                    break;
                case 'pod':
                    this.updatePod(e, dtSec, speedMult);
                    break;
                case 'swarmer':
                    this.updateSwarmer(e, dtSec, speedMult);
                    break;
                case 'baiter':
                    this.updateBaiter(e, dtSec, speedMult);
                    break;
            }
            // World wrap
            e.x = this.wrapWorldX(e.x);
            // Clamp Y — keep enemies in playable area (not below terrain line)
            if (e.y < RADAR_Y + RADAR_H + 10)
                e.y = RADAR_Y + RADAR_H + 10;
            const maxEnemyY = this.planetDestroyed ? H - 40 : H * 0.75;
            if (e.y > maxEnemyY)
                e.y = maxEnemyY;
            // Shooting (lander, mutant, baiter, bomber)
            if (e.type !== 'pod' && e.type !== 'swarmer') {
                e.shootTimer -= dtSec * 1000;
                if (e.shootTimer <= 0 && this.isOnScreen(e.x, 200)) {
                    this.fireEnemyBullet(e.x, e.y);
                    const dif = Math.min(this.wave, 15);
                    let baseInterval;
                    if (e.type === 'lander') {
                        baseInterval = e.hasHumanoid ? Math.max(500, 1500 - dif * 80) : Math.max(800, 2500 - dif * 100);
                    }
                    else if (e.type === 'mutant') {
                        baseInterval = Math.max(400, 1200 - dif * 60);
                    }
                    else if (e.type === 'baiter') {
                        baseInterval = Math.max(300, 1500 - dif * 80);
                    }
                    else {
                        baseInterval = Math.max(600, 2000 - dif * 80);
                    }
                    e.shootTimer = baseInterval + Math.random() * 500;
                }
            }
        }
    }
    updateLander(e, dtSec, speedMult) {
        if (!e.hasHumanoid) {
            // Find a target humanoid if none
            if (e.targetHumanoid < 0 || this.humanoids[e.targetHumanoid]?.state !== 'walking') {
                e.targetHumanoid = -1;
                const walkingIdxs = this.humanoids.map((h, i) => h.state === 'walking' ? i : -1).filter(i => i >= 0);
                if (walkingIdxs.length > 0) {
                    e.targetHumanoid = walkingIdxs[Math.floor(Math.random() * walkingIdxs.length)];
                }
            }
            // Descend toward target humanoid
            if (e.targetHumanoid >= 0) {
                const h = this.humanoids[e.targetHumanoid];
                if (!h || h.state === 'dead') {
                    e.targetHumanoid = -1;
                }
                else {
                    let dx = this.wrapDx(h.x - e.x);
                    e.vx += (dx > 0 ? 1 : -1) * 200 * dtSec * speedMult;
                    // Only descend if ABOVE the humanoid, otherwise hover at humanoid height
                    const dy = h.y - e.y;
                    if (dy > 30) {
                        e.vy = 120 * speedMult; // descend toward humanoid
                    }
                    else if (dy < -20) {
                        e.vy = -60 * speedMult; // rise back up if too low
                    }
                    else {
                        e.vy *= 0.9; // hover near humanoid height
                    }
                    // Zig-zag
                    e.zigTimer += dtSec;
                    e.vx += Math.sin(e.zigTimer * 3) * 120 * dtSec;
                    // Check grab — generous radius
                    if (Math.abs(dx) < 25 && Math.abs(dy) < 25 && h.state === 'walking') {
                        e.hasHumanoid = true;
                        h.state = 'grabbed';
                        h.vx = 0;
                        h.vy = 0;
                        try {
                            this.sound.play('snd_warning', { volume: 0.3 });
                        }
                        catch { }
                    }
                }
            }
            else {
                // No humanoid to target — patrol at mid-height
                e.zigTimer += dtSec;
                e.vx += Math.sin(e.zigTimer * 2) * 100 * dtSec;
                // Maintain patrol altitude around 30% of screen height
                const patrolY = H * 0.3;
                if (e.y < patrolY - 50)
                    e.vy = 40 * speedMult;
                else if (e.y > patrolY + 50)
                    e.vy = -40 * speedMult;
                else
                    e.vy += (Math.random() - 0.5) * 80 * dtSec;
            }
        }
        else {
            // Ascend with humanoid — fast!
            e.vy = -180 * speedMult;
            e.vx *= 0.98;
            // Move humanoid with lander
            const hIdx = e.targetHumanoid;
            if (hIdx >= 0 && this.humanoids[hIdx]) {
                this.humanoids[hIdx].x = e.x;
                this.humanoids[hIdx].y = e.y + 12 * PX / 3;
            }
            // If reached top → mutate
            if (e.y <= 40) {
                // Humanoid dies
                if (hIdx >= 0 && this.humanoids[hIdx]) {
                    this.humanoids[hIdx].state = 'dead';
                    this.humanoids[hIdx].sprite = this.destroyObj(this.humanoids[hIdx].sprite);
                    try {
                        this.sound.play('snd_humanoiddead', { volume: 0.3 });
                    }
                    catch { }
                }
                // Lander becomes mutant — swap sprite texture
                e.type = 'mutant';
                if (e.sprite)
                    e.sprite.setTexture('def-mutant');
                try {
                    this.sound.play('snd_explode', { volume: 0.4 });
                }
                catch { }
                e.hasHumanoid = false;
                e.targetHumanoid = -1;
                this.checkPlanetDestroyed();
            }
        }
        // Apply velocity with clamping
        e.vx = Math.max(-280 * speedMult, Math.min(280 * speedMult, e.vx));
        e.x += e.vx * dtSec;
        e.y += e.vy * dtSec;
    }
    updateMutant(e, dtSec, speedMult) {
        // Home toward player
        const dx = this.wrapDx(this.playerX - e.x);
        const dy = this.playerY - e.y;
        const dist = Math.sqrt(dx * dx + dy * dy) || 1;
        const speed = 300 * speedMult;
        e.vx += (dx / dist) * speed * dtSec * 3;
        e.vy += (dy / dist) * speed * dtSec * 3;
        // Random jitter
        e.vx += (Math.random() - 0.5) * 400 * dtSec;
        e.vy += (Math.random() - 0.5) * 400 * dtSec;
        // Clamp speed
        const maxV = speed * 1.5;
        const curSpeed = Math.sqrt(e.vx * e.vx + e.vy * e.vy);
        if (curSpeed > maxV) {
            e.vx = (e.vx / curSpeed) * maxV;
            e.vy = (e.vy / curSpeed) * maxV;
        }
        e.x += e.vx * dtSec;
        e.y += e.vy * dtSec;
    }
    updateBomber(e, dtSec, speedMult) {
        // Slow horizontal drift
        e.x += e.vx * dtSec * speedMult;
        e.y += Math.sin(e.zigPhase) * 15 * dtSec;
        e.zigPhase += dtSec;
        // Drop mines
        e.mineTimer -= dtSec * 1000;
        if (e.mineTimer <= 0) {
            this.mines.push({
                x: e.x,
                y: e.y + 10,
                life: 15000,
                blinkTimer: 0,
            });
            e.mineTimer = 3000 + Math.random() * 1000;
        }
    }
    updatePod(e, dtSec, speedMult) {
        // Slow drift
        e.x += e.vx * dtSec * speedMult;
        e.y += e.vy * dtSec * speedMult;
        // Gentle bounce at vertical boundaries
        if (e.y < 60 || e.y > H * 0.6)
            e.vy = -e.vy;
    }
    updateSwarmer(e, dtSec, speedMult) {
        // Fast zig-zag toward player
        const dx = this.wrapDx(this.playerX - e.x);
        const dy = this.playerY - e.y;
        const dist = Math.sqrt(dx * dx + dy * dy) || 1;
        const speed = 400 * speedMult;
        e.vx += (dx / dist) * speed * dtSec * 2;
        e.vy += (dy / dist) * speed * dtSec * 2;
        // Erratic zig-zag
        e.zigPhase += dtSec * 10;
        e.vx += Math.sin(e.zigPhase) * 300 * dtSec;
        e.vy += Math.cos(e.zigPhase * 1.3) * 200 * dtSec;
        // Clamp
        const maxV = speed * 1.8;
        const curSpeed = Math.sqrt(e.vx * e.vx + e.vy * e.vy);
        if (curSpeed > maxV) {
            e.vx = (e.vx / curSpeed) * maxV;
            e.vy = (e.vy / curSpeed) * maxV;
        }
        e.x += e.vx * dtSec;
        e.y += e.vy * dtSec;
        // Smart direction change when far from player (OpenDefender: 200px)
        let sdx = this.playerX - e.x;
        if (sdx > WORLD_W / 2)
            sdx -= WORLD_W;
        if (sdx < -WORLD_W / 2)
            sdx += WORLD_W;
        if (Math.abs(sdx) > 300) {
            e.vx += (sdx > 0 ? 1 : -1) * 500 * dtSec;
        }
    }
    updateBaiter(e, dtSec, speedMult) {
        e.zigPhase += dtSec;
        // Phase 1: Brief dormant hover (first 1.5 seconds)
        if (e.zigPhase < 1.5) {
            e.vx *= 0.95;
            e.vy *= 0.95;
            e.x += e.vx * dtSec;
            e.y += e.vy * dtSec;
            return;
        }
        const dx = this.wrapDx(this.playerX - e.x);
        const dy = this.playerY - e.y;
        const dist = Math.sqrt(dx * dx + dy * dy) || 1;
        const speed = 280 * speedMult;
        // Orbit behavior: if close to player, strafe around instead of sitting on top
        const minDist = 150;
        if (dist < minDist) {
            // Too close — veer away perpendicular + strafe
            const perpX = -dy / dist;
            const perpY = dx / dist;
            e.vx += perpX * speed * dtSec * 3;
            e.vy += perpY * speed * dtSec * 3;
            // Push away slightly
            e.vx -= (dx / dist) * speed * dtSec * 1.5;
            e.vy -= (dy / dist) * speed * dtSec * 1.5;
        }
        else {
            // Approach but not too aggressively
            e.vx += (dx / dist) * speed * dtSec * 1.5;
            e.vy += (dy / dist) * speed * dtSec * 1.5;
        }
        // Strafing oscillation
        e.vx += Math.sin(e.zigPhase * 4) * 180 * dtSec;
        e.vy += Math.cos(e.zigPhase * 3) * 120 * dtSec;
        // Clamp to max speed
        const maxV = speed * 0.7;
        const curSpeed = Math.sqrt(e.vx * e.vx + e.vy * e.vy);
        if (curSpeed > maxV) {
            e.vx = (e.vx / curSpeed) * maxV;
            e.vy = (e.vy / curSpeed) * maxV;
        }
        e.x += e.vx * dtSec;
        e.y += e.vy * dtSec;
    }
    destroyEnemy(e) {
        if (!e.alive)
            return;
        e.alive = false;
        e.sprite = this.destroyObj(e.sprite);
        try {
            this.sound.play('snd_enemydead', { volume: 0.4 });
        }
        catch { }
        const colorMap = {
            lander: 0x00ff00, mutant: 0xff00ff, bomber: 0xffff00,
            pod: 0xcc00cc, swarmer: 0xffff00, baiter: 0x00ff44,
        };
        const scoreMap = {
            lander: 150, mutant: 150, bomber: 250,
            pod: 1000, swarmer: 150, baiter: 200,
        };
        const sx = this.worldToScreenX(e.x);
        this.addScore(scoreMap[e.type], sx, e.y);
        this.spawnExplosion(e.x, e.y, colorMap[e.type], 10);
        this.checkExtraLife();
        // Release humanoid if lander was carrying one
        if (e.type === 'lander' && e.hasHumanoid && e.targetHumanoid >= 0) {
            const h = this.humanoids[e.targetHumanoid];
            if (h && h.state === 'grabbed') {
                h.state = 'falling';
                h.vy = 0;
            }
        }
        // Pod splits into swarmers
        if (e.type === 'pod') {
            const count = 3 + Math.floor(Math.random() * 3);
            this.spawnSwarmers(e.x, e.y, count);
        }
    }
    /* ================================================================
       HUMANOIDS
       ================================================================ */
    spawnHumanoids(count) {
        // Destroy existing humanoid sprites before respawning
        for (const h of this.humanoids) {
            h.sprite = this.destroyObj(h.sprite);
        }
        this.humanoids = [];
        for (let i = 0; i < count; i++) {
            const x = Math.random() * WORLD_W;
            const tY = this.getTerrainY(x);
            const sprite = this.add.image(0, 0, 'def-humanoid').setDepth(10).setOrigin(0.5, 0.5).setScale(this.spriteScale);
            this.humanoids.push({
                x,
                y: tY - 3,
                vx: (Math.random() > 0.5 ? 1 : -1) * (10 + Math.random() * 10),
                vy: 0,
                state: 'walking',
                walkDir: Math.random() > 0.5 ? 1 : -1,
                sprite,
            });
        }
    }
    updateHumanoids(dtSec) {
        for (let i = 0; i < this.humanoids.length; i++) {
            const h = this.humanoids[i];
            switch (h.state) {
                case 'walking':
                    if (this.planetDestroyed) {
                        // Planet destroyed — humanoids fall
                        h.state = 'falling';
                        h.vy = 0;
                        break;
                    }
                    h.x += h.vx * dtSec;
                    h.x = this.wrapWorldX(h.x);
                    const tY = this.getTerrainY(h.x);
                    h.y = tY - 3;
                    // Randomly change direction
                    if (Math.random() < 0.005)
                        h.vx = -h.vx;
                    break;
                case 'grabbed':
                    // Moved by lander in updateLander
                    break;
                case 'falling':
                    // Gentle gravity matching OpenDefender (fallspeed=0.01, terminal=8px/frame)
                    // Scaled for our coordinate system: slow accel, capped terminal velocity
                    h.vy += 60 * dtSec; // gentle gravity (~10× slower than before)
                    if (h.vy > 120)
                        h.vy = 120; // terminal velocity cap — keeps it catchable
                    h.y += h.vy * dtSec;
                    if (!this.planetDestroyed) {
                        const groundY = this.getTerrainY(h.x);
                        if (h.y >= groundY - 3) {
                            if (h.vy > 100) {
                                // Splat — only if falling fast (dropped from very high without catching)
                                h.state = 'dead';
                                h.sprite = this.destroyObj(h.sprite);
                                this.spawnExplosion(h.x, h.y, 0xffffff, 6);
                                try {
                                    this.sound.play('snd_humanoiddead', { volume: 0.3 });
                                }
                                catch { }
                                this.checkPlanetDestroyed();
                            }
                            else {
                                // Soft landing
                                h.y = groundY - 3;
                                h.vy = 0;
                                h.state = 'walking';
                                h.vx = (Math.random() > 0.5 ? 1 : -1) * 15;
                            }
                        }
                    }
                    else {
                        // No terrain — fall to death
                        if (h.y > H + 50) {
                            h.state = 'dead';
                            h.sprite = this.destroyObj(h.sprite);
                            try {
                                this.sound.play('snd_humanoiddead', { volume: 0.3 });
                            }
                            catch { }
                        }
                    }
                    break;
                case 'rescued':
                    // Moved by player in updatePlayerPhysics
                    break;
                case 'dead':
                    break;
            }
        }
    }
    checkPlanetDestroyed() {
        if (this.planetDestroyed)
            return;
        const alive = this.humanoids.filter(h => h.state !== 'dead').length;
        if (alive === 0) {
            this.planetDestroyed = true;
            // All remaining landers become mutants
            for (const e of this.enemies) {
                if (e.alive && e.type === 'lander') {
                    e.type = 'mutant';
                    if (e.sprite)
                        e.sprite.setTexture('def-mutant');
                    e.hasHumanoid = false;
                    e.targetHumanoid = -1;
                }
            }
        }
    }
    /* ================================================================
       MINES
       ================================================================ */
    updateMines(dt) {
        for (let i = this.mines.length - 1; i >= 0; i--) {
            const m = this.mines[i];
            m.life -= dt;
            m.blinkTimer += dt;
            if (m.life <= 0) {
                this.mines.splice(i, 1);
            }
        }
    }
    /* ================================================================
       COLLISIONS
       ================================================================ */
    worldDist(x1, y1, x2, y2) {
        const dx = this.wrapDx(x1 - x2);
        const dy = y1 - y2;
        return Math.sqrt(dx * dx + dy * dy);
    }
    /** Wrap a delta-X value for the toroidal world. */
    wrapDx(dx) {
        if (dx > WORLD_W / 2)
            dx -= WORLD_W;
        if (dx < -WORLD_W / 2)
            dx += WORLD_W;
        return dx;
    }
    checkCollisions() {
        // Use half the ship's rendered height so the hitbox matches the visible sprite
        const playerRadius = 53 * this.spriteScale / 2;
        // Player bullets vs enemies
        for (let bi = this.bullets.length - 1; bi >= 0; bi--) {
            const b = this.bullets[bi];
            if (b.isEnemy)
                continue;
            for (const e of this.enemies) {
                if (!e.alive)
                    continue;
                const hitR = e.type === 'swarmer' ? 12 * PX / 3 : 18 * PX / 3;
                if (this.worldDist(b.x, b.y, e.x, e.y) < hitR) {
                    this.destroyEnemy(e);
                    this.bullets.splice(bi, 1);
                    break;
                }
            }
        }
        // Player bullets vs mines
        for (let bi = this.bullets.length - 1; bi >= 0; bi--) {
            const b = this.bullets[bi];
            if (b.isEnemy)
                continue;
            for (let mi = this.mines.length - 1; mi >= 0; mi--) {
                const m = this.mines[mi];
                if (this.worldDist(b.x, b.y, m.x, m.y) < 10 * PX / 3) {
                    this.mines.splice(mi, 1);
                    this.bullets.splice(bi, 1);
                    this.addScore(25, this.worldToScreenX(m.x), m.y);
                    break;
                }
            }
        }
        // Player bullets vs humanoids (friendly fire)
        for (let bi = this.bullets.length - 1; bi >= 0; bi--) {
            const b = this.bullets[bi];
            if (b.isEnemy)
                continue;
            for (const h of this.humanoids) {
                if (h.state !== 'walking')
                    continue;
                const hitR = 14 * PX / 3;
                if (this.worldDist(b.x, b.y, h.x, h.y) < hitR) {
                    if (this.carriedHumanoid >= 0 && this.humanoids[this.carriedHumanoid] === h) {
                        this.carriedHumanoid = -1;
                    }
                    h.state = 'dead';
                    try {
                        this.sound.play('snd_humanoiddead', { volume: 0.3 });
                    }
                    catch { }
                    this.spawnExplosion(h.x, h.y, 0x00ffff, 8);
                    this.bullets.splice(bi, 1);
                    this.checkPlanetDestroyed();
                    break;
                }
            }
        }
        if (!this.shipAlive)
            return;
        // Enemy bullets vs player
        for (let bi = this.bullets.length - 1; bi >= 0; bi--) {
            const b = this.bullets[bi];
            if (!b.isEnemy)
                continue;
            if (this.worldDist(b.x, b.y, this.playerX, this.playerY) < playerRadius) {
                this.bullets.splice(bi, 1);
                this.killPlayer();
                return;
            }
        }
        // Enemies body vs player
        if (this.invincibleTimer <= 0) {
            for (const e of this.enemies) {
                if (!e.alive)
                    continue;
                const hitR = e.type === 'swarmer' ? 10 * PX / 3 : 18 * PX / 3;
                if (this.worldDist(e.x, e.y, this.playerX, this.playerY) < hitR) {
                    this.killPlayer();
                    return;
                }
            }
        }
        // Mines vs player
        if (this.invincibleTimer <= 0) {
            for (let mi = this.mines.length - 1; mi >= 0; mi--) {
                const m = this.mines[mi];
                if (this.worldDist(m.x, m.y, this.playerX, this.playerY) < 10 * PX / 3) {
                    this.mines.splice(mi, 1);
                    this.killPlayer();
                    return;
                }
            }
        }
        // Falling humanoids — catch by player
        for (let i = 0; i < this.humanoids.length; i++) {
            const h = this.humanoids[i];
            if (h.state !== 'falling')
                continue;
            if (this.carriedHumanoid >= 0)
                continue; // already carrying one
            if (this.worldDist(h.x, h.y, this.playerX, this.playerY) < 40 * PX / 3) {
                h.state = 'rescued';
                h.vy = 0;
                this.carriedHumanoid = i;
                this.addScore(250, this.worldToScreenX(h.x), h.y);
                try {
                    this.sound.play('snd_bonus', { volume: 0.4 });
                }
                catch { }
            }
        }
    }
    /* ================================================================
       WAVES
       ================================================================ */
    startWave() {
        this.wave++;
        this.waveTimer = 0;
        this.baiterSpawned = false;
        this.syncLevelToHUD(this.wave);
        this.showWaveBanner(this.wave);
        try {
            this.sound.play('snd_start', { volume: 0.3 });
        }
        catch { }
        // Clear old dead enemies — destroy their sprites
        for (const e of this.enemies) {
            if (!e.alive) {
                e.sprite = this.destroyObj(e.sprite);
            }
        }
        this.enemies = this.enemies.filter(e => e.alive);
        this.bullets = [];
        this.mines = [];
        // Humanoids persist across waves — only spawn on wave 1 or if planet was destroyed
        if (this.wave === 1) {
            this.spawnHumanoids(10);
        }
        // Don't respawn humanoids on subsequent waves — they carry over!
        // Spawn enemies
        const landerCount = 5 + (this.wave - 1) * 2;
        this.spawnLanders(landerCount);
        if (this.wave >= 3) {
            this.spawnBombers(Math.min(this.wave - 2, 4));
        }
        if (this.wave >= 4) {
            this.spawnPods(Math.min(this.wave - 3, 3));
        }
    }
    onWaveComplete() {
        // Bonus for surviving humanoids
        if (!this.planetDestroyed) {
            const alive = this.humanoids.filter(h => h.state !== 'dead').length;
            if (alive > 0) {
                const bonus = 500 * alive;
                this.addScore(bonus, W / 2, H / 2);
            }
        }
        this.waveDelay = 2000;
    }
    /* ================================================================
       EXTRA LIFE
       ================================================================ */
    checkExtraLife() {
        if (this.score >= this.nextExtraLife) {
            this.lives++;
            this.syncLivesToHUD();
            this.nextExtraLife += EXTRA_LIFE_SCORE;
            try {
                this.sound.play('snd_player1up', { volume: 0.5 });
            }
            catch { }
            // Flash notification
            const txt = this.add.text(W / 2, H * 0.3, 'EXTRA LIFE!', {
                fontFamily: '"Press Start 2P", monospace',
                fontSize: '18px',
                color: '#00ff00',
                stroke: '#000',
                strokeThickness: 3,
            }).setOrigin(0.5, 0.5).setDepth(950);
            this.tweens.add({
                targets: txt,
                y: H * 0.25,
                alpha: 0,
                duration: 1500,
                onComplete: () => txt.destroy(),
            });
        }
    }
    /* ================================================================
       EXPLOSIONS
       ================================================================ */
    spawnExplosion(worldX, worldY, color, count) {
        const sx = this.worldToScreenX(worldX);
        if (sx < -200 || sx > W + 200)
            return; // off-screen, skip
        this.spawnParticleExplosion(sx, worldY, color, count);
    }
    /* ================================================================
       RENDERING
       ================================================================ */
    renderGame() {
        const g = this.gameGfx;
        g.clear();
        // Draw terrain
        this.renderTerrain();
        // Draw humanoids
        this.renderHumanoids(g);
        // Draw enemies
        this.renderEnemies(g);
        // Draw mines
        this.renderMines(g);
        // Draw bullets
        this.renderBullets(g);
        // Draw player
        if (this.shipAlive) {
            const blink = this.invincibleTimer > 0 && Math.sin(performance.now() / 80) < 0;
            this.shipSprite.setAlpha(blink ? 0.2 : 1);
            this.renderPlayer(g);
        }
        else {
            this.shipSprite.setVisible(false);
        }
        // Draw radar
        this.renderRadar();
        // Draw smart bomb HUD
        this.renderSmartBombHUD();
    }
    renderTerrain() {
        const tg = this.terrainGfx;
        tg.clear();
        if (this.planetDestroyed)
            return;
        // Draw terrain that's visible on screen
        const startWorldX = this.cameraX - 20;
        const endWorldX = this.cameraX + W + 20;
        // Mountain line — orange/brown to match original arcade
        tg.lineStyle(2, 0xcc8800, 1);
        tg.beginPath();
        let firstPoint = true;
        for (let wx = startWorldX; wx <= endWorldX; wx += TERRAIN_SAMPLE / 2) {
            const wrappedX = this.wrapWorldX(wx);
            const sy = this.getTerrainY(wrappedX);
            const sx = wx - this.cameraX;
            if (firstPoint) {
                tg.moveTo(sx, sy);
                firstPoint = false;
            }
            else {
                tg.lineTo(sx, sy);
            }
        }
        tg.strokePath();
        // Subtle fill below terrain — dark brown
        tg.fillStyle(0x331800, 0.3);
        tg.beginPath();
        firstPoint = true;
        for (let wx = startWorldX; wx <= endWorldX; wx += TERRAIN_SAMPLE / 2) {
            const wrappedX = this.wrapWorldX(wx);
            const sy = this.getTerrainY(wrappedX);
            const sx = wx - this.cameraX;
            if (firstPoint) {
                tg.moveTo(sx, sy);
                firstPoint = false;
            }
            else {
                tg.lineTo(sx, sy);
            }
        }
        // Close polygon at bottom
        tg.lineTo(endWorldX - this.cameraX, H);
        tg.lineTo(startWorldX - this.cameraX, H);
        tg.closePath();
        tg.fillPath();
    }
    renderPlayer(g) {
        const sx = this.worldToScreenX(this.playerX);
        this.shipSprite.setPosition(sx, this.playerY);
        this.shipSprite.setTexture(this.facingRight ? 'def-ship-r' : 'def-ship-l');
        this.shipSprite.setVisible(true);
        // Engine exhaust — fires from the REAR of the ship (opposite of facing direction)
        if (this.cursors.left.isDown || this.cursors.right.isDown) {
            const shipHalfW = 118 * this.spriteScale / 2;
            const shipHalfH = 53 * this.spriteScale / 2;
            // Exhaust shoots out behind the ship
            const exhaustDir = this.facingRight ? -1 : 1;
            const exhaustX = sx + exhaustDir * shipHalfW;
            // Main exhaust flame — large, flickering
            const flameLen = 15 + Math.random() * 25; // variable length
            const flameW = flameLen * SCALE;
            const flameH = (6 + Math.random() * 4) * SCALE;
            const fx = exhaustDir > 0 ? exhaustX : exhaustX - flameW;
            // Outer glow (orange)
            g.fillStyle(0xff6600, 0.3 + Math.random() * 0.2);
            g.fillRect(fx - 2 * SCALE, this.playerY - flameH * 0.7, flameW + 4 * SCALE, flameH * 1.4);
            // Core flame (magenta/pink — matches ship engine)
            g.fillStyle(0xff00ff, 0.5 + Math.random() * 0.4);
            g.fillRect(fx, this.playerY - flameH * 0.4, flameW * 0.8, flameH * 0.8);
            // Hot center (white/yellow)
            g.fillStyle(0xffff88, 0.4 + Math.random() * 0.4);
            const coreW = flameW * 0.4;
            const coreX = exhaustDir > 0 ? exhaustX : exhaustX - coreW;
            g.fillRect(coreX, this.playerY - flameH * 0.2, coreW, flameH * 0.4);
            // Random sparks/particles
            for (let i = 0; i < 3; i++) {
                const sparkX = exhaustX + exhaustDir * (Math.random() * flameW * 1.2);
                const sparkY = this.playerY + (Math.random() - 0.5) * flameH * 1.5;
                const sparkSize = (1 + Math.random() * 2) * SCALE;
                g.fillStyle(Math.random() > 0.5 ? 0xff4400 : 0xff00ff, 0.3 + Math.random() * 0.5);
                g.fillRect(sparkX, sparkY, sparkSize, sparkSize);
            }
        }
    }
    renderEnemies(g) {
        for (const e of this.enemies) {
            if (!e.alive) {
                if (e.sprite)
                    e.sprite.setVisible(false);
                continue;
            }
            const sx = this.worldToScreenX(e.x);
            if (sx < -60 || sx > W + 60) {
                if (e.sprite)
                    e.sprite.setVisible(false);
                continue;
            }
            if (e.sprite) {
                e.sprite.setPosition(sx, e.y);
                e.sprite.setVisible(true);
                // Mutant pulse effect
                if (e.type === 'mutant') {
                    e.sprite.setAlpha(0.7 + Math.sin(performance.now() / 200) * 0.3);
                }
            }
        }
    }
    renderHumanoids(g) {
        for (const h of this.humanoids) {
            if (h.state === 'dead') {
                if (h.sprite)
                    h.sprite.setVisible(false);
                continue;
            }
            const sx = this.worldToScreenX(h.x);
            if (sx < -30 || sx > W + 30) {
                if (h.sprite)
                    h.sprite.setVisible(false);
                continue;
            }
            if (h.sprite) {
                h.sprite.setPosition(sx, h.y);
                h.sprite.setVisible(true);
                // Color tint based on state
                if (h.state === 'rescued')
                    h.sprite.setTint(0x00ff00);
                else if (h.state === 'falling')
                    h.sprite.setTint(0xff8800);
                else if (h.state === 'grabbed')
                    h.sprite.setTint(0xff4444);
                else
                    h.sprite.clearTint();
            }
        }
    }
    renderBullets(g) {
        const bs = Math.max(3, Math.round(4 * SCALE)); // bullet size scales with screen
        for (const b of this.bullets) {
            const sx = this.worldToScreenX(b.x);
            if (sx < -200 || sx > W + 200)
                continue;
            if (b.isEnemy) {
                g.fillStyle(0xff0000);
                g.fillRect(sx - bs, b.y - bs, bs * 2, bs * 2);
            }
            else {
                // Long dashed laser beam — scales with screen
                const dir = b.vx > 0 ? 1 : -1;
                const beamLen = Math.round(120 * SCALE);
                const segLen = Math.round(14 * SCALE);
                const gapLen = Math.round(6 * SCALE);
                const thick = Math.max(3, Math.round(4 * SCALE));
                for (let i = 0; i < beamLen; i += segLen + gapLen) {
                    const segX = sx + (dir > 0 ? -i - segLen : i);
                    g.fillStyle(0xff4400, 1);
                    g.fillRect(segX, b.y - Math.floor(thick / 2), segLen, thick);
                }
                // Bright tip
                const tipS = Math.max(4, Math.round(5 * SCALE));
                g.fillStyle(0xffff00, 1);
                g.fillRect(sx - tipS, b.y - Math.floor(tipS / 2), tipS * 2, tipS);
            }
        }
    }
    renderMines(g) {
        for (const m of this.mines) {
            const sx = this.worldToScreenX(m.x);
            if (sx < -20 || sx > W + 20)
                continue;
            // Blink effect
            const visible = Math.sin(m.blinkTimer * 0.008) > -0.3;
            if (visible) {
                g.fillStyle(0xff0000);
                const ms = PX * 1.5;
                g.fillRect(sx - ms, m.y - ms, ms * 2, ms * 2);
            }
        }
    }
    renderRadar() {
        const rg = this.radarGfx;
        rg.clear();
        // Background
        rg.fillStyle(0x000000, 0.5);
        rg.fillRect(0, RADAR_Y, W, RADAR_H);
        // Blue border lines (left and right edges, like original)
        rg.lineStyle(2, 0x0044ff, 0.9);
        rg.beginPath();
        rg.moveTo(W * 0.3, RADAR_Y);
        rg.lineTo(W * 0.3, RADAR_Y + RADAR_H);
        rg.strokePath();
        rg.beginPath();
        rg.moveTo(W * 0.7, RADAR_Y);
        rg.lineTo(W * 0.7, RADAR_Y + RADAR_H);
        rg.strokePath();
        // Top and bottom border
        rg.lineStyle(1, 0x0044ff, 0.6);
        rg.strokeRect(0, RADAR_Y, W, RADAR_H);
        const scaleX = W / WORLD_W;
        const scaleY = RADAR_H / H;
        // Terrain on radar — orange to match main terrain
        if (!this.planetDestroyed) {
            rg.lineStyle(1, 0xcc8800, 0.6);
            rg.beginPath();
            let first = true;
            for (let i = 0; i < this.terrainHeights.length; i += 4) {
                const wx = i * TERRAIN_SAMPLE;
                const rx = wx * scaleX;
                const ry = RADAR_Y + this.terrainHeights[i] * scaleY;
                if (first) {
                    rg.moveTo(rx, ry);
                    first = false;
                }
                else
                    rg.lineTo(rx, ry);
            }
            rg.strokePath();
        }
        // Blips
        const blipSize = 3;
        // Humanoids (cyan)
        rg.fillStyle(0x00ffff);
        for (const h of this.humanoids) {
            if (h.state === 'dead')
                continue;
            rg.fillRect(h.x * scaleX, RADAR_Y + h.y * scaleY, blipSize, blipSize);
        }
        // Enemies
        for (const e of this.enemies) {
            if (!e.alive)
                continue;
            const color = e.type === 'mutant' ? 0xff00ff :
                e.type === 'bomber' ? 0xffff00 :
                    e.type === 'baiter' ? 0x00ff44 :
                        e.type === 'swarmer' ? 0xffff00 :
                            e.type === 'pod' ? 0xcc00cc :
                                0x00ff00;
            rg.fillStyle(color);
            rg.fillRect(e.x * scaleX, RADAR_Y + e.y * scaleY, blipSize, blipSize);
        }
        // Player (white crosshair, like original — larger for visibility)
        const px = this.playerX * scaleX;
        const py = RADAR_Y + this.playerY * scaleY;
        rg.fillStyle(0xffffff);
        rg.fillRect(px - 1, py - 4, 3, 9); // vertical bar
        rg.fillRect(px - 4, py - 1, 9, 3); // horizontal bar
    }
    renderSmartBombHUD() {
        const hg = this.hudExtraGfx;
        hg.clear();
        // Draw smart bomb count below radar
        const bombY = RADAR_Y + RADAR_H + 4;
        for (let i = 0; i < this.smartBombs; i++) {
            hg.fillStyle(0xff4400);
            hg.fillRect(8 + i * 14, bombY, 10, 8);
            hg.lineStyle(1, 0xff8800);
            hg.strokeRect(8 + i * 14, bombY, 10, 8);
        }
    }
    /* ================================================================
       CLEANUP
       ================================================================ */
    shutdown() {
        super.shutdown();
        // Stop looping sounds
        try {
            this.sound.stopByKey('snd_thrust');
        }
        catch { }
        this.thrustSoundPlaying = false;
        // Destroy enemy sprites
        for (const e of this.enemies) {
            e.sprite = this.destroyObj(e.sprite);
        }
        // Destroy humanoid sprites
        for (const h of this.humanoids) {
            h.sprite = this.destroyObj(h.sprite);
        }
        // Destroy player sprite
        this.shipSprite = this.destroyObj(this.shipSprite);
        // Destroy graphics objects
        this.destroyObj(this.gameGfx);
        this.destroyObj(this.radarGfx);
        this.destroyObj(this.terrainGfx);
        this.destroyObj(this.hudExtraGfx);
    }
}
//# sourceMappingURL=PlanetGuardian.js.map