@where-stars-drift/core 1.0.0

package/dist/src/entities/black-hole-shapes.js

@@ -0,0 +1,224 @@
+/**
+ * @fileoverview Defines all black hole shape rendering functions.
+ */
+import { BLACK_HOLE_CONFIG } from './black-hole';
+export const drawStandardShape = (ctx, hole) => {
+    // A simple white glow from behind
+    const ringRadius = hole.radius * 1.5;
+    ctx.save();
+    ctx.shadowColor = `rgba(255, 255, 255, 0.7)`;
+    ctx.shadowBlur = 20;
+    // Draw the black hole itself, the shadow will create the glow
+    ctx.beginPath();
+    ctx.fillStyle = hole.color;
+    ctx.arc(hole.x, hole.y, hole.radius, 0, Math.PI * 2);
+    ctx.fill();
+    ctx.restore();
+};
+export const drawWarpedDiskShape = (ctx, hole) => {
+    const config = BLACK_HOLE_CONFIG.WARPED_DISK;
+    const diskRadius = hole.radius * 2.5;
+    // 1. Draw outer, faint, warped lines
+    ctx.save();
+    ctx.translate(hole.x, hole.y);
+    ctx.globalCompositeOperation = 'lighter';
+    for (let i = 0; i < config.WARPED_LINE_COUNT; i++) {
+        const progress = i / config.WARPED_LINE_COUNT;
+        const startRadius = diskRadius * (1.5 + progress * 2);
+        const endRadius = diskRadius * (1.1 - progress * 0.2);
+        const startAngle = hole.warpAngle + progress * Math.PI * 0.4;
+        const endAngle = hole.warpAngle + Math.PI * 0.2 + progress * Math.PI * 0.8;
+        const startX = Math.cos(startAngle) * startRadius;
+        const startY = Math.sin(startAngle) * startRadius;
+        const endX = Math.cos(endAngle) * endRadius;
+        const endY = Math.sin(endAngle) * endRadius;
+        const cp1x = Math.cos(startAngle + 0.5) * startRadius * 0.8;
+        const cp1y = Math.sin(startAngle + 0.5) * startRadius * 0.8;
+        const cp2x = Math.cos(endAngle - 0.5) * endRadius * 1.2;
+        const cp2y = Math.sin(endAngle - 0.5) * endRadius * 1.2;
+        ctx.beginPath();
+        ctx.moveTo(startX, startY);
+        ctx.bezierCurveTo(cp1x, cp1y, cp2x, cp2y, endX, endY);
+        ctx.strokeStyle = `rgba(255, 200, 150, ${0.05 + progress * 0.1})`;
+        ctx.lineWidth = 0.5 + progress * 1.0;
+        ctx.stroke();
+    }
+    ctx.restore();
+    // 2. Draw main accretion disk
+    ctx.save();
+    ctx.translate(hole.x, hole.y);
+    const gradient = ctx.createRadialGradient(0, 0, hole.radius, 0, 0, diskRadius);
+    gradient.addColorStop(0.3, config.DISK_COLOR_INNER);
+    gradient.addColorStop(0.6, config.DISK_COLOR_OUTER);
+    gradient.addColorStop(1, 'rgba(255, 150, 0, 0)');
+    ctx.strokeStyle = gradient;
+    ctx.lineWidth = hole.radius * 1.5;
+    ctx.shadowColor = config.DISK_COLOR_INNER;
+    ctx.shadowBlur = 30;
+    ctx.beginPath();
+    ctx.arc(0, 0, diskRadius, 0, Math.PI * 2);
+    ctx.stroke();
+    ctx.restore();
+    // 3. Draw the black hole itself
+    ctx.beginPath();
+    ctx.fillStyle = hole.color;
+    ctx.arc(hole.x, hole.y, hole.radius, 0, Math.PI * 2);
+    ctx.fill();
+    // 4. Draw the diagonal "cut" which creates the 3D effect
+    ctx.save();
+    ctx.translate(hole.x, hole.y);
+    ctx.fillStyle = 'rgba(0,0,0,1)';
+    ctx.shadowColor = 'black';
+    ctx.shadowBlur = 5;
+    ctx.fillRect(-diskRadius * 1.5, -hole.radius * 0.1, diskRadius * 3, hole.radius * 0.2);
+    ctx.restore();
+    ctx.shadowBlur = 0;
+};
+export const drawLensingShape = (ctx, hole) => {
+    // Gravitational Lensing Effect
+    const ringRadius = hole.radius * 1.5;
+    ctx.save();
+    ctx.shadowColor = `rgba(255, 255, 255, 0.5)`;
+    ctx.shadowBlur = 50;
+    ctx.beginPath();
+    ctx.strokeStyle = `rgba(255, 255, 255, 0.9)`;
+    ctx.lineWidth = hole.radius * 0.4;
+    ctx.arc(hole.x, hole.y, ringRadius, 0, Math.PI * 2);
+    ctx.stroke();
+    ctx.restore();
+    // Draw the black hole itself
+    ctx.beginPath();
+    ctx.fillStyle = hole.color;
+    ctx.arc(hole.x, hole.y, hole.radius, 0, Math.PI * 2);
+    ctx.fill();
+};
+export const drawAccretionDiskShape = (ctx, hole) => {
+    const diskRadius = hole.radius * 2.5;
+    const glowRadius = diskRadius * 0.6;
+    const config = BLACK_HOLE_CONFIG.ACCRETION_DISK;
+    // --- Draw Relativistic Jets ---
+    ctx.save();
+    ctx.translate(hole.x, hole.y);
+    ctx.rotate(hole.accretionDiskAngle);
+    ctx.globalCompositeOperation = 'lighter';
+    // Animate the nozzle length only every 5 frames for performance
+    if (hole.frameCount % 5 === 0) {
+        const maxNozzleLength = diskRadius * 1.1;
+        // nozzleLengthMultiplier will be between 0.5 (50%) and 1.0 (100%)
+        const nozzleLengthMultiplier = Math.random() * 0.5 + 0.5;
+        hole.nozzleLength = maxNozzleLength * nozzleLengthMultiplier;
+    }
+    // Always draw the jets using the cached nozzleLength
+    if (hole.nozzleLength > 0) {
+        ctx.shadowColor = 'white';
+        ctx.shadowBlur = 15;
+        const nozzleBaseWidth = hole.radius * 2; // Base is 2x the hole's radius
+        const jetColor = `rgba(200, 220, 255, ${0.1 + (hole.nozzleLength / (diskRadius * 1.1)) * 0.3})`;
+        ctx.fillStyle = jetColor;
+        // Jet 1 (positive x direction)
+        ctx.beginPath();
+        ctx.moveTo(hole.nozzleLength, 0); // Tip of the jet
+        ctx.lineTo(0, nozzleBaseWidth / 2); // Base centered at the hole
+        ctx.lineTo(0, -nozzleBaseWidth / 2); // Base centered at the hole
+        ctx.closePath();
+        ctx.fill();
+        // Jet 2 (negative x direction)
+        ctx.beginPath();
+        ctx.moveTo(-hole.nozzleLength, 0); // Tip of the jet
+        ctx.lineTo(0, nozzleBaseWidth / 2); // Base centered at the hole
+        ctx.lineTo(0, -nozzleBaseWidth / 2); // Base centered at the hole
+        ctx.closePath();
+        ctx.fill();
+    }
+    ctx.restore();
+    // 1. Draw the outer glow
+    ctx.save();
+    ctx.translate(hole.x, hole.y);
+    const glowGradient = ctx.createRadialGradient(0, 0, hole.radius, 0, 0, glowRadius);
+    glowGradient.addColorStop(0.2, config.GLOW_COLOR);
+    glowGradient.addColorStop(1, 'rgba(180, 210, 255, 0)');
+    ctx.fillStyle = glowGradient;
+    ctx.shadowColor = config.GLOW_COLOR;
+    ctx.shadowBlur = 30;
+    ctx.beginPath();
+    ctx.arc(0, 0, glowRadius, 0, Math.PI * 2);
+    ctx.fill();
+    ctx.restore();
+    // 2. Draw the black hole event horizon
+    ctx.beginPath();
+    ctx.fillStyle = hole.color;
+    ctx.arc(hole.x, hole.y, hole.radius, 0, Math.PI * 2);
+    ctx.fill();
+    // 3. Draw the flat white line crossing the front
+    ctx.save();
+    ctx.translate(hole.x, hole.y);
+    ctx.rotate(hole.accretionDiskAngle);
+    const lineGradient = ctx.createLinearGradient(-diskRadius * 1.1, 0, diskRadius * 1.1, 0);
+    lineGradient.addColorStop(0, 'rgba(255, 255, 255, 0)');
+    lineGradient.addColorStop(0.25, 'rgba(255, 255, 255, 0.95)');
+    lineGradient.addColorStop(0.75, 'rgba(255, 255, 255, 0.95)');
+    lineGradient.addColorStop(1, 'rgba(255, 255, 255, 0)');
+    ctx.fillStyle = lineGradient;
+    ctx.shadowColor = 'white';
+    ctx.shadowBlur = 15;
+    const lineHeight = hole.radius * 0.35;
+    ctx.fillRect(-diskRadius * 1.1, -lineHeight / 2, diskRadius * 2.2, lineHeight);
+    ctx.restore();
+    ctx.shadowBlur = 0;
+};
+export const drawVortexShape = (ctx, hole) => {
+    const config = BLACK_HOLE_CONFIG.VORTEX;
+    const outerRadius = hole.radius * 5;
+    // 1. Draw the vast, faint outer glow
+    ctx.save();
+    ctx.translate(hole.x, hole.y);
+    const outerGradient = ctx.createRadialGradient(0, 0, hole.radius, 0, 0, outerRadius);
+    outerGradient.addColorStop(0.3, config.VORTEX_COLOR_MID);
+    outerGradient.addColorStop(1, config.VORTEX_COLOR_OUTER);
+    ctx.fillStyle = outerGradient;
+    ctx.beginPath();
+    ctx.arc(0, 0, outerRadius, 0, Math.PI * 2);
+    ctx.fill();
+    ctx.restore();
+    // 2. Draw the swirling, fiery arms
+    ctx.save();
+    ctx.translate(hole.x, hole.y);
+    ctx.globalCompositeOperation = 'lighter';
+    for (let i = 0; i < config.PARTICLE_COUNT; i++) {
+        const progress = i / config.PARTICLE_COUNT;
+        const angle = hole.vortexAngle + progress * Math.PI * 2;
+        const startRadius = hole.radius * (1.2 + progress * 1.5);
+        const endRadius = hole.radius * (1.0 + progress * 1.0);
+        const flameColor = i % 2 === 0 ? `rgba(255, 220, 150, 0.15)` : `rgba(255, 180, 50, 0.1)`;
+        ctx.beginPath();
+        ctx.arc(0, 0, startRadius, angle, angle + Math.PI * 0.8);
+        ctx.arc(0, 0, endRadius, angle + Math.PI * 0.8, angle, true);
+        ctx.closePath();
+        ctx.fillStyle = flameColor;
+        ctx.shadowColor = 'rgba(255, 150, 0, 0.5)';
+        ctx.shadowBlur = 45;
+        ctx.fill();
+    }
+    ctx.restore();
+    // 3. Draw the bright inner ring
+    ctx.save();
+    ctx.translate(hole.x, hole.y);
+    const innerRingRadius = hole.radius * 1.2;
+    const innerGradient = ctx.createRadialGradient(0, 0, 0, 0, 0, innerRingRadius);
+    innerGradient.addColorStop(0, 'rgba(255, 255, 255, 0.9)');
+    innerGradient.addColorStop(0.7, config.VORTEX_COLOR_INNER);
+    innerGradient.addColorStop(1, 'rgba(255, 200, 0, 0)');
+    ctx.fillStyle = innerGradient;
+    ctx.shadowColor = 'rgba(255, 255, 255, 0.7)';
+    ctx.shadowBlur = 20;
+    ctx.beginPath();
+    ctx.arc(0, 0, innerRingRadius, 0, Math.PI * 2);
+    ctx.fill();
+    ctx.restore();
+    // 4. Draw the central black hole
+    ctx.beginPath();
+    ctx.fillStyle = hole.color;
+    ctx.arc(hole.x, hole.y, hole.radius, 0, Math.PI * 2);
+    ctx.fill();
+    ctx.shadowBlur = 0;
+};

