@where-stars-drift/core 1.0.0

package/dist/src/controllers/hover-controller.js

@@ -0,0 +1,107 @@
+import { Starship, STARSHIP_CONFIG } from '../entities/starship';
+import { Fleet, FLEET_CONFIG } from '../entities/fleet';
+import { STAR_CONFIG } from '../entities/star';
+import { BlackHole, BLACK_HOLE_CONFIG } from '../entities/black-hole';
+function isHoverable(body) {
+    return 'isHovered' in body && 'hoverTimer' in body && 'hoverRadius' in body && 'x' in body && 'y' in body;
+}
+export class HoverController {
+    constructor(bodies) {
+        this.bodies = bodies;
+    }
+    update(mouse, isMouseInside, debug) {
+        if (!debug) {
+            return;
+        }
+        this.updateHoverStates();
+        if (isMouseInside) {
+            this.checkHoverState(mouse);
+        }
+    }
+    checkHoverState(mouse) {
+        const allHoverables = this.bodies.filter(isHoverable);
+        let hoveredShip = null;
+        let hoveredFleet = null;
+        let hoveredStar = null;
+        let hoveredBlackHole = null;
+        // Prioritize smaller, more specific objects first by checking them in order.
+        // Once a hovered object is found, we stop to prevent hovering multiple objects at once.
+        // 1. Ships
+        for (const body of allHoverables) {
+            if (body instanceof Starship) {
+                const dx = body.x - mouse.x;
+                const dy = body.y - mouse.y;
+                const distSq = dx * dx + dy * dy;
+                if (distSq < body.hoverRadius * body.hoverRadius) {
+                    hoveredShip = body;
+                    break;
+                }
+            }
+        }
+        // 2. Fleets
+        if (!hoveredShip) {
+            for (const body of allHoverables) {
+                if (body instanceof Fleet) {
+                    const dx = body.x - mouse.x;
+                    const dy = body.y - mouse.y;
+                    const distSq = dx * dx + dy * dy;
+                    if (distSq < body.hoverRadius * body.hoverRadius) {
+                        hoveredFleet = body;
+                        break;
+                    }
+                }
+            }
+        }
+        // 3. Black Holes
+        if (!hoveredShip && !hoveredFleet) {
+            for (const body of allHoverables) {
+                if (body instanceof BlackHole) {
+                    const dx = body.x - mouse.x;
+                    const dy = body.y - mouse.y;
+                    const distSq = dx * dx + dy * dy;
+                    if (distSq < body.hoverRadius * body.hoverRadius) {
+                        hoveredBlackHole = body;
+                        break;
+                    }
+                }
+            }
+        }
+        // 4. Stars (as a fallback)
+        if (!hoveredShip && !hoveredFleet && !hoveredBlackHole) {
+            for (const body of allHoverables) {
+                if (!(body instanceof Starship) && !(body instanceof Fleet) && !(body instanceof BlackHole)) {
+                    const dx = body.x - mouse.x;
+                    const dy = body.y - mouse.y;
+                    const distSq = dx * dx + dy * dy;
+                    if (distSq < body.hoverRadius * body.hoverRadius) {
+                        hoveredStar = body;
+                        break;
+                    }
+                }
+            }
+        }
+        // Set timers for all hovered items
+        if (hoveredShip) {
+            hoveredShip.hoverTimer = STARSHIP_CONFIG.HOVER_TIMEOUT;
+        }
+        if (hoveredFleet) {
+            hoveredFleet.hoverTimer = FLEET_CONFIG.HOVER_TIMEOUT;
+        }
+        if (hoveredBlackHole) {
+            hoveredBlackHole.hoverTimer = BLACK_HOLE_CONFIG.HOVER_TIMEOUT;
+        }
+        if (hoveredStar) {
+            hoveredStar.hoverTimer = STAR_CONFIG.HOVER_TIMEOUT;
+        }
+    }
+    updateHoverStates() {
+        this.bodies.forEach(obj => {
+            if (isHoverable(obj)) {
+                if (obj.hoverTimer > 0) {
+                    obj.hoverTimer--;
+                }
+                obj.isHovered = obj.hoverTimer > 0;
+            }
+        });
+    }
+}

