@where-stars-drift/core 1.0.0

package/dist/src/entities/ringed-planet.js

@@ -0,0 +1,68 @@
+/**
+ * @fileoverview Defines the RingedPlanet class, a specialized type of Star.
+ */
+import { Star, STAR_CONFIG } from './star';
+import { DockingPoint } from './docking-point';
+import { Ring } from './ring';
+// --- Ringed Planet Configuration ---
+export const RINGED_PLANET_CONFIG = {
+    RING_COUNT_MIN: 1,
+    RING_COUNT_MAX: 2,
+    RING_RADIUS_MULTIPLIER_MIN: 2.2,
+    RING_RADIUS_MULTIPLIER_MAX: 2.8,
+    RING_THICKNESS_MIN: 0.2,
+    RING_THICKNESS_MAX: 0.8,
+    RING_ALPHA: 0.7,
+    RING_DOTTED_CHANCE: 0.3, // Chance for a ring to be dotted
+    DOCKING_POINTS_PER_RING: 4,
+};
+let ringedPlanetCounter = 0;
+export class RingedPlanet extends Star {
+    constructor(x, y, ringCount) {
+        super(x, y);
+        this.name = `RP-${++ringedPlanetCounter}`;
+        this.rings = [];
+        this.dockingPoints = []; // A planet itself has no docking points, they are on rings/orbits.
+        this.orbits = []; // Clear star-generated orbits
+        this.hasAura = Math.random() < STAR_CONFIG.AURA_CHANCE;
+        const finalRingCount = ringCount !== undefined
+            ? ringCount
+            : Math.floor(Math.random() * (RINGED_PLANET_CONFIG.RING_COUNT_MAX - RINGED_PLANET_CONFIG.RING_COUNT_MIN + 1)) +
+                RINGED_PLANET_CONFIG.RING_COUNT_MIN;
+        let maxRingRadius = this.radius;
+        for (let i = 0; i < finalRingCount; i++) {
+            const radiusMultiplier = (Math.random() * (RINGED_PLANET_CONFIG.RING_RADIUS_MULTIPLIER_MAX - RINGED_PLANET_CONFIG.RING_RADIUS_MULTIPLIER_MIN) +
+                RINGED_PLANET_CONFIG.RING_RADIUS_MULTIPLIER_MIN) + i * 3.0; // Stagger rings
+            const ringRadius = this.radius * radiusMultiplier;
+            maxRingRadius = Math.max(maxRingRadius, ringRadius);
+            const ringColor = this.color.startsWith('rgba')
+                ? this.color.replace(/, [0-9\.]+$/, `, ${RINGED_PLANET_CONFIG.RING_ALPHA})`)
+                : `rgba(255, 255, 255, ${RINGED_PLANET_CONFIG.RING_ALPHA})`;
+            const isDotted = Math.random() < RINGED_PLANET_CONFIG.RING_DOTTED_CHANCE;
+            const ring = new Ring(this, ringRadius, Math.random() * (RINGED_PLANET_CONFIG.RING_THICKNESS_MAX - RINGED_PLANET_CONFIG.RING_THICKNESS_MIN) + RINGED_PLANET_CONFIG.RING_THICKNESS_MIN, ringColor, isDotted);
+            this.rings.push(ring);
+            // Add docking points along the rings
+            const pointsOnRing = RINGED_PLANET_CONFIG.DOCKING_POINTS_PER_RING;
+            for (let j = 0; j < pointsOnRing; j++) {
+                const angle = (j / pointsOnRing) * Math.PI * 2;
+                const dx = Math.cos(angle) * ringRadius;
+                const dy = Math.sin(angle) * ringRadius;
+                this.dockingPoints.push(new DockingPoint(this, dx, dy));
+            }
+        }
+        // Update hoverRadius to encompass the rings
+        this.hoverRadius = maxRingRadius + 10;
+    }
+    draw(ctx, pulseTime) {
+        // Call the parent draw method to draw the planet body itself on top
+        this.drawBase(ctx, pulseTime);
+        // Draw rings 
+        this.rings.forEach(ring => {
+            ring.draw(ctx);
+        });
+        // Draw orbits
+        this.orbits.forEach(orbit => {
+            orbit.draw(ctx);
+        });
+    }
+}

