@where-stars-drift/core 1.0.0

package/dist/src/ui/ships-panel.js

@@ -0,0 +1,61 @@
+import { PANEL_CONFIG } from './panel-config';
+export function drawStarshipCatalog(ctx, startY, shipCatalog) {
+    let currentY = startY + PANEL_CONFIG.PADDING;
+    Object.keys(shipCatalog).forEach(groupName => {
+        // Draw Main Group Header (Military / Non-Military)
+        ctx.font = PANEL_CONFIG.GROUP_FONT;
+        ctx.fillStyle = PANEL_CONFIG.TEXT_COLOR;
+        ctx.textAlign = 'left';
+        ctx.textBaseline = 'top';
+        ctx.fillText(groupName, PANEL_CONFIG.X + PANEL_CONFIG.PADDING, currentY);
+        currentY += PANEL_CONFIG.GROUP_HEADER_HEIGHT;
+        const categories = shipCatalog[groupName];
+        Object.keys(categories).forEach(categoryName => {
+            // Draw Category Header (Capital, Cruiser, etc.)
+            ctx.font = PANEL_CONFIG.ROW_FONT;
+            ctx.fillStyle = PANEL_CONFIG.ACCENT_COLOR;
+            ctx.fillText(categoryName, PANEL_CONFIG.X + PANEL_CONFIG.PADDING + 10, currentY);
+            currentY += PANEL_CONFIG.ROW_HEIGHT * 0.8;
+            const shipClasses = categories[categoryName];
+            shipClasses.forEach(shipClassEntry => {
+                // Draw ship class name once
+                ctx.fillStyle = PANEL_CONFIG.TEXT_COLOR;
+                ctx.font = PANEL_CONFIG.ROW_FONT;
+                ctx.fillText(shipClassEntry.template.name, PANEL_CONFIG.X + PANEL_CONFIG.PADDING + 20, currentY);
+                currentY += PANEL_CONFIG.ROW_HEIGHT;
+                // Loop through variants and draw them vertically
+                shipClassEntry.variants.forEach((variant, index) => {
+                    const rowHeight = 40;
+                    const vizX = PANEL_CONFIG.X + PANEL_CONFIG.PADDING + 40;
+                    const vizY = currentY + rowHeight / 2;
+                    ctx.save();
+                    ctx.translate(vizX, vizY);
+                    ctx.rotate(-Math.PI / 2); // Point ships to the right
+                    ctx.beginPath();
+                    variant(ctx, shipClassEntry.template.radius * PANEL_CONFIG.SHIP_RENDER_SCALE);
+                    ctx.fillStyle = shipClassEntry.template.color;
+                    ctx.strokeStyle = '#fff';
+                    ctx.lineWidth = 0.5;
+                    ctx.fill();
+                    ctx.stroke();
+                    ctx.restore();
+                    // Draw details on the right
+                    const detailsX = vizX + 40;
+                    ctx.fillStyle = PANEL_CONFIG.TEXT_COLOR;
+                    ctx.font = '11px "Roboto Mono", monospace';
+                    ctx.textAlign = 'left';
+                    ctx.textBaseline = 'top';
+                    ctx.fillText(`Variant ${index + 1}`, detailsX, currentY + 5);
+                    ctx.font = '10px "Roboto Mono", monospace';
+                    ctx.fillStyle = PANEL_CONFIG.ACCENT_COLOR;
+                    ctx.fillText(`Radius: ${shipClassEntry.template.radius.toFixed(1)}px`, detailsX, currentY + 20);
+                    ctx.fillText(`Color: ${shipClassEntry.template.color}`, detailsX + 90, currentY + 20);
+                    currentY += rowHeight;
+                });
+                currentY += 10; // Extra padding after variants for a class
+            });
+        });
+        currentY += PANEL_CONFIG.ROW_HEIGHT / 2; // Extra space between main groups
+    });
+    return currentY - startY;
+}

package/dist/src/ui/stars-panel.d.ts

@@ -0,0 +1,2 @@
+import { Star } from '../entities/star';
+export declare function drawStarCatalog(ctx: CanvasRenderingContext2D, startY: number, catalogStars: Star[], pulseTime: number): number;