package/dist/src/controllers/layer-controller.d.ts

@@ -0,0 +1,16 @@
+import type { CelestialBody } from '../base/celestial-body';
+export type Layer = {
+    name: string;
+    description: string;
+    bodies: CelestialBody[];
+    isInteractive: boolean;
+};
+export declare class LayerController {
+    private layers;
+    constructor();
+    private initializeLayers;
+    getLayers(): Record<string, Layer>;
+    getLayer(layerName: string): Layer | undefined;
+    getBodies(layerName: string): CelestialBody[];
+    addBody(layerName: string, body: CelestialBody): void;
+}

package/dist/src/controllers/layer-controller.js

@@ -0,0 +1,64 @@
+export class LayerController {
+    constructor() {
+        this.layers = {};
+        this.initializeLayers();
+    }
+    initializeLayers() {
+        this.layers = {
+            backgroundNebulas: {
+                name: 'Background Nebulas',
+                description: 'Slow-moving, non-interactive nebula clouds for visual depth.',
+                bodies: [],
+                isInteractive: false,
+            },
+            sectorGrid: {
+                name: 'Sector Grid',
+                description: 'A grid of sectors that divides the map.',
+                bodies: [],
+                isInteractive: false,
+            },
+            staticStars: {
+                name: 'Static Stars',
+                description: 'A layer of stars that provides parallax but does not react to mouse interaction.',
+                bodies: [],
+                isInteractive: false,
+            },
+            interactiveStars: {
+                name: 'Interactive Stars',
+                description: 'A layer of stars that reacts to mouse movement and can be hovered.',
+                bodies: [],
+                isInteractive: true,
+            },
+            blackHoles: {
+                name: 'Black Holes',
+                description: 'Gravitational wells that affect other objects.',
+                bodies: [],
+                isInteractive: true,
+            },
+            dynamicObjects: {
+                name: 'Dynamic Objects',
+                description: 'Comets, starships, and fleets that move and interact within the simulation.',
+                bodies: [],
+                isInteractive: true,
+            },
+        };
+    }
+    getLayers() {
+        return this.layers;
+    }
+    getLayer(layerName) {
+        return this.layers[layerName];
+    }
+    getBodies(layerName) {
+        var _a;
+        return ((_a = this.layers[layerName]) === null || _a === void 0 ? void 0 : _a.bodies) || [];
+    }
+    addBody(layerName, body) {
+        if (this.layers[layerName]) {
+            this.layers[layerName].bodies.push(body);
+        }
+        else {
+            console.warn(`Layer "${layerName}" does not exist.`);
+        }
+    }
+}

package/dist/src/controllers/physics-controller.d.ts

@@ -0,0 +1,14 @@
+import { Star } from '../entities/star';
+import { BlackHle } from '../entities/black-hole';
+import { Supernova } from '../entities/supernova';
+import { Quadtree } from '../lib/quadtree';
+import { DebugController } from './debug-controller';
+export declare class PhysicsController {
+    private debugController;
+    constructor(debugController: DebugController);
+    update(blackHoles: BlackHle[], allStars: Star[], quadtree: Quadtree, width: number, height: number): Supernova[];
+    private findSafeRespawnLocation;
+    private applyGravity;
+    private handleStarConsumption;
+    private handleBlackHoleCollisions;
+}

package/dist/src/controllers/physics-controller.js

