@where-stars-drift/core 1.0.0

package/src/entities/starship.ts

@@ -0,0 +1,906 @@
+
+/**
+ * @fileoverview Defines all starship classes, shapes, and properties, and the Starship class itself.
+ */
+
+import { BoundedBody } from '../base/bounded-body';
+import type { Star } from './star';
+import type { DockingPoint } from './docking-point';
+import type { Orbit } from './orbit';
+import type { Hoverable } from '../base/hoverable';
+import { DEBUG_CONFIG } from '../config/simulation';
+import type { Fleet } from './fleet';
+import { DebugController } from '../controllers/debug-controller';
+
+
+// --- Ship Shape Definitions ---
+// A collection of reusable path-drawing functions for different ship shapes.
+
+export const SHAPES: Record<string, ((ctx: CanvasRenderingContext2D, r: number) => void)[]> = {
+  CAPITAL: [
+    // Variant 1: Based on Carrier v3 image
+    (ctx, r) => {
+        ctx.moveTo(0, -r * 1.5); // Nose tip
+        ctx.lineTo(r * 0.8, -r * 1.3);
+        ctx.lineTo(r * 0.9, r * 0.5);
+        ctx.lineTo(r * 1.2, r * 0.8);
+        ctx.lineTo(r * 1.1, r * 1.5);
+        ctx.lineTo(-r * 1.1, r * 1.5);
+        ctx.lineTo(-r * 1.2, r * 0.8);
+        ctx.lineTo(-r * 0.9, r * 0.5);
+        ctx.lineTo(-r * 0.8, -r * 1.3);
+        ctx.closePath();
+    },
+    // Variant 2: Based on Carrier v2 image (long, bulky freighter/dreadnought)
+    (ctx, r) => {
+        ctx.moveTo(0, -r * 1.6); // Top antenna area
+        ctx.lineTo(r * 0.6, -r * 1.5);
+        ctx.lineTo(r * 0.6, -r * 0.8);
+        ctx.lineTo(r * 0.9, -r * 0.6);
+        ctx.lineTo(r * 0.9, r * 0.8);
+        ctx.lineTo(r * 0.6, r * 1.0);
+        ctx.lineTo(r * 0.7, r * 1.5);
+        ctx.lineTo(-r * 0.7, r * 1.5);
+        ctx.lineTo(-r * 0.6, r * 1.0);
+        ctx.lineTo(-r * 0.9, r * 0.8);
+        ctx.lineTo(-r * 0.9, -r * 0.6);
+        ctx.lineTo(-r * 0.6, -r * 0.8);
+        ctx.lineTo(-r * 0.6, -r * 1.5);
+        ctx.closePath();
+    },
+    // Variant 3: Based on Carrier v1 image
+    (ctx, r) => {
+      ctx.moveTo(r * 0.3, -r * 1.6); // Right prong nose
+      ctx.lineTo(r * 0.8, -r * 1.5); // Right prong outer edge
+      ctx.lineTo(r * 0.9, r * 1.2);
+      ctx.lineTo(r * 0.7, r * 1.6); // Right engine
+      ctx.lineTo(-r * 0.7, r * 1.6); // Left engine
+      ctx.lineTo(-r * 0.9, r * 1.2);
+      ctx.lineTo(-r * 0.8, -r * 1.5); // Left prong outer edge
+      ctx.lineTo(-r * 0.3, -r * 1.6); // Left prong nose
+      ctx.lineTo(-r * 0.2, -r * 1.3);
+      ctx.lineTo(r * 0.2, -r * 1.3);
+      ctx.closePath();
+    },
+  ],
+  CRUISER: [
+    // Variant 1: Sleek cruiser with side pods (third from left)
+    (ctx, r) => {
+        ctx.moveTo(0, -r * 1.5);
+        ctx.lineTo(r * 0.3, -r * 1.2);
+        ctx.lineTo(r * 0.4, 0);
+        ctx.lineTo(r * 0.8, -0.2 * r);
+        ctx.lineTo(r * 0.8, 0.2 * r);
+        ctx.lineTo(r * 0.4, r * 0.4);
+        ctx.lineTo(r * 0.5, r * 1.4);
+        ctx.lineTo(-r * 0.5, r * 1.4);
+        ctx.lineTo(-r * 0.4, r * 0.4);
+        ctx.lineTo(-r * 0.8, 0.2 * r);
+        ctx.lineTo(-r * 0.8, -0.2 * r);
+        ctx.lineTo(-r * 0.4, 0);
+        ctx.lineTo(-r * 0.3, -r * 1.2);
+        ctx.closePath();
+    },
+    // Variant 2: Cruiser with forward wings (fourth from left)
+    (ctx, r) => {
+        ctx.moveTo(0, -r * 1.5);
+        ctx.lineTo(r * 1.2, r * 0.2);
+        ctx.lineTo(r * 0.6, r * 1.3);
+        ctx.lineTo(-r * 0.6, r * 1.3);
+        ctx.lineTo(-r * 1.2, r * 0.2);
+        ctx.closePath();
+    },
+  ],
+  ESCORT: [
+    // Variant 1: Compact escort with rear engines (fifth from left)
+     (ctx, r) => {
+        ctx.moveTo(0, -r * 1.3);
+        ctx.lineTo(r * 0.8, -r * 0.5);
+        ctx.lineTo(r * 0.8, r * 0.6);
+        ctx.lineTo(r * 0.5, r * 1.2);
+        ctx.lineTo(-r * 0.5, r * 1.2);
+        ctx.lineTo(-r * 0.8, r * 0.6);
+        ctx.lineTo(-r * 0.8, -r * 0.5);
+        ctx.closePath();
+    },
+    // Variant 2: Smallest ship with wings (far right)
+    (ctx, r) => {
+        ctx.moveTo(0, -r * 1.2);
+        ctx.lineTo(r * 1, r * 0.1);
+        ctx.lineTo(r*0.4, r*0.1);
+        ctx.lineTo(r * 0.6, r * 1);
+        ctx.lineTo(-r * 0.6, r * 1);
+        ctx.lineTo(-r*0.4, r*0.1);
+        ctx.lineTo(-r * 1, r * 0.1);
+        ctx.closePath();
+    },
+    // Variant 3: Inspired by middle-bottom sprites
+    (ctx, r) => {
+      ctx.moveTo(0, -r);
+      ctx.lineTo(r * 0.9, -r * 0.7);
+      ctx.lineTo(r * 0.9, r * 0.7);
+      ctx.lineTo(r * 0.4, r * 1.1);
+      ctx.lineTo(-r * 0.4, r * 1.1);
+      ctx.lineTo(-r * 0.9, r * 0.7);
+      ctx.lineTo(-r * 0.9, -r * 0.7);
+      ctx.closePath();
+    },
+  ],
+  FIGHTER: [
+    // Variant 1: Arrowhead fighter
+    (ctx, r) => {
+      ctx.moveTo(0, -r * 1.4); // Nose
+      ctx.lineTo(r * 0.7, r * 0.7); // Right wing tip
+      ctx.lineTo(r * 0.4, r * 0.9); // Right wing inner
+      ctx.lineTo(-r * 0.4, r * 0.9); // Left wing inner
+      ctx.lineTo(-r * 0.7, r * 0.7); // Left wing tip
+      ctx.closePath();
+    },
+     // Variant 2: Inspired by X-Wing style
+    (ctx, r) => {
+      ctx.moveTo(0, -r * 0.5); // Cockpit
+      ctx.lineTo(r * 1.2, -r * 0.2); // Right-front wing
+      ctx.lineTo(r * 1.2, r * 0.2);
+      ctx.lineTo(0, r * 1.2); // Rear
+      ctx.lineTo(-r * 1.2, r * 0.2);
+      ctx.lineTo(-r * 1.2, -r * 0.2);
+      ctx.closePath();
+    },
+  ],
+  SUPPORT: [
+    // Variant 1: Based on Hauler image
+    (ctx, r) => {
+      const h = r * 1.8;
+      const w = r * 0.4;
+      const wingW = r * 1.2;
+      const tailW = r * 0.8;
+
+      ctx.moveTo(0, -h); // Nose
+      ctx.lineTo(w, -h * 0.8);
+      ctx.lineTo(w, r * 0.1);
+      ctx.lineTo(wingW, r * 0.2); // Wing start
+      ctx.lineTo(wingW, r * 0.7); // Wing end
+      ctx.lineTo(w, r * 0.8);
+      ctx.lineTo(w, h * 0.8);
+      ctx.lineTo(tailW, h); // Tail fin outer
+      ctx.lineTo(tailW * 0.8, h);
+      ctx.lineTo(w * 0.5, h * 0.85);
+      ctx.lineTo(-w * 0.5, h * 0.85);
+      ctx.lineTo(-tailW * 0.8, h);
+      ctx.lineTo(-tailW, h); // Tail fin outer
+      ctx.lineTo(-w, h * 0.8);
+      ctx.lineTo(-w, r * 0.8);
+      ctx.lineTo(-wingW, r * 0.7); // Wing end
+      ctx.lineTo(-wingW, r * 0.2); // Wing start
+      ctx.lineTo(-w, r * 0.1);
+      ctx.lineTo(-w, -h * 0.8);
+      ctx.closePath();
+    },
+    // Variant 2: Based on Transport image
+    (ctx, r) => {
+        const h = r * 2.0; // Height (length)
+        const w = r * 0.6; // Width
+        ctx.moveTo(0, -h); // Nose
+        ctx.bezierCurveTo(w * 0.8, -h, w, -h * 0.8, w, -h * 0.6);
+        ctx.lineTo(w, h * 0.7);
+        ctx.lineTo(w * 0.8, h * 0.9);
+        ctx.lineTo(w * 0.8, h * 1.1); // right pylon
+        ctx.lineTo(w * 0.6, h * 1.1);
+        ctx.lineTo(w * 0.6, h * 0.9);
+        ctx.lineTo(-w * 0.6, h * 0.9);
+        ctx.lineTo(-w * 0.6, h * 1.1); // left pylon
+        ctx.lineTo(-w * 0.8, h * 1.1);
+        ctx.lineTo(-w * 0.8, h * 0.9);
+        ctx.lineTo(-w, h * 0.7);
+        ctx.lineTo(-w, -h * 0.6);
+        ctx.bezierCurveTo(-w, -h * 0.8, -w * 0.8, -h, 0, -h);
+        ctx.closePath();
+    },
+    // Variant 3: Based on Colony Ship v1 image
+    (ctx, r) => {
+        const h = r * 2.2;
+        const w = r * 0.3;
+        const wingW = r * 1.0;
+        const engineW = r * 0.6;
+
+        ctx.moveTo(0, -h); // Nose cone tip
+        ctx.lineTo(w, -h + r * 0.2);
+        ctx.lineTo(w, -h * 0.4);
+        ctx.lineTo(wingW, -h * 0.35); // Right solar panel
+        ctx.lineTo(wingW, -h * 0.25);
+        ctx.lineTo(w, -h * 0.2);
+        ctx.lineTo(w, h * 0.7); // Main body
+        ctx.lineTo(engineW, h * 0.8); // Right engine block
+        ctx.lineTo(engineW, h);
+        ctx.lineTo(-engineW, h);
+        ctx.lineTo(-engineW, h * 0.8);
+        ctx.lineTo(-w, h * 0.7);
+        ctx.lineTo(-w, -h * 0.2);
+        ctx.lineTo(-wingW, -h * 0.25); // Left solar panel
+        ctx.lineTo(-wingW, -h * 0.35);
+        ctx.lineTo(-w, -h * 0.4);
+        ctx.lineTo(-w, -h + r * 0.2);
+        ctx.closePath();
+    },
+    // Variant 4: Based on Colony Ship v2 image
+    (ctx, r) => {
+        const h = r * 2.5; // Very tall
+        const w = r * 1.5; // Wide base
+
+        ctx.moveTo(0, -h); // Top center
+        ctx.lineTo(r * 0.1, -h * 0.95);
+        ctx.lineTo(r * 0.1, -h * 0.6); // Upper hull side
+        ctx.lineTo(r * 0.4, -h * 0.5); // Side module start
+        ctx.lineTo(r * 0.4, -h * 0.2);
+        ctx.lineTo(r * 0.2, -h * 0.1); // Back to main hull
+        ctx.lineTo(r * 0.2, h * 0.1);
+        ctx.lineTo(w * 0.5, h * 0.2); // Lower structure start
+        ctx.lineTo(w * 0.5, h * 0.4);
+        ctx.lineTo(w * 0.8, h * 0.5);
+        ctx.lineTo(w * 0.8, h * 0.7);
+        ctx.lineTo(w * 0.4, h * 0.9);
+        ctx.lineTo(w * 0.3, h); // Base corner
+        ctx.lineTo(-w * 0.3, h);
+        ctx.lineTo(-w * 0.4, h * 0.9);
+        ctx.lineTo(-w * 0.8, h * 0.7);
+        ctx.lineTo(-w * 0.8, h * 0.5);
+        ctx.lineTo(-w * 0.5, h * 0.4);
+        ctx.lineTo(-w * 0.5, h * 0.2);
+        ctx.lineTo(-r * 0.2, h * 0.1);
+        ctx.lineTo(-r * 0.2, -h * 0.1);
+        ctx.lineTo(-r * 0.4, -h * 0.2);
+        ctx.lineTo(-r * 0.4, -h * 0.5);
+        ctx.lineTo(-r * 0.1, -h * 0.6);
+        ctx.lineTo(-r * 0.1, -h * 0.95);
+        ctx.closePath();
+    },
+  ],
+  MINER: [
+    // Based on Mining Vessel image
+    (ctx, r) => {
+        const h = r * 1.8; // Height (length)
+        const w = r * 0.8; // Width
+        ctx.moveTo(0, -h * 0.8); // Front middle top
+        ctx.lineTo(w * 0.2, -h); // Front right tooth tip
+        ctx.lineTo(w * 0.3, -h * 0.7);
+        ctx.lineTo(w * 0.5, -h * 0.9); // Front right 2nd tooth
+        ctx.lineTo(w * 0.6, -h * 0.6);
+        ctx.lineTo(w, -h * 0.5); // Right side wing/pod start
+        ctx.lineTo(w, h * 0.4);
+        ctx.lineTo(w * 1.2, h * 0.5); // Right side wing/pod end
+        ctx.lineTo(w * 1.2, h * 0.8);
+        ctx.lineTo(w * 0.8, h); // Right rear
+        ctx.lineTo(-w * 0.8, h); // Left rear
+        ctx.lineTo(-w * 1.2, h * 0.8);
+        ctx.lineTo(-w * 1.2, h * 0.5); // Left side wing/pod end
+        ctx.lineTo(-w, h * 0.4);
+        ctx.lineTo(-w, -h * 0.5); // Left side wing/pod start
+        ctx.lineTo(-w * 0.6, -h * 0.6);
+        ctx.lineTo(-w * 0.5, -h * 0.9); // Left front 2nd tooth
+        ctx.lineTo(-w * 0.3, -h * 0.7);
+        ctx.lineTo(-w * 0.2, -h); // Left front tooth tip
+        ctx.closePath();
+    }
+  ],
+  UTILITY: [
+    // Simple circle for shuttles/runabouts
+    (ctx, r) => {
+      ctx.arc(0, 0, r, 0, Math.PI * 2);
+    },
+  ],
+};
+
+// --- Ship Class Interface ---
+export interface ShipClass {
+  name: string;
+  category:
+    | 'Capital'
+    | 'Cruiser'
+    | 'Escort'
+    | 'Support'
+    | 'Small Craft'
+    | 'Exploration & Science'
+    | 'Commerce & Logistics'
+    | 'Resource Extraction'
+    | 'Diplomatic & Civil';
+  shape: (ctx: CanvasRenderingContext2D, r: number) => void;
+  radius: number;
+  color: string;
+  accentColor: string;
+}
+
+// --- Ship Class Definitions ---
+// A registry of all available ship classes in the simulation.
+// The `shape` property here is a string key to look up variants in SHAPES.
+export const SHIP_CLASS_TEMPLATES: Record<string, Omit<ShipClass, 'shape' | 'accentColor'> & { shapeKey: keyof typeof SHAPES }> = {
+  // --- Military Classes ---
+  Dreadnought: { name: 'Dreadnought', category: 'Capital', shapeKey: 'CAPITAL', radius: 4.5, color: '#3E4A61' },
+  Battleship: { name: 'Battleship', category: 'Capital', shapeKey: 'CAPITAL', radius: 4.0, color: '#4E5A71' },
+  Carrier: { name: 'Carrier', category: 'Capital', shapeKey: 'CAPITAL', radius: 4.2, color: '#5E6A81' },
+  HeavyCruiser: { name: 'Heavy Cruiser', category: 'Cruiser', shapeKey: 'CRUISER', radius: 3.0, color: '#4A617A' },
+  LightCruiser: { name: 'Light Cruiser', category: 'Cruiser', shapeKey: 'CRUISER', radius: 2.5, color: '#5A718A' },
+  Battlecruiser: { name: 'Battlecruiser', category: 'Cruiser', shapeKey: 'CRUISER', radius: 3.5, color: '#6A819A' },
+  Destroyer: { name: 'Destroyer', category: 'Escort', shapeKey: 'ESCORT', radius: 2.0, color: '#516E5A' },
+  Frigate: { name: 'Frigate', category: 'Escort', shapeKey: 'ESCORT', radius: 1.8, color: '#617E6A' },
+  Corvette: { name: 'Corvette', category: 'Escort', shapeKey: 'ESCORT', radius: 1.5, color: '#718E7A' },
+  Monitor: { name: 'Monitor', category: 'Support', shapeKey: 'SUPPORT', radius: 3.2, color: '#7E7A61' },
+  TroopTransport: { name: 'Troop Transport', category: 'Support', shapeKey: 'SUPPORT', radius: 3.0, color: '#8E8A71' },
+  Fighter: { name: 'Fighter', category: 'Small Craft', shapeKey: 'FIGHTER', radius: 1.0, color: '#6A5A7A' },
+  Bomber: { name: 'Bomber', category: 'Small Craft', shapeKey: 'FIGHTER', radius: 1.2, color: '#7A6A8A' },
+
+  // --- Peaceful Classes ---
+  // Exploration & Science
+  Explorer: { name: 'Explorer', category: 'Exploration & Science', shapeKey: 'CRUISER', radius: 3.2, color: '#3E5E6B' },
+  ScienceFrigate: { name: 'Science Frigate', category: 'Exploration & Science', shapeKey: 'ESCORT', radius: 2.2, color: '#4E6E7B' },
+  Pathfinder: { name: 'Pathfinder', category: 'Exploration & Science', shapeKey: 'FIGHTER', radius: 1.3, color: '#5E7E8B' },
+  // Commerce & Logistics
+  Hauler: { name: 'Hauler', category: 'Commerce & Logistics', shapeKey: 'SUPPORT', radius: 5.0, color: '#555555' },
+  ColonyShip: { name: 'Colony Ship', category: 'Commerce & Logistics', shapeKey: 'SUPPORT', radius: 4.0, color: '#666666' },
+  Shuttle: { name: 'Shuttle', category: 'Commerce & Logistics', shapeKey: 'UTILITY', radius: 1.0, color: '#DDDDDD' },
+  // Resource Extraction
+  MiningVessel: { name: 'Mining Vessel', category: 'Resource Extraction', shapeKey: 'MINER', radius: 4.0, color: '#6F554A' },
+  GasMiner: { name: 'Gas Miner', category: 'Resource Extraction', shapeKey: 'MINER', radius: 4.5, color: '#7F655A' },
+  SalvageShip: { name: 'Salvage Ship', category: 'Resource Extraction', shapeKey: 'MINER', radius: 3.5, color: '#8F756A' },
+  // Diplomatic & Civil
+  DiplomaticCourier: { name: 'Diplomatic Courier', category: 'Diplomatic & Civil', shapeKey: 'ESCORT', radius: 2.0, color: '#FFFFFF' },
+  HospitalShip: { name: 'Hospital Ship', category: 'Diplomatic & Civil', shapeKey: 'SUPPORT', radius: 4.8, color: '#BDECB6' },
+};
+
+const ACCENT_COLOR_PALETTES: Record<string, string[]> = {
+    Military: ['#FF4136', '#FF6B6B', '#C44D58'],
+    Exploration: ['#39CCCC', '#3D9970', '#20B2AA'],
+    Commerce: ['#AAAAAA', '#F0E68C', '#DDDDDD'],
+    Extraction: ['#85144b', '#FF851B', '#BDBDBD'],
+    Civil: ['#FFFFFF', '#2ECC40', '#0074D9'],
+}
+
+/**
+ * Returns a random ship class with a specific shape variant selected.
+ * @returns {ShipClass} A random ship class instance.
+ */
+export function getRandomShipClass(): ShipClass {
+    const classKeys = Object.keys(SHIP_CLASS_TEMPLATES);
+    const randomKey = classKeys[Math.floor(Math.random() * classKeys.length)];
+    const template = SHIP_CLASS_TEMPLATES[randomKey];
+
+    const shapeVariants = SHAPES[template.shapeKey];
+    const randomShape = shapeVariants[Math.floor(Math.random() * shapeVariants.length)];
+
+    let accentPalette: string[];
+    switch (template.category) {
+        case 'Capital':
+        case 'Cruiser':
+        case 'Escort':
+        case 'Support': // Military support
+        case 'Small Craft':
+            accentPalette = ACCENT_COLOR_PALETTES.Military;
+            break;
+        case 'Exploration & Science':
+            accentPalette = ACCENT_COLOR_PALETTES.Exploration;
+            break;
+        case 'Commerce & Logistics':
+            accentPalette = ACCENT_COLOR_PALETTES.Commerce;
+            break;
+        case 'Resource Extraction':
+            accentPalette = ACCENT_COLOR_PALETTES.Extraction;
+            break;
+        case 'Diplomatic & Civil':
+            accentPalette = ACCENT_COLOR_PALETTES.Civil;
+            break;
+        default:
+            accentPalette = ['#FFFFFF'];
+    }
+    const randomAccent = accentPalette[Math.floor(Math.random() * accentPalette.length)];
+
+    return {
+        ...template,
+        shape: randomShape,
+        accentColor: randomAccent,
+    };
+}
+
+
+// --- Starship Configuration ---
+export const STARSHIP_CONFIG = {
+    COUNT: 30,
+    MIN_SPEED: 0.22,
+    MAX_SPEED: 0.3,
+    ACCELERATION: 0.01,
+    DOCKING_DISTANCE: 1,
+    DOCK_DURATION_MIN: 120, // 2 seconds in frames
+    DOCK_DURATION_VARIANCE: 300, // 2-7 seconds in frames
+    TRAIL_LENGTH: 20,
+    WARP_CHANCE: 0.05,
+    WARP_SPEED_MULTIPLIER: 10,
+    WARP_TRAIL_LENGTH_MULTIPLIER: 3,
+    FORMATION_PADDING: 10, // Extra padding for the fleet's bounding circle
+    FLEE_DISTANCE: 50,
+    FLEE_ACCELERATION: 0.05,
+    FLEE_DURATION: 180, // 3 seconds in frames
+    HOVER_RADIUS_MULTIPLIER: 5,
+    HOVER_GLOW_COLOR: 'rgba(255, 255, 255, 0.7)',
+    HOVER_GLOW_WIDTH: 1.5,
+    HOVER_TIMEOUT: 120, // 2 seconds in frames
+    REFORM_ACCELERATION: 0.05,
+    REFORM_SPEED_MULTIPLIER: 2.0,
+};
+
+export type ShipState = 'IDLE' | 'TRAVELING' | 'DOCKING' | 'WARPING' | 'ORBITING' | 'FLEEING' | 'IN_FORMATION';
+
+let starshipCounter = 0;
+
+export class Starship extends BoundedBody implements Hoverable {
+    id: number;
+    name: string;
+    shipClass: ShipClass;
+    radius: number;
+    target: DockingPoint | null;
+    rotation: number;
+    state: ShipState;
+    stateTimer: number;
+    currentMaxSpeed: number;
+    isHovered: boolean = false;
+    hoverRadius: number;
+    hoverTimer: number;
+    fleet: Fleet | null;
+    private debugController: DebugController;
+
+    // Orbit properties
+    orbit: Orbit | null;
+    orbitAngle: number;
+    orbitSpeed: number;
+
+    // Warp properties
+    private warpTotalDistance: number;
+    private warpDistanceTraveled: number;
+    
+    constructor(x: number, y: number, debugController: DebugController) {
+        const shipClass = getRandomShipClass();
+        super(x, y, shipClass.radius);
+        this.id = ++starshipCounter;
+        this.name = `SS-${this.id}`;
+        this.shipClass = shipClass;
+        this.radius = shipClass.radius;
+        this.boundingRadius = shipClass.radius;
+        this.target = null;
+        this.rotation = 0;
+        this.state = 'IDLE';
+        this.stateTimer = this.getNewIdleTime();
+        this.currentMaxSpeed = this.getNewMaxSpeed();
+        this.hoverRadius = this.boundingRadius * STARSHIP_CONFIG.HOVER_RADIUS_MULTIPLIER;
+        this.hoverTimer = 0;
+        this.fleet = null;
+        this.debugController = debugController;
+
+        this.orbit = null;
+        this.orbitAngle = 0;
+        this.orbitSpeed = (Math.random() * 0.02 + 0.005) * (Math.random() > 0.5 ? 1 : -1);
+        
+        this.warpTotalDistance = 0;
+        this.warpDistanceTraveled = 0;
+    }
+
+    private getNewMaxSpeed(): number {
+        return Math.random() * (STARSHIP_CONFIG.MAX_SPEED - STARSHIP_CONFIG.MIN_SPEED) + STARSHIP_CONFIG.MIN_SPEED;
+    }
+
+    isAvailable(): boolean {
+        return this.state === 'IDLE';
+    }
+
+    private getNewIdleTime(): number {
+        return Math.random() * STARSHIP_CONFIG.DOCK_DURATION_VARIANCE + STARSHIP_CONFIG.DOCK_DURATION_MIN;
+    }
+
+    findNewTarget(starsWithDocks: Star[]) {
+        if (starsWithDocks.length === 0 || this.state === 'IN_FORMATION') {
+            this.target = null;
+            return;
+        }
+
+        this.currentMaxSpeed = this.getNewMaxSpeed();
+
+        const currentTargetParent = this.target ? this.target.parent : null;
+        
+        const eligibleStars = starsWithDocks.filter(s => s !== currentTargetParent);
+        const targetStars = eligibleStars.length > 0 ? eligibleStars : starsWithDocks;
+        
+        if (targetStars.length === 0) {
+            this.target = null;
+            return;
+        }
+
+        const randomStar = targetStars[Math.floor(Math.random() * targetStars.length)];
+        
+        if (randomStar.dockingPoints.length > 0) {
+            this.target = randomStar.dockingPoints[Math.floor(Math.random() * randomStar.dockingPoints.length)];
+        }
+
+
+        if (Math.random() < STARSHIP_CONFIG.WARP_CHANCE && this.target) {
+            this.enterWarpState(this.target);
+        } else {
+            this.state = 'TRAVELING';
+        }
+    }
+    
+    enterWarpState(target: DockingPoint) {
+        this.state = 'WARPING';
+        this.target = target;
+        const { x: targetX, y: targetY } = this.target.getAbsolutePosition();
+        const dx = targetX - this.x;
+        const dy = targetY - this.y;
+        this.warpTotalDistance = Math.sqrt(dx * dx + dy * dy);
+        this.warpDistanceTraveled = 0;
+
+        const angle = Math.atan2(dy, dx);
+        const targetSpeed = this.currentMaxSpeed * STARSHIP_CONFIG.WARP_SPEED_MULTIPLIER;
+        this.vx = Math.cos(angle) * targetSpeed;
+        this.vy = Math.sin(angle) * targetSpeed;
+        this.rotation = Math.atan2(this.vy, this.vx) + Math.PI / 2;
+    }
+
+    private updateDocking() {
+        this.stateTimer--;
+
+        if (this.target) {
+            const { x: targetX, y: targetY } = this.target.getAbsolutePosition();
+            this.x = targetX;
+            this.y = targetY;
+        }
+
+        if (this.stateTimer <= 0) {
+             this.state = 'IDLE';
+             this.stateTimer = this.getNewIdleTime();
+        }
+    }
+
+    private updateOrbiting(deltaTime: number) {
+        this.stateTimer--;
+        if (!this.orbit || !this.orbit.parent) {
+             this.state = 'IDLE';
+             this.stateTimer = this.getNewIdleTime();
+             return;
+        }
+
+        this.orbitAngle += this.orbitSpeed * deltaTime;
+        
+        const parentStar = this.orbit.parent;
+        this.x = parentStar.x + Math.cos(this.orbitAngle) * this.orbit.radius;
+        this.y = parentStar.y + Math.sin(this.orbitAngle) * this.orbit.radius;
+        this.rotation = this.orbitAngle + Math.PI / 2;
+
+        if (this.stateTimer <= 0) {
+            this.state = 'IDLE';
+            this.stateTimer = this.getNewIdleTime();
+            this.orbit = null;
+        }
+    }
+
+    public accelerateToPosition(targetX: number, targetY: number) {
+        const desiredVectorX = targetX - this.x;
+        const desiredVectorY = targetY - this.y;
+        const dist = Math.sqrt(desiredVectorX * desiredVectorX + desiredVectorY * desiredVectorY);
+    
+        const maxSpeed = this.currentMaxSpeed * STARSHIP_CONFIG.REFORM_SPEED_MULTIPLIER;
+        const slowingRadius = 15;
+        let desiredSpeed = maxSpeed;
+    
+        if (dist < slowingRadius) {
+            // A non-linear easing function for deceleration
+            const factor = (slowingRadius - dist) / slowingRadius; // 0 at edge, 1 at center
+            const easedFactor = 1 - (1 - factor) * (1 - factor); // Ease-in quad
+            desiredSpeed = maxSpeed * (1 - easedFactor);
+            desiredSpeed = Math.max(desiredSpeed, STARSHIP_CONFIG.MIN_SPEED * 2);
+        }
+    
+        const desiredVx = (desiredVectorX / dist) * desiredSpeed;
+        const desiredVy = (desiredVectorY / dist) * desiredSpeed;
+    
+        const steerX = desiredVx - this.vx;
+        const steerY = desiredVy - this.vy;
+    
+        // Apply the steering force, capped at max acceleration
+        this.vx += steerX * STARSHIP_CONFIG.REFORM_ACCELERATION;
+        this.vy += steerY * STARSHIP_CONFIG.REFORM_ACCELERATION;
+    
+        // Update rotation to match velocity
+        if (Math.abs(this.vx) > 0.01 || Math.abs(this.vy) > 0.01) {
+            this.rotation = Math.atan2(this.vy, this.vx) + Math.PI / 2;
+        }
+    
+        this.x += this.vx;
+        this.y += this.vy;
+    }
+
+
+    private updateTraveling(width: number, height: number) {
+        if (!this.target) {
+            this.state = 'IDLE';
+            this.stateTimer = this.getNewIdleTime();
+            return;
+        }
+
+        const { x: targetX, y: targetY } = this.target.getAbsolutePosition();
+        const dx = targetX - this.x;
+        const dy = targetY - this.y;
+        const dist = Math.sqrt(dx * dx + dy * dy);
+
+        if (dist < STARSHIP_CONFIG.DOCKING_DISTANCE) { 
+            this.state = 'ORBITING';
+            this.stateTimer = this.getNewIdleTime();
+
+            const parentStar = this.target.parent as Star;
+            const targetOrbit = parentStar.orbits.find(o => o.dockingPoints.includes(this.target!));
+
+            if (targetOrbit) {
+                this.orbit = targetOrbit;
+                this.orbitAngle = Math.atan2(dy, dx);
+                this.orbitSpeed = (Math.random() * 0.02 + 0.005) * (Math.random() > 0.5 ? 1 : -1);
+            } else {
+                this.state = 'DOCKING';
+            }
+        } else {
+            const angle = Math.atan2(dy, dx);
+            this.vx += Math.cos(angle) * STARSHIP_CONFIG.ACCELERATION;
+            this.vy += Math.sin(angle) * STARSHIP_CONFIG.ACCELERATION;
+
+            const speed = Math.sqrt(this.vx * this.vx + this.vy * this.vy);
+            if (speed > this.currentMaxSpeed) {
+                this.vx = (this.vx / speed) * this.currentMaxSpeed;
+                this.vy = (this.vy / speed) * this.currentMaxSpeed;
+            }
+            this.rotation = Math.atan2(this.vy, this.vx) + Math.PI / 2;
+        }
+        
+        this.x += this.vx;
+        this.y += this.vy;
+    }
+
+    private updateWarping() {
+        if (!this.target) {
+            this.state = 'TRAVELING';
+            return;
+        }
+    
+        const { x: targetX, y: targetY } = this.target.getAbsolutePosition();
+        const distToTarget = Math.sqrt(
+            (targetX - this.x) ** 2 +
+            (targetY - this.y) ** 2
+        );
+        const travelSpeed = Math.sqrt(this.vx**2 + this.vy**2);
+        this.warpDistanceTraveled += travelSpeed;
+        
+        if (this.warpDistanceTraveled >= this.warpTotalDistance || distToTarget < travelSpeed) {
+             this.state = 'TRAVELING';
+             this.warpTotalDistance = 0;
+             this.warpDistanceTraveled = 0;
+             const angle = Math.atan2(this.vy, this.vx);
+             this.vx = Math.cos(angle) * this.currentMaxSpeed;
+             this.vy = Math.sin(angle) * this.currentMaxSpeed;
+             return;
+        }
+
+        this.x += this.vx;
+        this.y += this.vy;
+    }
+    
+    private updateFleeing(mouse: { x: number; y: number }) {
+        this.stateTimer--;
+        if (this.stateTimer <= 0) {
+            this.state = 'IDLE';
+            this.stateTimer = this.getNewIdleTime();
+            return;
+        }
+        
+        const dx = this.x - mouse.x;
+        const dy = this.y - mouse.y;
+        const angle = Math.atan2(dy, dx);
+
+        this.vx += Math.cos(angle) * STARSHIP_CONFIG.FLEE_ACCELERATION;
+        this.vy += Math.sin(angle) * STARSHIP_CONFIG.FLEE_ACCELERATION;
+
+        const speed = Math.sqrt(this.vx * this.vx + this.vy * this.vy);
+        if (speed > this.currentMaxSpeed * 2) { // Flee faster
+            this.vx = (this.vx / speed) * this.currentMaxSpeed * 2;
+            this.vy = (this.vy / speed) * this.currentMaxSpeed * 2;
+        }
+        this.rotation = Math.atan2(this.vy, this.vx) + Math.PI / 2;
+
+        this.x += this.vx;
+        this.y += this.vy;
+    }
+
+    update(ctx: CanvasRenderingContext2D, width: number, height: number, mouse: {x: number, y: number}, deltaTime: number) {
+        if (DEBUG_CONFIG.SHOW_DEBUG_INFO && DEBUG_CONFIG.SHOW_STARSHIP_TARGET_LINE && this.target && this.debugController) {
+            this.debugController.registerDirectionalLine(this, this.target.getAbsolutePosition(), { drawLine: true, showDistance: true });
+        }
+
+        if (this.state === 'IN_FORMATION') {
+            // When in formation, movement is controlled by the Fleet class.
+            // But we still need to apply the final velocity to the position.
+            this.x += this.vx;
+            this.y += this.vy;
+            return;
+        }
+
+        if (this.state === 'IDLE') {
+            this.stateTimer--;
+            // Target finding is now handled by the controller
+        }
+        
+        switch (this.state) {
+            case 'DOCKING':
+                this.updateDocking();
+                break;
+            case 'ORBITING':
+                this.updateOrbiting(deltaTime);
+                return;
+            case 'TRAVELING':
+                this.updateTraveling(width, height);
+                break;
+            case 'WARPING':
+                this.updateWarping();
+                break;
+            case 'FLEEING':
+                this.updateFleeing(mouse);
+                break;
+        }
+        
+        if (['TRAVELING', 'WARPING', 'FLEEING'].includes(this.state)) {
+            if (this.x < -this.boundingRadius) this.x = width + this.boundingRadius;
+            if (this.x > width + this.boundingRadius) this.x = -this.boundingRadius;
+            if (this.y < -this.boundingRadius) this.y = height + this.boundingRadius;
+            if (this.y > height + this.boundingRadius) this.y = -this.boundingRadius;
+        }
+    }
+    
+    private drawWarpTrail(ctx: CanvasRenderingContext2D) {
+        const trailLength = this.radius * STARSHIP_CONFIG.WARP_TRAIL_LENGTH_MULTIPLIER * 5;
+        const warpProgress = this.warpDistanceTraveled / this.warpTotalDistance;
+        let currentTrailLength = 0;
+
+        if (warpProgress < 0.1) {
+            currentTrailLength = trailLength * (warpProgress / 0.1);
+        } else if (warpProgress > 0.9) {
+            currentTrailLength = trailLength * ((1 - warpProgress) / 0.1);
+        } else {
+            return;
+        }
+        
+        if (currentTrailLength <= 0) return;
+        
+        ctx.save();
+        ctx.translate(this.x, this.y);
+        ctx.rotate(this.rotation);
+
+        const shapeFn = this.shipClass.shape;
+        if (shapeFn) {
+            ctx.fillStyle = this.shipClass.color;
+            shapeFn(ctx, this.radius);
+            ctx.fill();
+        }
+
+        const gradient = ctx.createLinearGradient(0, this.radius, 0, -currentTrailLength);
+        const color = this.shipClass.color;
+        
+        const r = parseInt(color.slice(1, 3), 16);
+        const g = parseInt(color.slice(3, 5), 16);
+        const b = parseInt(color.slice(5, 7), 16);
+        
+        gradient.addColorStop(0, `rgba(${r},${g},${b}, 0.7)`);
+        gradient.addColorStop(1, `rgba(${r},${g},${b}, 0)`);
+        
+        ctx.fillStyle = gradient;
+        ctx.beginPath();
+        ctx.moveTo(this.radius, this.radius);
+        ctx.lineTo(-this.radius, this.radius);
+        ctx.lineTo(0, -currentTrailLength);
+        ctx.closePath();
+        ctx.fill();
+
+        ctx.restore();
+    }
+    
+    private drawDebugInfo(ctx: CanvasRenderingContext2D) {
+        const startX = this.x + this.hoverRadius + 15;
+        const boxPadding = 10;
+        const lineHeight = 14;
+        const infoLines = [
+            `Name: ${this.name}`,
+            `Class: ${this.shipClass.name} (${this.shipClass.category})`,
+            `State: ${this.state} (${Math.ceil(this.stateTimer)})`,
+            `Target: ${this.target ? `${(this.target.parent as Star).name} (DP: ${this.target.id})` : 'None'}`,
+            `Position: (${this.x.toFixed(0)}, ${this.y.toFixed(0)})`,
+            `Velocity: (${this.vx.toFixed(2)}, ${this.vy.toFixed(2)})`,
+            `Max Speed: ${this.currentMaxSpeed.toFixed(2)}`,
+        ];
+
+        const boxHeight = infoLines.length * lineHeight + boxPadding * 2;
+        const boxWidth = Math.max(...infoLines.map(line => ctx.measureText(line).width)) + boxPadding * 2;
+        const boxY = this.y - boxHeight / 2;
+
+        ctx.fillStyle = 'rgba(0, 0, 0, 0.7)';
+        ctx.strokeStyle = this.shipClass.accentColor;
+        ctx.lineWidth = 1;
+        ctx.beginPath();
+        ctx.roundRect(startX, boxY, boxWidth, boxHeight, 5);
+        ctx.fill();
+        ctx.stroke();
+
+        ctx.fillStyle = 'white';
+        ctx.font = '10px "Roboto Mono", monospace';
+        ctx.textAlign = 'left';
+        ctx.textBaseline = 'top';
+
+        infoLines.forEach((line, index) => {
+            ctx.fillText(line, startX + boxPadding, boxY + boxPadding + index * lineHeight);
+        });
+    }
+
+    draw(ctx: CanvasRenderingContext2D) {
+        if (this.state === 'WARPING') {
+            this.drawWarpTrail(ctx);
+            return; // Skip other drawing logic for warp
+        }
+        
+        this.isHovered = this.hoverTimer > 0;
+        const isInFleet = this.state === 'IN_FORMATION';
+
+        ctx.save();
+        ctx.translate(this.x, this.y);
+        ctx.rotate(this.rotation);
+
+        const shapeFn = this.shipClass.shape;
+
+        if (this.isHovered && shapeFn) {
+            ctx.strokeStyle = STARSHIP_CONFIG.HOVER_GLOW_COLOR;
+            ctx.lineWidth = STARSHIP_CONFIG.HOVER_GLOW_WIDTH;
+            ctx.shadowColor = STARSHIP_CONFIG.HOVER_GLOW_COLOR;
+            ctx.shadowBlur = 10;
+            
+            ctx.beginPath();
+            shapeFn(ctx, this.radius + 1); 
+            ctx.stroke();
+            ctx.shadowBlur = 0;
+
+            if (!isInFleet && DEBUG_CONFIG.SHOW_DEBUG_INFO && DEBUG_CONFIG.SHOW_ENTITY_HOVER_INFO) {
+                // To draw the debug info panel correctly, we need to un-rotate the canvas
+                ctx.restore();
+                this.drawDebugInfo(ctx);
+                ctx.save(); // Re-save context to restore it at the end
+                ctx.translate(this.x, this.y);
+                ctx.rotate(this.rotation);
+            }
+        }
+        
+        if (shapeFn) {
+            ctx.beginPath();
+            shapeFn(ctx, this.radius);
+
+            ctx.fillStyle = this.shipClass.color;
+            ctx.fill();
+
+            ctx.strokeStyle = this.shipClass.accentColor;
+            ctx.lineWidth = 0.5;
+            ctx.stroke();
+            
+            if (this.fleet) {
+                ctx.strokeStyle = this.fleet.clan.color;
+                ctx.lineWidth = 0.25;
+                ctx.stroke();
+            }
+        }
+
+        ctx.restore();
+
+        if (DEBUG_CONFIG.SHOW_DEBUG_INFO && !this.fleet) {
+            ctx.save();
+            ctx.fillStyle = 'rgba(255, 255, 255, 0.5)';
+            ctx.font = '8px "Roboto Mono", monospace';
+            ctx.textAlign = 'center';
+            ctx.fillText(this.state, this.x, this.y + this.radius + 8);
+            ctx.restore();
+        }
+    }
+}