package/dist/src/entities/black-hole.d.ts

@@ -0,0 +1,69 @@
+/**
+ * @fileoverview Defines the BlackHle class for the night sky simulation.
+ */
+import { MassiveBody } from '../base/massive-body';
+import type { Hoverable } from '../base/hoverable';
+import { Star } from './star';
+export declare const BLACK_HOLE_CONFIG: {
+    RADIUS_BASE: number;
+    RADIUS_VARIANCE: number;
+    MASS_MULTIPLIER: number;
+    HOVER_TIMEOUT: number;
+    INITIAL_VELOCITY_RANGE: number;
+    ATTRACTION_RADIUS: number;
+    STAR_ATTRACTION_RADIUS: number;
+    DECELERATION_DURATION: number;
+    PAUSE_DURATION: number;
+    ENERGY_STREAM_DISTANCE: number;
+    PULSE_FREQUENCY_MIN: number;
+    PULSE_FREQUENCY_VARIANCE: number;
+    ACCRETION_DISK: {
+        GLOW_COLOR: string;
+    };
+    VORTEX: {
+        PARTICLE_COUNT: number;
+        HOTSPOT_COUNT: number;
+        VORTEX_COLOR_INNER: string;
+        VORTEX_COLOR_MID: string;
+        VORTEX_COLOR_OUTER: string;
+    };
+    WARPED_DISK: {
+        WARPED_LINE_COUNT: number;
+        DISK_COLOR_INNER: string;
+        DISK_COLOR_OUTER: string;
+    };
+};
+export type BlackHoleType = 'LENSING' | 'ACCRETION_DISK' | 'VORTEX' | 'WARPED_DISK' | 'STANDARD';
+type MergeState = 'IDLE' | 'DECELERATING' | 'PAUSED';
+export declare class BlackHole extends MassiveBody implements Hoverable {
+    id: number;
+    name: string;
+    radius: number;
+    baseRadius: number;
+    color: string;
+    isHovered: boolean;
+    hoverRadius: number;
+    hoverTimer: number;
+    eatenStars: number;
+    type: BlackHoleType;
+    vortexAngle: number;
+    warpAngle: number;
+    accretionDiskAngle: number;
+    mergeState: MergeState;
+    mergeStateTimer: number;
+    preDecelerationVx: number;
+    preDecelerationVy: number;
+    attractionTargets: BlackHole[];
+    pulseFrequency: number;
+    pulsePhase: number;
+    nozzleLength: number;
+    nozzleColor: string | CanvasGradient | null;
+    frameCount: number;
+    constructor(x: number, y: number, type: BlackHoleType);
+    absorb(body: Star | BlackHole): void;
+    reset(x: number, y: number, vx: number, vy: number): void;
+    update(ctx: CanvasRenderingContext2D, width: number, height: number, frameCount: number): void;
+    private drawDebugInfo;
+    draw(ctx: CanvasRenderingContext2D, pulseTime: number, frameCount: number): void;
+}
+export { BlackHole as BlackHle };