@@ -0,0 +1,152 @@
+import { Star } from '../entities/star';
+import { BLACK_HOLE_CONFIG } from '../entities/black-hole';
+import { Supernova } from '../entities/supernova';
+import { DEBUG_CONFIG } from '../config/simulation';
+import { BoundedBody } from '../base/bounded-body';
+const GRAVITATIONAL_CONSTANT = 0.007;
+class SearchArea extends BoundedBody {
+    constructor(x, y, radius) {
+        super(x, y, radius);
+    }
+    update() { }
+    draw() { }
+}
+export class PhysicsController {
+    constructor(debugController) {
+        this.debugController = debugController;
+    }
+    update(blackHoles, allStars, quadtree, width, height) {
+        const newSupernovas = [];
+        this.applyGravity(blackHoles, quadtree);
+        this.handleStarConsumption(blackHoles, allStars, quadtree, newSupernovas, width, height);
+        this.handleBlackHoleCollisions(blackHoles, newSupernovas, width, height);
+        return newSupernovas;
+    }
+    findSafeRespawnLocation(blackHoles, width, height) {
+        const SAFE_DISTANCE = 200;
+        let attempts = 0;
+        const MAX_ATTEMPTS = 10;
+        while (attempts < MAX_ATTEMPTS) {
+            const x = Math.random() * width;
+            const y = Math.random() * height;
+            let isSafe = true;
+            for (const hole of blackHoles) {
+                const dx = x - hole.x;
+                const dy = y - hole.y;
+                const distance = Math.sqrt(dx * dx + dy * dy);
+                if (distance < SAFE_DISTANCE) {
+                    isSafe = false;
+                    break;
+                }
+            }
+            if (isSafe) {
+                return { x, y };
+            }
+            attempts++;
+        }
+        return { x: Math.random() * width, y: Math.random() * height };
+    }
+    ;
+    applyGravity(blackHoles, quadtree) {
+        for (const blackHole of blackHoles) {
+            const searchArea = new SearchArea(blackHole.x, blackHole.y, BLACK_HOLE_CONFIG.STAR_ATTRACTION_RADIUS);
+            const nearbyStars = quadtree.query(searchArea).filter(b => b instanceof Star);
+            for (const star of nearbyStars) {
+                const dx = blackHole.x - star.x;
+                const dy = blackHole.y - star.y;
+                const distSq = dx * dx + dy * dy;
+                if (distSq < BLACK_HOLE_CONFIG.STAR_ATTRACTION_RADIUS * BLACK_HOLE_CONFIG.STAR_ATTRACTION_RADIUS) {
+                    const dist = Math.sqrt(distSq);
+                    const force = (GRAVITATIONAL_CONSTANT * blackHole.mass * star.mass) / (distSq + 1);
+                    const acceleration = force / star.mass;
+                    star.vx += (dx / dist) * acceleration;
+                    star.vy += (dy / dist) * acceleration;
+                }
+            }
+        }
+    }
+    handleStarConsumption(blackHoles, allStars, quadtree, supernovas, width, height) {
+        for (const blackHole of blackHoles) {
+            const consumptionRadius = blackHole.radius + 5; // A little buffer
+            const searchArea = new SearchArea(blackHole.x, blackHole.y, consumptionRadius);
+            const nearbyStars = quadtree.query(searchArea).filter(b => b instanceof Star);
+            for (const star of nearbyStars) {
+                if (star.isEatenBy(blackHole)) {
+                    blackHole.absorb(star);
+                    const { x: respawnX, y: respawnY } = this.findSafeRespawnLocation(blackHoles, width, height);
+                    star.respawn(respawnX, respawnY);
+                    supernovas.push(new Supernova(blackHole.x, blackHole.y, blackHole.radius, blackHole));
+                    supernovas.push(new Supernova(respawnX, respawnY, 5));
+                }
+            }
+        }
+    }
+    handleBlackHoleCollisions(blackHoles, supernovas, width, height) {
+        if (blackHoles.length < 2)
+            return;
+        // Reset attraction targets at the start of each frame
+        for (const bh of blackHoles) {
+            bh.attractionTargets = [];
+        }
+        for (let i = 0; i < blackHoles.length; i++) {
+            for (let j = i + 1; j < blackHoles.length; j++) {
+                const bh1 = blackHoles[i];
+                const bh2 = blackHoles[j];
+                const dx = bh2.x - bh1.x;
+                const dy = bh2.y - bh1.y;
+                const distSq = dx * dx + dy * dy;
+                const dist = Math.sqrt(distSq);
+                if (dist < BLACK_HOLE_CONFIG.ENERGY_STREAM_DISTANCE) {
+                    // Register targets for stream rendering
+                    bh1.attractionTargets.push(bh2);
+                    bh2.attractionTargets.push(bh1);
+                    // Register line for debug display
+                    if (DEBUG_CONFIG.SHOW_DEBUG_INFO && DEBUG_CONFIG.SHOW_INTER_HOLE_DISTANCE) {
+                        this.debugController.registerLine(bh1, bh2, { drawLine: false, showDistance: true });
+                    }
+                }
+                if (dist < BLACK_HOLE_CONFIG.ATTRACTION_RADIUS) {
+                    const force = (GRAVITATIONAL_CONSTANT * bh1.mass * bh2.mass) / (distSq + 1);
+                    const acceleration1 = force / bh1.mass;
+                    const acceleration2 = force / bh2.mass;
+                    bh1.vx += (dx / dist) * acceleration1;
+                    bh1.vy += (dy / dist) * acceleration1;
+                    bh2.vx -= (dx / dist) * acceleration2;
+                    bh2.vy -= (dy / dist) * acceleration2;
+                }
+                if (dist < bh1.radius + bh2.radius) {
+                    const absorber = bh1.mass > bh2.mass ? bh1 : bh2;
+                    const absorbed = bh1.mass > bh2.mass ? bh2 : bh1;
+                    absorber.absorb(absorbed);
+                    supernovas.push(new Supernova(absorber.x, absorber.y, absorber.radius * 1.5, absorber));
+                    const side = Math.floor(Math.random() * 4);
+                    let x, y;
+                    const buffer = 50;
+                    switch (side) {
+                        case 0:
+                            x = Math.random() * width;
+                            y = -buffer;
+                            break;
+                        case 1:
+                            x = width + buffer;
+                            y = Math.random() * height;
+                            break;
+                        case 2:
+                            x = Math.random() * width;
+                            y = height + buffer;
+                            break;
+                        default:
+                            x = -buffer;
+                            y = Math.random() * height;
+                            break;
+                    }
+                    const angleToCenter = Math.atan2(height / 2 - y, width / 2 - x);
+                    const speed = 0.1;
+                    const vx = Math.cos(angleToCenter) * speed;
+                    const vy = Math.sin(angleToCenter) * speed;
+                    absorbed.reset(x, y, vx, vy);
+                }
+            }
+        }
+    }
+}