package/dist/src/ui/stars-panel.js

@@ -0,0 +1,120 @@
+import { Star } from '../entities/star';
+import { Pulsar } from '../entities/pulsar';
+import { RingedPlanet } from '../entities/ringed-planet';
+import { PANEL_CONFIG } from './panel-config';
+function drawStarParameters(ctx, star, x, y) {
+    ctx.font = '10px "Roboto Mono", monospace';
+    ctx.fillStyle = PANEL_CONFIG.ACCENT_COLOR;
+    ctx.textAlign = 'left';
+    ctx.textBaseline = 'top';
+    let currentY = y;
+    const lineHeight = 12;
+    const params = [
+        { label: 'Radius', value: star.baseRadius.toFixed(2) },
+        { label: 'Mass', value: star.mass.toFixed(2) },
+        { label: 'Color', value: star.color },
+        { label: 'Aura', value: star.hasAura.toString() },
+    ];
+    if (star instanceof Pulsar) {
+        params.push({ label: 'Blink Speed', value: star.pulsationSpeed.toFixed(2) });
+    }
+    if (star instanceof RingedPlanet) {
+        params.push({ label: 'Rings', value: star.rings.length.toString() });
+    }
+    params.forEach(param => {
+        ctx.fillText(`${param.label}:`, x, currentY);
+        ctx.fillStyle = PANEL_CONFIG.TEXT_COLOR;
+        ctx.fillText(param.value, x + 70, currentY);
+        ctx.fillStyle = PANEL_CONFIG.ACCENT_COLOR;
+        currentY += lineHeight;
+    });
+}
+export function drawStarCatalog(ctx, startY, catalogStars, pulseTime) {
+    let currentY = startY + PANEL_CONFIG.PADDING;
+    const starTypes = [
+        { name: 'Standard Star', ctor: Star },
+        { name: 'Pulsar', ctor: Pulsar },
+        { name: 'Ringed Planet', ctor: RingedPlanet },
+    ];
+    starTypes.forEach(typeInfo => {
+        ctx.font = PANEL_CONFIG.GROUP_FONT;
+        ctx.fillStyle = PANEL_CONFIG.TEXT_COLOR;
+        ctx.textAlign = 'left';
+        ctx.textBaseline = 'top';
+        ctx.fillText(typeInfo.name, PANEL_CONFIG.X + PANEL_CONFIG.PADDING, currentY);
+        currentY += PANEL_CONFIG.GROUP_HEADER_HEIGHT;
+        const variations = catalogStars.filter(star => {
+            if (typeInfo.ctor === Star) {
+                return star.constructor === Star;
+            }
+            return star instanceof typeInfo.ctor;
+        });
+        if (variations.length === 0) {
+            ctx.font = '10px "Roboto Mono", monospace';
+            ctx.fillStyle = PANEL_CONFIG.ACCENT_COLOR;
+            ctx.fillText('No variations available for this type.', PANEL_CONFIG.X + PANEL_CONFIG.PADDING + 10, currentY);
+            currentY += 20;
+            return;
+        }
+        variations.forEach((sampleStar) => {
+            const rowY = currentY + 30;
+            const xPos = PANEL_CONFIG.X + PANEL_CONFIG.PADDING + 20;
+            // Draw star visualization
+            ctx.save();
+            ctx.translate(xPos, rowY);
+            if (sampleStar instanceof Pulsar) {
+                // Update animation without moving the star by passing 0 for width/height
+                sampleStar.update(ctx, 0, 0, { dx: 0, dy: 0 }, false, false, pulseTime);
+                sampleStar.draw(ctx, pulseTime);
+            }
+            else {
+                const originalAura = sampleStar.hasAura;
+                sampleStar.hasAura = false; // Disable aura for performance in catalog
+                sampleStar.draw(ctx, 0); // Draw star statically
+                sampleStar.hasAura = originalAura; // Restore it for parameter display
+            }
+            ctx.restore();
+            // Draw star parameters
+            drawStarParameters(ctx, sampleStar, xPos + 40, rowY - 20);
+            // If it's a ringed planet, draw ring details
+            if (sampleStar instanceof RingedPlanet) {
+                const planet = sampleStar;
+                let ringListY = currentY + 80;
+                ctx.font = '10px "Roboto Mono", monospace';
+                ctx.fillStyle = PANEL_CONFIG.ACCENT_COLOR;
+                ctx.fillText("Ring Composition:", xPos + 40, ringListY);
+                ringListY += 20;
+                planet.rings.forEach((ring, index) => {
+                    const ringDisplayRadius = ring.radius * 0.5; // Scale down for display
+                    const ringCenterY = ringListY + ringDisplayRadius + 5;
+                    // Draw the ring visualization
+                    ctx.save();
+                    ctx.translate(xPos + 10, ringCenterY);
+                    ring.draw(ctx);
+                    ctx.restore();
+                    // Draw ring parameters
+                    const paramX = xPos + 40;
+                    ctx.fillStyle = PANEL_CONFIG.TEXT_COLOR;
+                    ctx.fillText(`Ring ${index + 1}: r=${ring.radius.toFixed(1)}, th=${ring.thickness.toFixed(1)}, dotted=${ring.isDotted}`, paramX, ringCenterY - 5);
+                    ringListY += (ringDisplayRadius * 2) + 15;
+                    // Draw separator line
+                    if (index < planet.rings.length - 1) {
+                        ctx.beginPath();
+                        ctx.moveTo(paramX - 5, ringListY);
+                        ctx.lineTo(PANEL_CONFIG.X + PANEL_CONFIG.WIDTH - PANEL_CONFIG.PADDING, ringListY);
+                        ctx.strokeStyle = PANEL_CONFIG.BORDER_COLOR;
+                        ctx.lineWidth = 0.5;
+                        ctx.stroke();
+                        ringListY += 10;
+                    }
+                });
+                currentY = ringListY;
+            }
+            else {
+                currentY += 80;
+            }
+        });
+        currentY += 20; // Space between categories
+    });
+    return currentY - startY;
+}