package/dist/src/entities/sector-grid.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @fileoverview Defines the SectorGrid class for the background grid.
+ */
+import { CelestialBody } from '../base/celestial-body';
+export declare class SectorGrid extends CelestialBody {
+    private numCols;
+    private numRows;
+    private sectorWidth;
+    private sectorHeight;
+    private width;
+    private height;
+    constructor(width: number, height: number);
+    resize(width: number, height: number): void;
+    update(context: CanvasRenderingContext2D, width: number, height: number): void;
+    draw(ctx: CanvasRenderingContext2D): void;
+}

package/dist/src/entities/sector-grid.js

@@ -0,0 +1,70 @@
+/**
+ * @fileoverview Defines the SectorGrid class for the background grid.
+ */
+import { CelestialBody } from '../base/celestial-body';
+import { GRID_CONFIG } from '../config/grid';
+export class SectorGrid extends CelestialBody {
+    constructor(width, height) {
+        super(0, 0);
+        this.numCols = 0;
+        this.numRows = 0;
+        this.sectorWidth = 0;
+        this.sectorHeight = 0;
+        this.width = 0;
+        this.height = 0;
+        this.resize(width, height);
+    }
+    resize(width, height) {
+        this.width = width;
+        this.height = height;
+        this.numCols = Math.ceil(width / GRID_CONFIG.SECTOR_SIZE);
+        this.numRows = Math.ceil(height / GRID_CONFIG.SECTOR_SIZE);
+        this.sectorWidth = width / this.numCols;
+        this.sectorHeight = height / this.numRows;
+    }
+    update(context, width, height) {
+        // update width/height in case it changed and resize wasn't called (defensive)
+        if (this.width !== width || this.height !== height) {
+            this.resize(width, height);
+        }
+    }
+    draw(ctx) {
+        if (this.width === 0 || this.height === 0)
+            return;
+        ctx.save();
+        ctx.strokeStyle = GRID_CONFIG.LINE_COLOR;
+        ctx.lineWidth = GRID_CONFIG.LINE_WIDTH;
+        ctx.setLineDash([2, 4]);
+        // Draw vertical lines
+        for (let i = 1; i < this.numCols; i++) {
+            const x = i * this.sectorWidth;
+            ctx.beginPath();
+            ctx.moveTo(x, 0);
+            ctx.lineTo(x, this.height);
+            ctx.stroke();
+        }
+        // Draw horizontal lines
+        for (let i = 1; i < this.numRows; i++) {
+            const y = i * this.sectorHeight;
+            ctx.beginPath();
+            ctx.moveTo(0, y);
+            ctx.lineTo(this.width, y);
+            ctx.stroke();
+        }
+        ctx.setLineDash([]);
+        // Draw sector names
+        ctx.fillStyle = GRID_CONFIG.FONT_COLOR;
+        ctx.font = GRID_CONFIG.FONT;
+        ctx.textAlign = 'center';
+        ctx.textBaseline = 'middle';
+        for (let row = 0; row < this.numRows; row++) {
+            for (let col = 0; col < this.numCols; col++) {
+                const sectorName = `${String.fromCharCode(65 + row)}-${col + 1}`;
+                const centerX = col * this.sectorWidth + this.sectorWidth / 2;
+                const centerY = row * this.sectorHeight + this.sectorHeight / 2;
+                ctx.fillText(sectorName, centerX, centerY);
+            }
+        }
+        ctx.restore();
+    }
+}

package/dist/src/entities/star-factory.d.ts

