@where-stars-drift/core 1.0.0

package/src/base/hoverable.ts

@@ -0,0 +1,11 @@
+/**
+ * @fileoverview Defines the Hoverable interface for objects that can be hovered.
+ */
+
+export interface Hoverable {
+  x: number;
+  y: number;
+  isHovered: boolean;
+  hoverTimer: number;
+  hoverRadius: number;
+}

package/src/base/massive-body.ts

@@ -0,0 +1,14 @@
+/**
+ * @fileoverview Defines the abstract base class for all celestial bodies that have mass.
+ */
+
+import { BoundedBody } from './bounded-body';
+
+export abstract class MassiveBody extends BoundedBody {
+  mass: number;
+
+  constructor(x: number, y: number, boundingRadius: number, mass: number) {
+    super(x, y, boundingRadius);
+    this.mass = mass;
+  }
+}

package/src/config/effects.ts

@@ -0,0 +1,15 @@
+/**
+ * @fileoverview Centralized configuration for visual effects in the simulation.
+ */
+
+export const EFFECTS_CONFIG = {
+  /**
+   * If true, renders the energy streams flowing between two interacting black holes.
+   */
+  RENDER_INTER_HOLE_STREAMS: true,
+  /**
+   * If true, renders the energy streams from stars that are being consumed by a black hole.
+   * This is computationally expensive and can be disabled for performance.
+   */
+  RENDER_STAR_TO_HOLE_STREAMS: true,
+};

package/src/config/grid.ts

@@ -0,0 +1,11 @@
+/**
+ * @fileoverview Centralized configuration for the sector grid.
+ */
+
+export const GRID_CONFIG = {
+  SECTOR_SIZE: 360,
+  LINE_COLOR: 'rgba(100, 120, 150, 0.2)',
+  LINE_WIDTH: 0.5,
+  FONT: '8px "Roboto Mono", monospace',
+  FONT_COLOR: 'rgba(100, 120, 150, 0.3)',
+};

package/src/config/panel.ts

@@ -0,0 +1,26 @@
+export const PANEL_CONFIG = {
+    X: 10,
+    WIDTH: 350,
+    HEIGHT_PERCENT: 0.5,
+    HEADER_HEIGHT: 40,
+    TAB_HEIGHT: 30,
+    ROW_HEIGHT: 25,
+    GROUP_HEADER_HEIGHT: 20,
+    PADDING: 10,
+    BG_COLOR: 'rgba(0, 0, 0, 0.75)',
+    BORDER_COLOR: '#555',
+    TEXT_COLOR: '#ddd',
+    ACCENT_COLOR: '#aaa',
+    TITLE_FONT: '14px "Roboto Mono", monospace',
+    TAB_FONT: '11px "Roboto Mono", monospace',
+    ROW_FONT: '12px "Roboto Mono", monospace',
+    GROUP_FONT: 'bold 12px "Roboto Mono", monospace',
+    SHIP_RENDER_SCALE: 1,
+    SCROLL_SPEED: 20,
+    TOGGLE_BUTTON: {
+        x: 15,
+        y: 5,
+        w: 120,
+        h: 22,
+    },
+};

package/src/config/simulation.ts

@@ -0,0 +1,25 @@
+/**
+ * @fileoverview Centralized configuration for the night sky simulation.
+ */
+
+// --- General Simulation ---
+export const SIMULATION_CONFIG = {
+  STARS_COUNT: 468,
+};
+
+// --- Debugging ---
+export const DEBUG_CONFIG = {
+  SHOW_DEBUG_INFO: true,
+  SHOW_ENTITY_HOVER_INFO: true, // Shows a detailed info panel on hover for individual entities
+  SHOW_STARSHIP_TARGET_LINE: true,
+  SHOW_INTER_HOLE_DISTANCE: true,
+  SHOW_FORMATION_TARGET_DOTS: false,
+  SHOW_CATALOG_PANEL: true,
+  SHOW_STARSHIP_CATALOG: true,
+  SHOW_FORMATION_CATALOG: true,
+  SHOW_CLAN_CATALOG: true,
+  SHOW_FLEET_CATALOG: true,
+  SHOW_STAR_CATALOG: true,
+  SHOW_BLACK_HOLE_CATALOG: true,
+  SHOW_QUADTREE: false,
+};

package/src/controllers/clan-controller.ts

@@ -0,0 +1,19 @@
+
+import { ClanManager } from '../entities/clan-manager';
+import type { Clan } from '../entities/clans';
+
+export class ClanController {
+    private clanManager: ClanManager;
+
+    constructor() {
+        this.clanManager = new ClanManager();
+    }
+
+    public getNextClan(): Clan {
+        return this.clanManager.getClanForNewFleet();
+    }
+
+    public getClans(): Clan[] {
+        return this.clanManager.getClans();
+    }
+}