package/dist/src/entities/black-hole.js

@@ -0,0 +1,210 @@
+/**
+ * @fileoverview Defines the BlackHle class for the night sky simulation.
+ */
+import { MassiveBody } from '../base/massive-body';
+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 class BlackHole extends MassiveBody {
+    constructor(x, y, type) {
+        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.isHovered = false;
+        this.vortexAngle = 0;
+        this.warpAngle = 0;
+        this.accretionDiskAngle = 0;
+        this.mergeState = 'IDLE';
+        this.mergeStateTimer = 0;
+        this.preDecelerationVx = 0;
+        this.preDecelerationVy = 0;
+        this.attractionTargets = [];
+        this.nozzleLength = 0; // Cached nozzle length for stream effect
+        this.nozzleColor = null; // Cached nozzle color for stream effect
+        this.frameCount = 0; // Frame count for animations
+        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) {
+        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, y, vx, vy) {
+        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, width, height, frameCount) {
+        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;
+        }
+    }
+    drawDebugInfo(ctx) {
+        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, pulseTime, frameCount) {
+        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/dist/src/entities/clan-manager.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @fileoverview Defines the ClanManager for the night sky simulation.
+ */
+import { type Clan } from './clans';
+export declare class ClanManager {
+    private clans;
+    private lastAssignedClanIndex;
+    constructor();
+    private initializeClans;
+    getClans(): Clan[];
+    getClanForNewFleet(): Clan;
+}

package/dist/src/entities/clan-manager.js

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

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

@@ -0,0 +1,15 @@
+/**
+ * @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;
+}
+export declare const CLANS_CONFIG: Pick<Clan, 'name' | 'color' | 'icon'>[];

package/dist/src/entities/clans.js

@@ -0,0 +1,76 @@
+const drawIconCrescent = (ctx, size) => {
+    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, size) => {
+    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, size) => {
+    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, size) => {
+    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, size) => {
+    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 = [
+    {
+        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/dist/src/entities/comet.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @fileoverview Defines the Comet class for the night sky simulation.
+ */
+import { BoundedBody } from '../base/bounded-body';
+export declare const COMET_CONFIG: {
+    COUNT: number;
+    DORMANT_LIFE_MIN: number;
+    DORMANT_LIFE_VARIANCE: number;
+    MIN_RADIUS: number;
+    RADIUS_VARIANCE: number;
+    SPEED_MIN: number;
+    SPEED_VARIANCE: number;
+    MAX_LIFE_MIN: number;
+    MAX_LIFE_VARIANCE: number;
+};
+export declare class Comet extends BoundedBody {
+    radius: number;
+    color: string;
+    life: number;
+    maxLife: number;
+    dormant: boolean;
+    dormantLife: number;
+    constructor(width: number, height: number);
+    reset(width: number, height: number): void;
+    update(ctx: CanvasRenderingContext2D, width: number, height: number): void;
+    draw(ctx: CanvasRenderingContext2D): void;
+}