@@ -0,0 +1,29 @@
+import { Star } from './star';
+import { Pulsar } from './pulsar';
+import { RingedPlanet } from './ringed-planet';
+interface StarOptions {
+    radius?: number;
+    hasAura?: boolean;
+}
+interface RingedPlanetOptions {
+    ringCount?: number;
+}
+export declare class StarFactory {
+    /**
+     * Creates a star of a random type (Standard, Pulsar, or Ringed Planet).
+     */
+    createRandomStar(x: number, y: number): Star;
+    /**
+     * Creates a standard star.
+     */
+    createStar(x: number, y: number, options?: StarOptions): Star;
+    /**
+     * Creates a pulsar star.
+     */
+    createPulsar(x: number, y: number): Pulsar;
+    /**
+     * Creates a ringed planet.
+     */
+    createRingedPlanet(x: number, y: number, options?: RingedPlanetOptions): RingedPlanet;
+}
+export {};

package/dist/src/entities/star-factory.js

@@ -0,0 +1,47 @@
+import { Star } from './star';
+import { Pulsar } from './pulsar';
+import { RingedPlanet } from './ringed-planet';
+export class StarFactory {
+    /**
+     * Creates a star of a random type (Standard, Pulsar, or Ringed Planet).
+     */
+    createRandomStar(x, y) {
+        const rand = Math.random();
+        if (rand < 0.02) {
+            return this.createPulsar(x, y);
+        }
+        else if (rand < 0.02 + 0.03) {
+            return this.createRingedPlanet(x, y);
+        }
+        else {
+            return this.createStar(x, y);
+        }
+    }
+    /**
+     * Creates a standard star.
+     */
+    createStar(x, y, options = {}) {
+        const star = new Star(x, y);
+        if (options.radius) {
+            star.radius = options.radius;
+            star.baseRadius = options.radius;
+        }
+        if (options.hasAura !== undefined) {
+            star.hasAura = options.hasAura;
+        }
+        return star;
+    }
+    /**
+     * Creates a pulsar star.
+     */
+    createPulsar(x, y) {
+        return new Pulsar(x, y);
+    }
+    /**
+     * Creates a ringed planet.
+     */
+    createRingedPlanet(x, y, options = {}) {
+        const planet = new RingedPlanet(x, y, options.ringCount);
+        return planet;
+    }
+}

package/dist/src/entities/star.d.ts

@@ -0,0 +1,48 @@
+/**
+ * @fileoverview Defines the Star class for the night sky simulation.
+ */
+import { MassiveBody } from '../base/massive-body';
+import { DockingPoint } from './docking-point';
+import { Orbit } from './orbit';
+import type { Hoverable } from '../base/hoverable';
+import type { BlackHole } from './black-hole';
+export declare const STAR_CONFIG: {
+    RARE_STAR_CHANCE: number;
+    RARE_STAR_COLORS: string[];
+    AURA_CHANCE: number;
+    RINGED_PLANET_CHANCE: number;
+    MIN_RADIUS: number;
+    RADIUS_VARIANCE: number;
+    INITIAL_VELOCITY_RANGE: number;
+    INTERACTION_ACCELERATION: number;
+    VELOCITY_DECAY: number;
+    HOVER_RADIUS_MULTIPLIER: number;
+    HOVER_GLOW_COLOR: string;
+    HOVER_TIMEOUT: number;
+};
+export declare class Star extends MassiveBody implements Hoverable {
+    id: number;
+    name: string;
+    radius: number;
+    baseRadius: number;
+    ivx: number;
+    ivy: number;
+    color: string;
+    hasAura: boolean;
+    dockingPoints: DockingPoint[];
+    orbits: Orbit[];
+    isHovered: boolean;
+    hoverRadius: number;
+    hoverTimer: number;
+    respawnTimer: number;
+    constructor(x: number, y: number);
+    isEatenBy(blackHole: BlackHole): boolean;
+    respawn(newX: number, newY: number): void;
+    update(ctx: CanvasRenderingContext2D, width: number, height: number, mouse: {
+        dx: number;
+        dy: number;
+    }, interactive: boolean, isMouseInside: boolean, pulseTime?: number): void;
+    private drawDebugInfo;
+    drawBase(ctx: CanvasRenderingContext2D, pulseTime: number): void;
+    draw(ctx: CanvasRenderingContext2D, pulseTime: number): void;
+}