package/src/controllers/debug-controller.ts

@@ -0,0 +1,112 @@
+/**
+ * @fileoverview Defines the DebugController for managing and drawing debug visualizations.
+ */
+
+interface Point {
+    x: number;
+    y: number;
+}
+
+interface BodyWithId extends Point {
+    id: number | string;
+}
+
+interface LineToDraw {
+    source: Point;
+    target: Point;
+    options: {
+        drawLine: boolean;
+        showDistance: boolean;
+    }
+}
+
+export class DebugController {
+    private linesToDraw: Map<string, LineToDraw>;
+
+    constructor() {
+        this.linesToDraw = new Map();
+    }
+
+    /**
+     * Resets the list of lines for the current frame.
+     */
+    public clear() {
+        this.linesToDraw.clear();
+    }
+
+    /**
+     * Registers a line to be drawn between two bodies, preventing duplicates.
+     * @param body1 The first body (source).
+     * @param body2 The second body (target).
+     * @param options Flags to control rendering.
+     */
+    public registerLine(body1: BodyWithId, body2: BodyWithId, options = { drawLine: true, showDistance: true }) {
+        // Create a unique, sorted key to prevent duplicate lines (A-B vs B-A)
+        const ids = [body1.id.toString(), body2.id.toString()].sort();
+        const lineKey = ids.join('-');
+
+        if (!this.linesToDraw.has(lineKey)) {
+            this.linesToDraw.set(lineKey, {
+                source: { x: body1.x, y: body1.y },
+                target: { x: body2.x, y: body2.y },
+                options,
+            });
+        }
+    }
+    
+    /**
+     * Registers a directional line from a source to a simple point target.
+     * Duplicates are not checked here as the source guarantees uniqueness for its own target line.
+     * @param source The source body.
+     * @param target The target point.
+     */
+    public registerDirectionalLine(source: BodyWithId, target: Point, options = { drawLine: true, showDistance: true }) {
+        const lineKey = `dir-${source.id}`;
+         this.linesToDraw.set(lineKey, { source, target, options });
+    }
+
+    private drawDebugLineWithDistance(ctx: CanvasRenderingContext2D, source: Point, target: Point, drawLine: boolean, showDistance: boolean) {
+        const dx = target.x - source.x;
+        const dy = target.y - source.y;
+        const dist = Math.sqrt(dx * dx + dy * dy);
+    
+        // Draw the dashed line if requested
+        if (drawLine) {
+            ctx.beginPath();
+            ctx.setLineDash([2, 4]);
+            ctx.moveTo(source.x, source.y);
+            ctx.lineTo(target.x, target.y);
+            ctx.strokeStyle = 'rgba(255, 255, 255, 0.2)';
+            ctx.lineWidth = 0.5;
+            ctx.stroke();
+            ctx.setLineDash([]);
+        }
+    
+        // Draw the distance text if requested
+        if (showDistance) {
+            const midX = source.x + dx / 2;
+            const midY = source.y + dy / 2;
+            ctx.fillStyle = 'rgba(255, 255, 255, 0.4)';
+            ctx.font = '10px "Roboto Mono", monospace';
+            ctx.textAlign = 'center';
+            ctx.textBaseline = 'bottom';
+            ctx.fillText(dist.toFixed(0), midX, midY - 2);
+        }
+    }
+
+    /**
+     * Draws all registered lines for the current frame.
+     * @param ctx The canvas rendering context.
+     */
+    public draw(ctx: CanvasRenderingContext2D) {
+        if (this.linesToDraw.size === 0) {
+            return;
+        }
+
+        ctx.save();
+        this.linesToDraw.forEach(({ source, target, options }) => {
+            this.drawDebugLineWithDistance(ctx, source, target, options.drawLine, options.showDistance);
+        });
+        ctx.restore();
+    }
+}

package/src/controllers/effects-controller.ts