package/dist/src/controllers/star-controller.d.ts

@@ -0,0 +1,12 @@
+import { Star } from '../entities/star';
+import { LayerController } from './layer-controller';
+export declare class StarController {
+    private layerController;
+    private allStars;
+    private starFactory;
+    private blackHoleFactory;
+    constructor(layerController: LayerController, starsCount: number, width: number, height: number);
+    private createStars;
+    private createBlackHoles;
+    getAllStars(): Star[];
+}

package/dist/src/controllers/star-controller.js

@@ -0,0 +1,38 @@
+import { StarFactory } from '../entities/star-factory';
+import { BlackHoleFactory } from '../entities/black-hole-factory';
+export class StarController {
+    constructor(layerController, starsCount, width, height) {
+        this.allStars = [];
+        this.layerController = layerController;
+        this.starFactory = new StarFactory();
+        this.blackHoleFactory = new BlackHoleFactory();
+        this.createStars(starsCount, width, height);
+        this.createBlackHoles(width, height);
+    }
+    createStars(starsCount, width, height) {
+        const staticStarsCount = Math.floor(starsCount * 0.7);
+        const interactiveStarsCount = starsCount - staticStarsCount;
+        for (let i = 0; i < staticStarsCount; i++) {
+            const star = this.starFactory.createRandomStar(Math.random() * width, Math.random() * height);
+            this.layerController.addBody('staticStars', star);
+            this.allStars.push(star);
+        }
+        for (let i = 0; i < interactiveStarsCount; i++) {
+            const star = this.starFactory.createRandomStar(Math.random() * width, Math.random() * height);
+            this.layerController.addBody('interactiveStars', star);
+            this.allStars.push(star);
+        }
+    }
+    createBlackHoles(width, height) {
+        const numBlackHoles = 3; // Hardcoded for now
+        const padding = 100;
+        for (let i = 0; i < numBlackHoles; i++) {
+            const x = Math.random() * (width - padding * 2) + padding;
+            const y = Math.random() * (height - padding * 2) + padding;
+            this.layerController.addBody('blackHoles', this.blackHoleFactory.createRandomBlackHole(x, y));
+        }
+    }
+    getAllStars() {
+        return this.allStars;
+    }
+}

