@where-stars-drift/core 1.0.0

package/src/entities/black-hole.ts

@@ -0,0 +1,246 @@
+
+/**
+ * @fileoverview Defines the BlackHle class for the night sky simulation.
+ */
+
+import { MassiveBody } from '../base/massive-body';
+import type { Hoverable } from '../base/hoverable';
+import { DEBUG_CONFIG } from '../config/simulation';
+import { Star } from './star';
+import { drawAccretionDiskShape, drawLensingShape, drawVortexShape, drawWarpedDiskShape, drawStandardShape } from './black-hole-shapes';
+import { drawEnergyStream } from '../lib/energy-stream';
+import { EFFECTS_CONFIG } from '../config/effects';
+
+// --- Black Hole Configuration ---
+export const BLACK_HOLE_CONFIG = {
+  RADIUS_BASE: 8,
+  RADIUS_VARIANCE: 4,
+  MASS_MULTIPLIER: 500,
+  HOVER_TIMEOUT: 120,
+  INITIAL_VELOCITY_RANGE: 0.025,
+  ATTRACTION_RADIUS: 100, // Only attract other black holes within this distance
+  STAR_ATTRACTION_RADIUS: 100, // Only attract stars within this distance
+  DECELERATION_DURATION: 180, // 3 seconds at 60fps
+  PAUSE_DURATION: 1200, // 20 seconds at 60fps
+  ENERGY_STREAM_DISTANCE: 300,
+  PULSE_FREQUENCY_MIN: 0.5,
+  PULSE_FREQUENCY_VARIANCE: 1.0,
+  ACCRETION_DISK: {
+    GLOW_COLOR: 'rgba(180, 210, 255, 0.4)',
+  },
+  VORTEX: {
+    PARTICLE_COUNT: 40,
+    HOTSPOT_COUNT: 5,
+    VORTEX_COLOR_INNER: 'rgba(255, 100, 0, 0.8)',
+    VORTEX_COLOR_MID: 'rgba(200, 50, 0, 0.3)',
+    VORTEX_COLOR_OUTER: 'rgba(150, 20, 0, 0)',
+  },
+  WARPED_DISK: {
+      WARPED_LINE_COUNT: 10,
+      DISK_COLOR_INNER: 'rgba(255, 220, 150, 1)',
+      DISK_COLOR_OUTER: 'rgba(255, 150, 0, 0.8)',
+  }
+};
+
+let blackHoleCounter = 0;
+
+export type BlackHoleType = 'LENSING' | 'ACCRETION_DISK' | 'VORTEX' | 'WARPED_DISK' | 'STANDARD';
+type MergeState = 'IDLE' | 'DECELERATING' | 'PAUSED';
+
+export class BlackHole extends MassiveBody implements Hoverable {
+  id: number;
+  name: string;
+  radius: number;
+  baseRadius: number;
+  color: string;
+  isHovered: boolean = false;
+  hoverRadius: number;
+  hoverTimer: number;
+  eatenStars: number;
+  type: BlackHoleType;
+  vortexAngle: number = 0;
+  warpAngle: number = 0;
+  accretionDiskAngle: number = 0;
+  mergeState: MergeState = 'IDLE';
+  mergeStateTimer: number = 0;
+  preDecelerationVx: number = 0;
+  preDecelerationVy: number = 0;
+  attractionTargets: BlackHole[] = [];
+  pulseFrequency: number;
+  pulsePhase: number;
+  nozzleLength: number = 0; // Cached nozzle length for stream effect
+  nozzleColor: string | CanvasGradient | null = null; // Cached nozzle color for stream effect
+  frameCount: number = 0; // Frame count for animations
+
+
+  constructor(x: number, y: number, type: BlackHoleType) {
+    const radius = Math.random() * BLACK_HOLE_CONFIG.RADIUS_VARIANCE + BLACK_HOLE_CONFIG.RADIUS_BASE;
+    const mass = radius * radius * BLACK_HOLE_CONFIG.MASS_MULTIPLIER;
+    super(x, y, radius, mass);
+    
+    this.id = ++blackHoleCounter;
+    this.name = `BH-${this.id}`;
+    this.radius = radius;
+    this.baseRadius = radius;
+    this.color = '#000000';
+    this.hoverTimer = 0;
+    this.hoverRadius = this.radius * 5; 
+    this.eatenStars = 0;
+    this.type = type;
+
+    this.vx = Math.random() * BLACK_HOLE_CONFIG.INITIAL_VELOCITY_RANGE * 2 - BLACK_HOLE_CONFIG.INITIAL_VELOCITY_RANGE;
+    this.vy = Math.random() * BLACK_HOLE_CONFIG.INITIAL_VELOCITY_RANGE * 2 - BLACK_HOLE_CONFIG.INITIAL_VELOCITY_RANGE;
+
+    this.pulseFrequency = Math.random() * BLACK_HOLE_CONFIG.PULSE_FREQUENCY_VARIANCE + BLACK_HOLE_CONFIG.PULSE_FREQUENCY_MIN;
+    this.pulsePhase = Math.random() * Math.PI * 2;
+  }
+
+  absorb(body: Star | BlackHole) {
+    if (body instanceof Star) {
+        this.eatenStars++;
+    } else if (body instanceof BlackHole) {
+        this.mergeState = 'DECELERATING';
+        this.mergeStateTimer = BLACK_HOLE_CONFIG.DECELERATION_DURATION;
+        this.preDecelerationVx = this.vx;
+        this.preDecelerationVy = this.vy;
+    }
+    this.mass += body.mass;
+    this.radius = Math.sqrt(this.mass / BLACK_HOLE_CONFIG.MASS_MULTIPLIER);
+    this.boundingRadius = this.radius;
+    this.hoverRadius = this.radius * 5;
+  }
+
+  reset(x: number, y: number, vx: number, vy: number) {
+    const newRadius = Math.random() * BLACK_HOLE_CONFIG.RADIUS_VARIANCE + BLACK_HOLE_CONFIG.RADIUS_BASE;
+    this.mass = newRadius * newRadius * BLACK_HOLE_CONFIG.MASS_MULTIPLIER;
+    this.radius = newRadius;
+    this.x = x;
+    this.y = y;
+    this.vx = vx;
+    this.vy = vy;
+    this.eatenStars = 0;
+    this.mergeState = 'IDLE';
+    this.mergeStateTimer = 0;
+  }
+
+  update(ctx: CanvasRenderingContext2D, width: number, height: number, frameCount: number) {
+    this.frameCount = frameCount;
+
+    // State machine for post-merger behavior
+    if (this.mergeState === 'DECELERATING') {
+        const decelerationFactor = Math.max(0, this.mergeStateTimer / BLACK_HOLE_CONFIG.DECELERATION_DURATION);
+        this.vx = this.preDecelerationVx * decelerationFactor;
+        this.vy = this.preDecelerationVy * decelerationFactor;
+    }
+
+    if (this.mergeState !== 'IDLE') {
+        this.mergeStateTimer--;
+        if (this.mergeStateTimer <= 0) {
+            if (this.mergeState === 'DECELERATING') {
+                this.vx = 0;
+                this.vy = 0;
+                this.mergeState = 'PAUSED';
+                this.mergeStateTimer = BLACK_HOLE_CONFIG.PAUSE_DURATION;
+            } else if (this.mergeState === 'PAUSED') {
+                this.mergeState = 'IDLE';
+                this.vx = Math.random() * BLACK_HOLE_CONFIG.INITIAL_VELOCITY_RANGE * 2 - BLACK_HOLE_CONFIG.INITIAL_VELOCITY_RANGE;
+                this.vy = Math.random() * BLACK_HOLE_CONFIG.INITIAL_VELOCITY_RANGE * 2 - BLACK_HOLE_CONFIG.INITIAL_VELOCITY_RANGE;
+            }
+        }
+    }
+    
+    this.x += this.vx;
+    this.y += this.vy;
+
+    if (this.x < -this.radius) this.x = width + this.radius;
+    if (this.x > width + this.radius) this.x = -this.radius;
+    if (this.y < -this.radius) this.y = height + this.radius;
+    if (this.y > height + this.radius) this.y = -this.radius;
+
+    if(this.type === 'VORTEX') {
+        this.vortexAngle += 0.01;
+    }
+    if(this.type === 'WARPED_DISK') {
+        this.warpAngle += 0.002;
+    }
+    if(this.type === 'ACCRETION_DISK') {
+        this.accretionDiskAngle += 0.005 / 3;
+    }
+  }
+
+  private drawDebugInfo(ctx: CanvasRenderingContext2D) {
+      const startX = this.x + this.hoverRadius + 15;
+      const boxPadding = 10;
+      const lineHeight = 14;
+      const infoLines = [
+          `Name: ${this.name}`,
+          `Type: ${this.constructor.name} (${this.type})`,
+          `Radius: ${this.radius.toFixed(2)}`,
+          `Mass: ${this.mass.toFixed(2)}`,
+          `Position: (${this.x.toFixed(0)}, ${this.y.toFixed(0)})`,
+          `Stars Eaten: ${this.eatenStars}`,
+          `Merge State: ${this.mergeState} (${this.mergeStateTimer})`
+      ];
+
+      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 = '#fff';
+      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, pulseTime: number, frameCount: number) {
+    this.frameCount = frameCount;
+    // 1. Draw streams from behind
+    if (EFFECTS_CONFIG.RENDER_INTER_HOLE_STREAMS && this.attractionTargets.length > 0) {
+        for (const target of this.attractionTargets) {
+            drawEnergyStream(ctx, this, target, pulseTime, frameCount);
+        }
+    }
+
+    // 2. Draw the main black hole shape
+    switch (this.type) {
+        case 'STANDARD':
+            drawStandardShape(ctx, this);
+            break;
+        case 'ACCRETION_DISK':
+            drawAccretionDiskShape(ctx, this);
+            break;
+        case 'VORTEX':
+            drawVortexShape(ctx, this);
+            break;
+        case 'WARPED_DISK':
+            drawWarpedDiskShape(ctx, this);
+            break;
+        case 'LENSING':
+        default:
+            drawLensingShape(ctx, this);
+            break;
+    }
+    
+    // 3. Draw hover effect if hovered
+    this.isHovered = this.hoverTimer > 0;
+    if (this.isHovered) {
+        if (DEBUG_CONFIG.SHOW_DEBUG_INFO && DEBUG_CONFIG.SHOW_ENTITY_HOVER_INFO) {
+          this.drawDebugInfo(ctx);
+        }
+    }
+  }
+}
+
+export { BlackHole as BlackHle };