@@ -0,0 +1,86 @@
+
+import { Supernova } from '../entities/supernova';
+import { Meteor, METEOR_CONFIG } from '../entities/meteor';
+import { STAR_CONFIG, Star } from '../entities/star';
+import { BlackHle } from '../entities/black-hole';
+import { EFFECTS_CONFIG } from '../config/effects';
+import { drawSimpleStarStream } from '../lib/simplified-stream';
+
+export class EffectsController {
+    private supernovas: Supernova[] = [];
+    private meteors: Meteor[] = [];
+    private meteorShowerCooldown: number;
+    private width: number;
+    private height: number;
+
+    constructor(width: number, height: number) {
+        this.width = width;
+        this.height = height;
+        this.meteorShowerCooldown = this.getNewMeteorCooldown();
+    }
+
+    private getNewMeteorCooldown(): number {
+        return Math.random() * METEOR_CONFIG.SHOWER_COOLDOWN_VARIANCE + METEOR_CONFIG.SHOWER_COOLDOWN_MIN;
+    }
+
+    public addSupernovas(newSupernovas: Supernova[]) {
+        this.supernovas.push(...newSupernovas);
+    }
+
+    public updateAndDrawSupernovas(ctx: CanvasRenderingContext2D) {
+        this.supernovas = this.supernovas.filter(nova => {
+            nova.update();
+            if (nova.isAlive()) {
+                nova.draw(ctx);
+                return true;
+            }
+            return false;
+        });
+    }
+
+    private spawnMeteorShower() {
+        const radiantX = Math.random() * this.width;
+        const radiantY = Math.random() * this.height * 0.5;
+        const baseAngle = Math.random() * Math.PI * 2;
+        const meteorCount = Math.random() * METEOR_CONFIG.COUNT_VARIANCE + METEOR_CONFIG.COUNT_MIN;
+        const showerColor = STAR_CONFIG.RARE_STAR_COLORS[Math.floor(Math.random() * STAR_CONFIG.RARE_STAR_COLORS.length)];
+
+        for (let i = 0; i < meteorCount; i++) {
+            const angle = baseAngle + (Math.random() - 0.5) * 0.3;
+            const speed = Math.random() * METEOR_CONFIG.SPEED_VARIANCE + METEOR_CONFIG.SPEED_MIN;
+            this.meteors.push(new Meteor(radiantX, radiantY, Math.cos(angle) * speed, Math.sin(angle) * speed, showerColor));
+        }
+    };
+
+    public updateAndDrawMeteors(ctx: CanvasRenderingContext2D) {
+        this.meteorShowerCooldown--;
+        if (this.meteorShowerCooldown <= 0) {
+            this.spawnMeteorShower();
+            this.meteorShowerCooldown = this.getNewMeteorCooldown();
+        }
+
+        this.meteors = this.meteors.filter(meteor => {
+            meteor.update();
+            if (meteor.isAlive(this.width, this.height)) {
+                meteor.draw(ctx);
+                return true;
+            }
+            return false;
+        });
+    }
+
+    public drawStarToHoleStreams(ctx: CanvasRenderingContext2D, allStars: Star[], blackHoles: BlackHle[]) {
+        if (!EFFECTS_CONFIG.RENDER_STAR_TO_HOLE_STREAMS) return;
+    
+        for (const star of allStars) {
+            for (const hole of blackHoles) {
+                const dx = hole.x - star.x;
+                const dy = hole.y - star.y;
+                const dist = Math.sqrt(dx * dx + dy * dy);
+                if (dist < hole.radius + 50) {
+                    drawSimpleStarStream(ctx, star, hole);
+                }
+            }
+        }
+    }
+}

package/src/controllers/hover-controller.ts