package/dist/src/entities/star.js

@@ -0,0 +1,167 @@
+/**
+ * @fileoverview Defines the Star class for the night sky simulation.
+ */
+import { MassiveBody } from '../base/massive-body';
+import { Orbit, ORBIT_CONFIG } from './orbit';
+import { DEBUG_CONFIG } from '../config/simulation';
+// --- Star Configuration ---
+export const STAR_CONFIG = {
+    RARE_STAR_CHANCE: 0.1,
+    RARE_STAR_COLORS: ['#FFD700', '#ADD8E6', '#FFB6C1', '#87CEEB', '#DDA0DD', '#ffabab', '#a6d9ff'],
+    AURA_CHANCE: 0.15,
+    RINGED_PLANET_CHANCE: 0.03, // Chance to spawn a ringed planet
+    MIN_RADIUS: 0.5,
+    RADIUS_VARIANCE: 1.1,
+    INITIAL_VELOCITY_RANGE: 0.05,
+    INTERACTION_ACCELERATION: 0.02,
+    VELOCITY_DECAY: 0.96,
+    HOVER_RADIUS_MULTIPLIER: 8,
+    HOVER_GLOW_COLOR: 'rgba(255, 255, 255, 0.7)',
+    HOVER_TIMEOUT: 120, // 2 seconds in frames
+};
+let starCounter = 0;
+export class Star extends MassiveBody {
+    constructor(x, y) {
+        const radius = Math.random() * STAR_CONFIG.RADIUS_VARIANCE + STAR_CONFIG.MIN_RADIUS;
+        const mass = radius * radius; // Mass is proportional to the square of the radius
+        super(x, y, radius, mass);
+        this.isHovered = false;
+        this.id = ++starCounter;
+        this.name = `S-${this.id}`;
+        this.radius = radius;
+        this.baseRadius = this.radius;
+        this.ivx = Math.random() * STAR_CONFIG.INITIAL_VELOCITY_RANGE * 2 - STAR_CONFIG.INITIAL_VELOCITY_RANGE;
+        this.ivy = Math.random() * STAR_CONFIG.INITIAL_VELOCITY_RANGE * 2 - STAR_CONFIG.INITIAL_VELOCITY_RANGE;
+        this.hasAura = Math.random() < STAR_CONFIG.AURA_CHANCE;
+        const isRare = Math.random() < STAR_CONFIG.RARE_STAR_CHANCE;
+        this.color = isRare
+            ? STAR_CONFIG.RARE_STAR_COLORS[Math.floor(Math.random() * STAR_CONFIG.RARE_STAR_COLORS.length)]
+            : 'rgba(255, 255, 255, 0.8)';
+        this.dockingPoints = [];
+        this.orbits = [];
+        this.hoverTimer = 0;
+        this.respawnTimer = 0;
+        const orbitCount = Math.floor(Math.random() * (ORBIT_CONFIG.COUNT_MAX - ORBIT_CONFIG.COUNT_MIN + 1)) + ORBIT_CONFIG.COUNT_MIN;
+        let maxOrbitRadius = this.radius;
+        for (let i = 0; i < orbitCount; i++) {
+            const radiusMultiplier = (Math.random() * (ORBIT_CONFIG.RADIUS_MULTIPLIER_MAX - ORBIT_CONFIG.RADIUS_MULTIPLIER_MIN) + ORBIT_CONFIG.RADIUS_MULTIPLIER_MIN);
+            const orbitRadius = this.radius * radiusMultiplier;
+            maxOrbitRadius = Math.max(maxOrbitRadius, orbitRadius);
+            const orbitColor = this.color.startsWith('rgba')
+                ? this.color.replace(/, [0-9\.]+$/, `, ${ORBIT_CONFIG.ALPHA})`)
+                : `rgba(255, 255, 255, ${ORBIT_CONFIG.ALPHA})`;
+            const orbit = new Orbit(this, orbitRadius, ORBIT_CONFIG.THICKNESS, orbitColor);
+            this.orbits.push(orbit);
+            this.dockingPoints.push(...orbit.dockingPoints);
+        }
+        this.hoverRadius = maxOrbitRadius + 10;
+    }
+    isEatenBy(blackHole) {
+        const dx = blackHole.x - this.x;
+        const dy = blackHole.y - this.y;
+        const distance = Math.sqrt(dx * dx + dy * dy);
+        return distance < blackHole.radius;
+    }
+    respawn(newX, newY) {
+        this.x = newX;
+        this.y = newY;
+        this.vx = 0;
+        this.vy = 0;
+        this.ivx = Math.random() * STAR_CONFIG.INITIAL_VELOCITY_RANGE * 2 - STAR_CONFIG.INITIAL_VELOCITY_RANGE;
+        this.ivy = Math.random() * STAR_CONFIG.INITIAL_VELOCITY_RANGE * 2 - STAR_CONFIG.INITIAL_VELOCITY_RANGE;
+        this.respawnTimer = 60; // 60 frames = ~1 second
+    }
+    update(ctx, width, height, mouse, interactive, isMouseInside, pulseTime) {
+        if (this.respawnTimer > 0) {
+            this.respawnTimer--;
+            return;
+        }
+        if (interactive && isMouseInside) {
+            const acc = STAR_CONFIG.INTERACTION_ACCELERATION;
+            this.vx += mouse.dx * acc;
+            this.vy += mouse.dy * acc;
+        }
+        this.vx *= STAR_CONFIG.VELOCITY_DECAY;
+        this.vy *= STAR_CONFIG.VELOCITY_DECAY;
+        this.x += this.vx + this.ivx;
+        this.y += this.vy + this.ivy;
+        if (this.x < 0)
+            this.x = width;
+        if (this.x > width)
+            this.x = 0;
+        if (this.y < 0)
+            this.y = height;
+        if (this.y > height)
+            this.y = 0;
+    }
+    drawDebugInfo(ctx) {
+        const startX = this.x + this.hoverRadius + 15;
+        const boxPadding = 10;
+        const lineHeight = 14;
+        const infoLines = [
+            `Name: ${this.name}`,
+            `Type: ${this.constructor.name}`,
+            `Radius: ${this.radius.toFixed(2)}`,
+            `Mass: ${this.mass.toFixed(2)}`,
+            `Color: ${this.color}`,
+            `Position: (${this.x.toFixed(0)}, ${this.y.toFixed(0)})`,
+            `Velocity: (${this.vx.toFixed(2)}, ${this.vy.toFixed(2)})`,
+            `Orbits: ${this.orbits.length}`,
+            `Docking Points: ${this.dockingPoints.length}`,
+        ];
+        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.color;
+        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);
+        });
+    }
+    // A new base drawing function that can be called by subclasses
+    drawBase(ctx, pulseTime) {
+        // Orbits are drawn first, behind the star
+        this.orbits.forEach(orbit => orbit.draw(ctx));
+        // Draw hover effect if hovered
+        this.isHovered = this.hoverTimer > 0;
+        if (this.isHovered) {
+            ctx.strokeStyle = STAR_CONFIG.HOVER_GLOW_COLOR;
+            ctx.lineWidth = 0.5;
+            ctx.shadowColor = STAR_CONFIG.HOVER_GLOW_COLOR;
+            ctx.shadowBlur = 10;
+            ctx.beginPath();
+            ctx.arc(this.x, this.y, this.hoverRadius, 0, Math.PI * 2);
+            ctx.stroke();
+            ctx.shadowBlur = 0;
+            if (DEBUG_CONFIG.SHOW_DEBUG_INFO && DEBUG_CONFIG.SHOW_ENTITY_HOVER_INFO) {
+                this.drawDebugInfo(ctx);
+            }
+        }
+        ctx.save();
+        ctx.fillStyle = this.color;
+        ctx.beginPath();
+        if (this.hasAura && !this.isHovered) { // Apply aura only if not hovered to avoid conflicting glows
+            ctx.shadowColor = this.color;
+            ctx.shadowBlur = 20;
+        }
+        ctx.arc(this.x, this.y, this.radius, 0, Math.PI * 2);
+        ctx.fill();
+        ctx.restore();
+        // Reset shadow blur after drawing the main body
+        if (this.hasAura || this.isHovered) {
+            ctx.shadowBlur = 0;
+        }
+    }
+    draw(ctx, pulseTime) {
+        this.drawBase(ctx, pulseTime);
+    }
+}