package/dist/src/controllers/starship-controller.d.ts

@@ -0,0 +1,17 @@
+import { Starship } from '../entities/starship';
+import { LayerController } from './layer-controller';
+import { Star } from '../entities/star';
+import { DebugController } from './debug-controller';
+import type { Clan } from '../entities/clans';
+export declare class StarshipController {
+    private layerController;
+    private clanController;
+    private debugController;
+    private allStarships;
+    constructor(layerController: LayerController, width: number, height: number, debugController: DebugController);
+    private createStarships;
+    manageFleets(width: number, height: number): void;
+    manageStarshipTargets(allStars: Star[]): void;
+    getAllStarships(): Starship[];
+    getAllClans(): Clan[];
+}

package/dist/src/controllers/starship-controller.js

@@ -0,0 +1,58 @@
+import { Starship, STARSHIP_CONFIG } from '../entities/starship';
+import { Fleet } from '../entities/fleet';
+import { ClanController } from './clan-controller';
+export class StarshipController {
+    constructor(layerController, width, height, debugController) {
+        this.allStarships = [];
+        this.layerController = layerController;
+        this.clanController = new ClanController();
+        this.debugController = debugController;
+        this.createStarships(width, height);
+    }
+    createStarships(width, height) {
+        for (let i = 0; i < STARSHIP_CONFIG.COUNT; i++) {
+            const starship = new Starship(Math.random() * width, Math.random() * height, this.debugController);
+            this.layerController.addBody('dynamicObjects', starship);
+            this.allStarships.push(starship);
+        }
+    }
+    manageFleets(width, height) {
+        const desiredFleetSizes = [7, 3, 5, 4, 3, 3];
+        const fleets = this.layerController.getBodies('dynamicObjects').filter(b => b instanceof Fleet);
+        const starships = this.allStarships;
+        // Disband fleets that have lost too many members
+        fleets.forEach(fleet => {
+            if (fleet.isActive && fleet.members.length < fleet.size * 0.5) {
+                fleet.disband();
+            }
+        });
+        desiredFleetSizes.forEach(size => {
+            const fleetExists = fleets.some(f => f.size === size && f.isActive);
+            if (!fleetExists) {
+                const availableShips = starships.filter(s => s.isAvailable());
+                if (availableShips.length >= size) {
+                    const clan = this.clanController.getNextClan();
+                    const fleetMembers = availableShips.slice(0, size);
+                    this.layerController.addBody('dynamicObjects', new Fleet(fleetMembers, clan, width, height));
+                }
+            }
+        });
+    }
+    manageStarshipTargets(allStars) {
+        const idleShips = this.allStarships.filter(ship => ship.state === 'IDLE' && ship.stateTimer <= 0);
+        if (idleShips.length === 0)
+            return;
+        const starsWithDocks = allStars.filter(s => s.dockingPoints.length > 0);
+        if (starsWithDocks.length === 0)
+            return;
+        for (const ship of idleShips) {
+            ship.findNewTarget(starsWithDocks);
+        }
+    }
+    getAllStarships() {
+        return this.allStarships;
+    }
+    getAllClans() {
+        return this.clanController.getClans();
+    }
+}