package/src/entities/clan-manager.ts

@@ -0,0 +1,33 @@
+/**
+ * @fileoverview Defines the ClanManager for the night sky simulation.
+ */
+import { CLANS_CONFIG, type Clan } from './clans';
+
+export class ClanManager {
+    private clans: Clan[] = [];
+    private lastAssignedClanIndex: number = -1;
+
+    constructor() {
+        this.initializeClans();
+    }
+
+    private initializeClans() {
+        this.clans = CLANS_CONFIG.map(config => ({
+            ...config,
+            fleets: [],
+            starships: [],
+            fleetsCount: 0,
+            starshipsCount: 0,
+        }));
+    }
+
+    public getClans(): Clan[] {
+        return this.clans;
+    }
+
+    public getClanForNewFleet(): Clan {
+        // Simple round-robin assignment for now
+        this.lastAssignedClanIndex = (this.lastAssignedClanIndex + 1) % this.clans.length;
+        return this.clans[this.lastAssignedClanIndex];
+    }
+}

package/src/entities/clans.ts

@@ -0,0 +1,98 @@
+/**
+ * @fileoverview Defines all clan properties for the night sky simulation.
+ */
+import type { Fleet } from './fleet';
+import type { Starship } from './starship';
+
+export interface Clan {
+  name: string;
+  color: string;
+  icon: (ctx: CanvasRenderingContext2D, size: number) => void;
+  fleets: Fleet[];
+  starships: Starship[];
+  fleetsCount: number;
+  starshipsCount: number;
+}
+
+const drawIconCrescent = (ctx: CanvasRenderingContext2D, size: number) => {
+    ctx.beginPath();
+    ctx.arc(0, 0, size / 2, 0, Math.PI * 2);
+    ctx.fill();
+    ctx.save();
+    ctx.globalCompositeOperation = 'destination-out';
+    ctx.beginPath();
+    ctx.arc(size * 0.2, 0, size / 2.5, 0, Math.PI * 2);
+    ctx.fill();
+    ctx.restore();
+};
+
+const drawIconSpikes = (ctx: CanvasRenderingContext2D, size: number) => {
+    const points = 6;
+    ctx.beginPath();
+    for (let i = 0; i < points * 2; i++) {
+        const radius = i % 2 === 0 ? size / 2 : size / 4;
+        const angle = (i / points) * Math.PI;
+        ctx.lineTo(radius * Math.cos(angle), radius * Math.sin(angle));
+    }
+    ctx.closePath();
+    ctx.fill();
+};
+
+const drawIconTriangle = (ctx: CanvasRenderingContext2D, size: number) => {
+    const h = size * (Math.sqrt(3)/2);
+    ctx.beginPath();
+    ctx.moveTo(0, -h/2);
+    ctx.lineTo(-size/2, h/2);
+    ctx.lineTo(size/2, h/2);
+    ctx.closePath();
+    ctx.stroke();
+};
+
+const drawIconHexagon = (ctx: CanvasRenderingContext2D, size: number) => {
+    const r = size / 2;
+    ctx.beginPath();
+    ctx.moveTo(r * Math.cos(0), r * Math.sin(0));
+    for (let i = 1; i <= 6; i++) {
+        ctx.lineTo(r * Math.cos(i * 2 * Math.PI / 6), r * Math.sin(i * 2 * Math.PI / 6));
+    }
+    ctx.stroke();
+};
+
+const drawIconCross = (ctx: CanvasRenderingContext2D, size: number) => {
+    const armLength = size / 2;
+    ctx.beginPath();
+    ctx.moveTo(-armLength, 0);
+    ctx.lineTo(armLength, 0);
+    ctx.moveTo(0, -armLength);
+    ctx.lineTo(0, armLength);
+    ctx.stroke();
+};
+
+
+export const CLANS_CONFIG: Pick<Clan, 'name' | 'color' | 'icon'>[] = [
+    { 
+        name: "Starkwood Sovereignty",
+        color: "#ADD8E6", 
+        icon: drawIconCrescent
+    },
+    { 
+        name: "Crimson Covenant",
+        color: "#FF6B6B", 
+        icon: drawIconSpikes
+    },
+    { 
+        name: "Golden Imperium",
+        color: "#FFD700", 
+        icon: drawIconTriangle
+    },
+    {
+        name: "Azure Assembly",
+        color: "#87CEEB",
+        icon: drawIconHexagon
+    },
+    {
+        name: "Veridian Syndicate",
+        color: "#3D9970",
+        icon: drawIconCross
+    }
+];