package/dist/src/entities/starship-classes.js

@@ -0,0 +1,2 @@
+"use strict";
+// This file is intentionally left empty after its contents were merged into starship.ts to resolve a build issue.

package/dist/src/entities/starship.d.ts

@@ -0,0 +1,91 @@
+/**
+ * @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 type { Fleet } from './fleet';
+import { DebugController } from '../controllers/debug-controller';
+export declare const SHAPES: Record<string, ((ctx: CanvasRenderingContext2D, r: number) => void)[]>;
+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;
+}
+export declare const SHIP_CLASS_TEMPLATES: Record<string, Omit<ShipClass, 'shape' | 'accentColor'> & {
+    shapeKey: keyof typeof SHAPES;
+}>;
+/**
+ * Returns a random ship class with a specific shape variant selected.
+ * @returns {ShipClass} A random ship class instance.
+ */
+export declare function getRandomShipClass(): ShipClass;
+export declare const STARSHIP_CONFIG: {
+    COUNT: number;
+    MIN_SPEED: number;
+    MAX_SPEED: number;
+    ACCELERATION: number;
+    DOCKING_DISTANCE: number;
+    DOCK_DURATION_MIN: number;
+    DOCK_DURATION_VARIANCE: number;
+    TRAIL_LENGTH: number;
+    WARP_CHANCE: number;
+    WARP_SPEED_MULTIPLIER: number;
+    WARP_TRAIL_LENGTH_MULTIPLIER: number;
+    FORMATION_PADDING: number;
+    FLEE_DISTANCE: number;
+    FLEE_ACCELERATION: number;
+    FLEE_DURATION: number;
+    HOVER_RADIUS_MULTIPLIER: number;
+    HOVER_GLOW_COLOR: string;
+    HOVER_GLOW_WIDTH: number;
+    HOVER_TIMEOUT: number;
+    REFORM_ACCELERATION: number;
+    REFORM_SPEED_MULTIPLIER: number;
+};
+export type ShipState = 'IDLE' | 'TRAVELING' | 'DOCKING' | 'WARPING' | 'ORBITING' | 'FLEEING' | 'IN_FORMATION';
+export declare 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;
+    hoverRadius: number;
+    hoverTimer: number;
+    fleet: Fleet | null;
+    private debugController;
+    orbit: Orbit | null;
+    orbitAngle: number;
+    orbitSpeed: number;
+    private warpTotalDistance;
+    private warpDistanceTraveled;
+    constructor(x: number, y: number, debugController: DebugController);
+    private getNewMaxSpeed;
+    isAvailable(): boolean;
+    private getNewIdleTime;
+    findNewTarget(starsWithDocks: Star[]): void;
+    enterWarpState(target: DockingPoint): void;
+    private updateDocking;
+    private updateOrbiting;
+    accelerateToPosition(targetX: number, targetY: number): void;
+    private updateTraveling;
+    private updateWarping;
+    private updateFleeing;
+    update(ctx: CanvasRenderingContext2D, width: number, height: number, mouse: {
+        x: number;
+        y: number;
+    }, deltaTime: number): void;
+    private drawWarpTrail;
+    private drawDebugInfo;
+    draw(ctx: CanvasRenderingContext2D): void;
+}