package/dist/src/where-stars-drift.d.ts

@@ -0,0 +1,71 @@
+export interface SimulationConfig {
+    starsCount?: number;
+    interactive?: boolean;
+    debug?: boolean;
+    showCatalog?: boolean;
+    showGrid?: boolean;
+    showGithubLink?: boolean;
+}
+export interface SimulationStats {
+    fps: number;
+    avgFps: number;
+    starCount: number;
+    starshipCount: number;
+    frameCount: number;
+}
+export declare class WhereStarsDrift {
+    private canvas;
+    private ctx;
+    private config;
+    private width;
+    private height;
+    private layerController;
+    private starController;
+    private starshipController;
+    private physicsController;
+    private effectsController;
+    private debugController;
+    private debugPanelController;
+    private hoverController;
+    private allLayers;
+    private allBodies;
+    private quadtree;
+    private mouse;
+    private isMouseInside;
+    private animationFrameId;
+    private lastTime;
+    private pulseTime;
+    private githubLinkBounds;
+    private isMouseOverGithubLink;
+    private frameCount;
+    private fps;
+    private fpsFrameCount;
+    private lastFpsUpdateTime;
+    private fpsHistory;
+    private avgFps;
+    private readonly avgFpsWindow;
+    constructor(canvas: HTMLCanvasElement, config?: SimulationConfig);
+    private _initializeControllers;
+    start(): void;
+    stop(): void;
+    destroy(): void;
+    getStats(): SimulationStats;
+    setInteractive(enabled: boolean): void;
+    setDebug(enabled: boolean): void;
+    setShowCatalog(visible: boolean): void;
+    setShowGrid(visible: boolean): void;
+    setShowGithubLink(visible: boolean): void;
+    private _setupEventListeners;
+    private _removeEventListeners;
+    private _handleMouseMove;
+    private _handleMouseEnter;
+    private _handleMouseLeave;
+    private _handleMouseDown;
+    private _handleMouseUp;
+    private _handleWheel;
+    private _handleResize;
+    private _drawGithubIcon;
+    private _drawGithubLink;
+    private _checkMouseInteraction;
+    private animate;
+}