package/dist/src/draw-debug-line.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @fileoverview Defines a utility function for drawing a debug line with distance.
+ */
+interface Point {
+    x: number;
+    y: number;
+}
+export declare function drawDebugLineWithDistance(ctx: CanvasRenderingContext2D, source: Point, target: Point, drawLine: boolean, showDistance: boolean): void;
+export {};

package/dist/src/draw-debug-line.js

@@ -0,0 +1,29 @@
+/**
+ * @fileoverview Defines a utility function for drawing a debug line with distance.
+ */
+export function drawDebugLineWithDistance(ctx, source, target, drawLine, showDistance) {
+    const dx = target.x - source.x;
+    const dy = target.y - source.y;
+    const dist = Math.sqrt(dx * dx + dy * dy);
+    // Draw the dashed line if requested
+    if (drawLine) {
+        ctx.beginPath();
+        ctx.setLineDash([2, 4]);
+        ctx.moveTo(source.x, source.y);
+        ctx.lineTo(target.x, target.y);
+        ctx.strokeStyle = 'rgba(255, 255, 255, 0.2)';
+        ctx.lineWidth = 0.5;
+        ctx.stroke();
+        ctx.setLineDash([]);
+    }
+    // Draw the distance text if requested
+    if (showDistance) {
+        const midX = source.x + dx / 2;
+        const midY = source.y + dy / 2;
+        ctx.fillStyle = 'rgba(255, 255, 255, 0.4)';
+        ctx.font = '10px "Roboto Mono", monospace';
+        ctx.textAlign = 'center';
+        ctx.textBaseline = 'bottom';
+        ctx.fillText(dist.toFixed(0), midX, midY - 2);
+    }
+}

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

@@ -0,0 +1,15 @@
+import { BlackHole, BlackHoleType } from './black-hole';
+export declare class BlackHoleFactory {
+    /**
+     * Creates a black hole of a random type.
+     */
+    createRandomBlackHole(x: number, y: number): BlackHole;
+    /**
+     * Creates a black hole of a specific type.
+     */
+    createBlackHole(x: number, y: number, type: BlackHoleType): BlackHole;
+    /**
+     * Gets an array of all possible black hole types.
+     */
+    getAllBlackHoleTypes(): BlackHoleType[];
+}

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

@@ -0,0 +1,23 @@
+import { BlackHole } from './black-hole';
+const BLACK_HOLE_TYPES = ['ACCRETION_DISK', 'VORTEX', 'LENSING', 'WARPED_DISK', 'STANDARD'];
+export class BlackHoleFactory {
+    /**
+     * Creates a black hole of a random type.
+     */
+    createRandomBlackHole(x, y) {
+        const randomType = BLACK_HOLE_TYPES[Math.floor(Math.random() * BLACK_HOLE_TYPES.length)];
+        return new BlackHole(x, y, randomType);
+    }
+    /**
+     * Creates a black hole of a specific type.
+     */
+    createBlackHole(x, y, type) {
+        return new BlackHole(x, y, type);
+    }
+    /**
+     * Gets an array of all possible black hole types.
+     */
+    getAllBlackHoleTypes() {
+        return [...BLACK_HOLE_TYPES];
+    }
+}

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

@@ -0,0 +1,9 @@
+/**
+ * @fileoverview Defines all black hole shape rendering functions.
+ */
+import type { BlackHle } from './black-hole';
+export declare const drawStandardShape: (ctx: CanvasRenderingContext2D, hole: BlackHle) => void;
+export declare const drawWarpedDiskShape: (ctx: CanvasRenderingContext2D, hole: BlackHle) => void;
+export declare const drawLensingShape: (ctx: CanvasRenderingContext2D, hole: BlackHle) => void;
+export declare const drawAccretionDiskShape: (ctx: CanvasRenderingContext2D, hole: BlackHle) => void;
+export declare const drawVortexShape: (ctx: CanvasRenderingContext2D, hole: BlackHle) => void;