@where-stars-drift/core 1.0.0

package/src/entities/ringed-planet.ts

@@ -0,0 +1,85 @@
+
+/**
+ * @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 {
+  rings: Ring[];
+
+  constructor(x: number, y: number, ringCount?: number) {
+    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: CanvasRenderingContext2D, pulseTime: number) {
+    // 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/src/entities/sector-grid.ts

@@ -0,0 +1,81 @@
+/**
+ * @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 {
+    private numCols: number = 0;
+    private numRows: number = 0;
+    private sectorWidth: number = 0;
+    private sectorHeight: number = 0;
+    private width: number = 0;
+    private height: number = 0;
+
+    constructor(width: number, height: number) {
+        super(0, 0);
+        this.resize(width, height);
+    }
+    
+    public resize(width: number, height: number) {
+        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: CanvasRenderingContext2D, width: number, height: number) {
+        // 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: CanvasRenderingContext2D) {
+        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/src/entities/star-factory.ts

@@ -0,0 +1,59 @@
+
+import { Star, STAR_CONFIG } from './star';
+import { Pulsar, PULSAR_CONFIG } from './pulsar';
+import { RingedPlanet, RINGED_PLANET_CONFIG } from './ringed-planet';
+
+interface StarOptions {
+    radius?: number;
+    hasAura?: boolean;
+}
+
+interface RingedPlanetOptions {
+    ringCount?: number;
+}
+
+export class StarFactory {
+    /**
+     * Creates a star of a random type (Standard, Pulsar, or Ringed Planet).
+     */
+    createRandomStar(x: number, y: number): Star {
+        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: number, y: number, options: StarOptions = {}): Star {
+        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: number, y: number): Pulsar {
+        return new Pulsar(x, y);
+    }
+
+    /**
+     * Creates a ringed planet.
+     */
+    createRingedPlanet(x: number, y: number, options: RingedPlanetOptions = {}): RingedPlanet {
+        const planet = new RingedPlanet(x, y, options.ringCount);
+        return planet;
+    }
+}

package/src/entities/star.ts

@@ -0,0 +1,222 @@
+
+/**
+ * @fileoverview Defines the Star class for the night sky simulation.
+ */
+
+import { MassiveBody } from '../base/massive-body';
+import { DockingPoint } from './docking-point';
+import { Orbit, ORBIT_CONFIG } from './orbit';
+import type { Hoverable } from '../base/hoverable';
+import { DEBUG_CONFIG } from '../config/simulation';
+import type { BlackHole } from './black-hole';
+
+// --- 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 implements Hoverable {
+  id: number;
+  name: string;
+  radius: number;
+  baseRadius: number;
+  ivx: number;
+  ivy: number;
+  color: string;
+  hasAura: boolean;
+  dockingPoints: DockingPoint[];
+  orbits: Orbit[];
+  isHovered: boolean = false;
+  hoverRadius: number;
+  hoverTimer: number;
+  respawnTimer: number;
+
+  constructor(x: number, y: number) {
+    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.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: BlackHole): boolean {
+    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: number, newY: number): void {
+    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: CanvasRenderingContext2D,
+    width: number,
+    height: number,
+    mouse: { dx: number; dy: number },
+    interactive: boolean,
+    isMouseInside: boolean,
+    pulseTime?: number,
+  ) {
+    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;
+  }
+
+  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}`,
+          `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: CanvasRenderingContext2D, pulseTime: number) {
+     // 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: CanvasRenderingContext2D, pulseTime: number) {
+    this.drawBase(ctx, pulseTime);
+  }
+}

package/src/entities/starship-classes.ts

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