@@ -0,0 +1,128 @@
+
+/**
+ * @fileoverview Defines the HoverController class for managing hover states.
+ */
+import type { Hoverable } from '../base/hoverable';
+import { Starship, STARSHIP_CONFIG } from '../entities/starship';
+import { Fleet, FLEET_CONFIG } from '../entities/fleet';
+import { Star, STAR_CONFIG } from '../entities/star';
+import { BlackHole, BLACK_HOLE_CONFIG } from '../entities/black-hole';
+import { CelestialBody } from '../base/celestial-body';
+
+function isHoverable(body: any): body is Hoverable & CelestialBody {
+  return 'isHovered' in body && 'hoverTimer' in body && 'hoverRadius' in body && 'x' in body && 'y' in body;
+}
+
+export class HoverController {
+  private bodies: CelestialBody[];
+
+  constructor(bodies: CelestialBody[]) {
+    this.bodies = bodies;
+  }
+
+  public update(mouse: { x: number; y: number }, isMouseInside: boolean, debug: boolean) {
+    if (!debug) {
+      return;
+    }
+    
+    this.updateHoverStates();
+    if (isMouseInside) {
+      this.checkHoverState(mouse);
+    }
+  }
+
+  private checkHoverState(mouse: { x: number; y: number }) {
+    const allHoverables = this.bodies.filter(isHoverable);
+    
+    let hoveredShip: Starship | null = null;
+    let hoveredFleet: Fleet | null = null;
+    let hoveredStar: Hoverable | null = null;
+    let hoveredBlackHole: BlackHole | null = null;
+
+    // Prioritize smaller, more specific objects first by checking them in order.
+    // Once a hovered object is found, we stop to prevent hovering multiple objects at once.
+
+    // 1. Ships
+    for (const body of allHoverables) {
+        if (body instanceof Starship) {
+            const dx = body.x - mouse.x;
+            const dy = body.y - mouse.y;
+            const distSq = dx * dx + dy * dy;
+            if (distSq < body.hoverRadius * body.hoverRadius) {
+                hoveredShip = body;
+                break;
+            }
+        }
+    }
+
+    // 2. Fleets
+    if (!hoveredShip) {
+        for (const body of allHoverables) {
+            if (body instanceof Fleet) {
+                const dx = body.x - mouse.x;
+                const dy = body.y - mouse.y;
+                const distSq = dx * dx + dy * dy;
+                if (distSq < body.hoverRadius * body.hoverRadius) {
+                    hoveredFleet = body;
+                    break;
+                }
+            }
+        }
+    }
+    
+    // 3. Black Holes
+    if (!hoveredShip && !hoveredFleet) {
+        for (const body of allHoverables) {
+            if (body instanceof BlackHole) {
+                const dx = body.x - mouse.x;
+                const dy = body.y - mouse.y;
+                const distSq = dx * dx + dy * dy;
+                if (distSq < body.hoverRadius * body.hoverRadius) {
+                    hoveredBlackHole = body;
+                    break;
+                }
+            }
+        }
+    }
+    
+    // 4. Stars (as a fallback)
+    if (!hoveredShip && !hoveredFleet && !hoveredBlackHole) {
+        for (const body of allHoverables) {
+            if (!(body instanceof Starship) && !(body instanceof Fleet) && !(body instanceof BlackHole)) {
+                 const dx = body.x - mouse.x;
+                 const dy = body.y - mouse.y;
+                 const distSq = dx * dx + dy * dy;
+                 if (distSq < body.hoverRadius * body.hoverRadius) {
+                     hoveredStar = body;
+                     break; 
+                 }
+            }
+        }
+    }
+    
+    // Set timers for all hovered items
+    if (hoveredShip) {
+        hoveredShip.hoverTimer = STARSHIP_CONFIG.HOVER_TIMEOUT;
+    }
+    if (hoveredFleet) {
+        hoveredFleet.hoverTimer = FLEET_CONFIG.HOVER_TIMEOUT;
+    }
+     if (hoveredBlackHole) {
+        hoveredBlackHole.hoverTimer = BLACK_HOLE_CONFIG.HOVER_TIMEOUT;
+    }
+    if (hoveredStar) {
+        hoveredStar.hoverTimer = STAR_CONFIG.HOVER_TIMEOUT;
+    }
+  }
+
+  private updateHoverStates() {
+    this.bodies.forEach(obj => {
+        if (isHoverable(obj)) {
+          if (obj.hoverTimer > 0) {
+            obj.hoverTimer--;
+          }
+          obj.isHovered = obj.hoverTimer > 0;
+        }
+      });
+  }
+}

package/src/controllers/layer-controller.ts

@@ -0,0 +1,78 @@
+
+import type { CelestialBody } from '../base/celestial-body';
+
+export type Layer = {
+    name: string;
+    description: string;
+    bodies: CelestialBody[];
+    isInteractive: boolean;
+};
+
+export class LayerController {
+    private layers: Record<string, Layer> = {};
+
+    constructor() {
+        this.initializeLayers();
+    }
+
+    private initializeLayers() {
+        this.layers = {
+            backgroundNebulas: {
+                name: 'Background Nebulas',
+                description: 'Slow-moving, non-interactive nebula clouds for visual depth.',
+                bodies: [],
+                isInteractive: false,
+            },
+            sectorGrid: {
+                name: 'Sector Grid',
+                description: 'A grid of sectors that divides the map.',
+                bodies: [],
+                isInteractive: false,
+            },
+            staticStars: {
+                name: 'Static Stars',
+                description: 'A layer of stars that provides parallax but does not react to mouse interaction.',
+                bodies: [],
+                isInteractive: false,
+            },
+            interactiveStars: {
+                name: 'Interactive Stars',
+                description: 'A layer of stars that reacts to mouse movement and can be hovered.',
+                bodies: [],
+                isInteractive: true,
+            },
+            blackHoles: {
+                name: 'Black Holes',
+                description: 'Gravitational wells that affect other objects.',
+                bodies: [],
+                isInteractive: true,
+            },
+            dynamicObjects: {
+                name: 'Dynamic Objects',
+                description: 'Comets, starships, and fleets that move and interact within the simulation.',
+                bodies: [],
+                isInteractive: true,
+            },
+        };
+    }
+    
+    public getLayers(): Record<string, Layer> {
+        return this.layers;
+    }
+
+    public getLayer(layerName: string): Layer | undefined {
+        return this.layers[layerName];
+    }
+    
+    public getBodies(layerName: string): CelestialBody[] {
+        return this.layers[layerName]?.bodies || [];
+    }
+
+    public addBody(layerName: string, body: CelestialBody) {
+        if (this.layers[layerName]) {
+            this.layers[layerName].bodies.push(body);
+        } else {
+            console.warn(`Layer "${layerName}" does not exist.`);
+        }
+    }
+}