package/src/entities/comet.ts

@@ -0,0 +1,102 @@
+/**
+ * @fileoverview Defines the Comet class for the night sky simulation.
+ */
+
+import { BoundedBody } from '../base/bounded-body';
+import { STAR_CONFIG } from './star';
+
+// --- Comet Configuration ---
+export const COMET_CONFIG = {
+  COUNT: 1,
+  DORMANT_LIFE_MIN: 1600,
+  DORMANT_LIFE_VARIANCE: 6400,
+  MIN_RADIUS: 1,
+  RADIUS_VARIANCE: 1.5,
+  SPEED_MIN: 3,
+  SPEED_VARIANCE: 4,
+  MAX_LIFE_MIN: 150,
+  MAX_LIFE_VARIANCE: 200,
+};
+
+export class Comet extends BoundedBody {
+    radius: number;
+    color: string;
+    life: number;
+    maxLife: number;
+    dormant: boolean;
+    dormantLife: number;
+
+    constructor(width: number, height: number) {
+        super(0, 0, 0); // Temporary initial values
+        this.radius = 0;
+        this.color = '';
+        this.life = 0;
+        this.maxLife = 0;
+        this.dormant = true;
+        this.dormantLife = Math.random() * COMET_CONFIG.DORMANT_LIFE_VARIANCE + COMET_CONFIG.DORMANT_LIFE_MIN; // Start dormant
+        this.reset(width, height);
+    }
+    
+    reset(width: number, height: number) {
+        this.x = Math.random() * width;
+        this.y = Math.random() > 0.5 ? -50 : height + 50;
+        this.radius = Math.random() * COMET_CONFIG.RADIUS_VARIANCE + COMET_CONFIG.MIN_RADIUS;
+        this.boundingRadius = this.radius;
+        const angle = Math.random() * Math.PI * 0.4 - Math.PI * 0.2;
+        const speed = Math.random() * COMET_CONFIG.SPEED_VARIANCE + COMET_CONFIG.SPEED_MIN;
+        this.vx = Math.sin(angle) * speed;
+        this.vy = Math.cos(angle) * speed * (this.y > height ? -1 : 1);
+        this.color = STAR_CONFIG.RARE_STAR_COLORS[Math.floor(Math.random() * STAR_CONFIG.RARE_STAR_COLORS.length)];
+        this.maxLife = (Math.random() * COMET_CONFIG.MAX_LIFE_VARIANCE + COMET_CONFIG.MAX_LIFE_MIN);
+        this.life = this.maxLife;
+        this.dormant = false;
+        this.dormantLife = 0;
+    }
+
+    update(ctx: CanvasRenderingContext2D, width: number, height: number) {
+        if (this.dormant) {
+            this.dormantLife--;
+            if (this.dormantLife <= 0) {
+                this.reset(width, height);
+            }
+            return;
+        }
+
+        this.x += this.vx;
+        this.y += this.vy;
+        this.life--;
+
+        if (this.life <= 0) {
+            this.dormant = true;
+            this.dormantLife = Math.random() * COMET_CONFIG.DORMANT_LIFE_VARIANCE + COMET_CONFIG.DORMANT_LIFE_MIN;
+        }
+    }
+
+    draw(ctx: CanvasRenderingContext2D) {
+        if (this.dormant) return;
+
+        const tailLength = this.radius * 30 * (this.life / this.maxLife);
+        
+        ctx.beginPath();
+        ctx.globalAlpha = this.life / this.maxLife * 0.8;
+
+        const gradient = ctx.createLinearGradient(this.x, this.y, this.x - this.vx * tailLength, this.y - this.vy * tailLength);
+        gradient.addColorStop(0, this.color);
+        gradient.addColorStop(1, "rgba(0,0,0,0)");
+        
+        ctx.strokeStyle = gradient;
+        ctx.lineWidth = this.radius;
+        ctx.lineCap = 'round';
+        
+        ctx.moveTo(this.x, this.y);
+        ctx.lineTo(this.x - this.vx * (tailLength / 10), this.y - this.vy * (tailLength / 10));
+        ctx.stroke();
+
+        ctx.beginPath();
+        ctx.fillStyle = this.color;
+        ctx.arc(this.x, this.y, this.radius / 2, 0, Math.PI * 2);
+        ctx.fill();
+        
+        ctx.globalAlpha = 1;
+    }
+}

package/src/entities/docking-point.ts

@@ -0,0 +1,34 @@
+/**
+ * @fileoverview Defines the DockingPoint class for the night sky simulation.
+ */
+
+import { CelestialBody } from '../base/celestial-body';
+import { Star } from './star';
+
+let dockingPointCounter = 0;
+
+export class DockingPoint {
+    id: number;
+    parent: CelestialBody | Star;
+    // Relative coordinates to the parent
+    relativeX: number;
+    relativeY: number;
+
+    constructor(parent: CelestialBody | Star, relativeX: number, relativeY: number) {
+        this.id = ++dockingPointCounter;
+        this.parent = parent;
+        this.relativeX = relativeX;
+        this.relativeY = relativeY;
+    }
+
+    /**
+     * Gets the absolute world coordinates of the docking point.
+     * @returns {{x: number, y: number}} The absolute position.
+     */
+    getAbsolutePosition(): { x: number, y: number } {
+        return {
+            x: this.parent.x + this.relativeX,
+            y: this.parent.y + this.relativeY
+        };
+    }
+}