@where-stars-drift/core 1.0.0

package/dist/src/entities/comet.js

@@ -0,0 +1,81 @@
+/**
+ * @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 {
+    constructor(width, height) {
+        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, height) {
+        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, width, height) {
+        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) {
+        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/dist/src/entities/docking-point.d.ts

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

package/dist/src/entities/docking-point.js

@@ -0,0 +1,22 @@
+/**
+ * @fileoverview Defines the DockingPoint class for the night sky simulation.
+ */
+let dockingPointCounter = 0;
+export class DockingPoint {
+    constructor(parent, relativeX, relativeY) {
+        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() {
+        return {
+            x: this.parent.x + this.relativeX,
+            y: this.parent.y + this.relativeY
+        };
+    }
+}

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

@@ -0,0 +1,45 @@
+/**
+ * @fileoverview Defines the Fleet class for managing groups of starships.
+ */
+import { Starship } from './starship';
+import type { Hoverable } from '../base/hoverable';
+import type { Clan } from './clans';
+import { Formation } from './formations';
+import { BoundedBody } from '../base/bounded-body';
+type FleetState = 'PATROLLING' | 'REFORMING';
+export declare const FLEET_CONFIG: {
+    HOVER_GLOW_COLOR: string;
+    HOVER_GLOW_WIDTH: number;
+    RING_COLOR: string;
+    RING_WIDTH: number;
+    HOVER_TIMEOUT: number;
+    ICON_SIZE: number;
+    ICON_MARGIN: number;
+};
+export declare class Fleet extends BoundedBody implements Hoverable {
+    id: number;
+    name: string;
+    members: Starship[];
+    size: number;
+    isActive: boolean;
+    clan: Clan;
+    state: FleetState;
+    isHovered: boolean;
+    hoverTimer: number;
+    formation: Formation | null;
+    radius: number;
+    hoverRadius: number;
+    speedMultiplier: number;
+    rotation: number;
+    targetRotation: number;
+    constructor(ships: Starship[], clan: Clan, canvasWidth: number, canvasHeight: number);
+    disband(): void;
+    private beginReforming;
+    private getBoundingBox;
+    private updateShipPositions;
+    update(ctx: CanvasRenderingContext2D, width: number, height: number): void;
+    private drawHoverLabel;
+    private drawDebugInfo;
+    draw(ctx: CanvasRenderingContext2D): void;
+}
+export {};

package/dist/src/entities/fleet.js

@@ -0,0 +1,374 @@
+/**
+ * @fileoverview Defines the Fleet class for managing groups of starships.
+ */
+import { STARSHIP_CONFIG } from './starship';
+import { formationRegistry } from './formations';
+import { DEBUG_CONFIG } from '../config/simulation';
+import { BoundedBody } from '../base/bounded-body';
+let fleetCounter = 0;
+const FLEET_NAMES = ["Alpha", "Beta", "Gamma", "Delta", "Epsilon", "Zeta", "Eta", "Theta"];
+// --- Fleet Configuration ---
+export const FLEET_CONFIG = {
+    HOVER_GLOW_COLOR: 'rgba(255, 255, 255, 0.5)',
+    HOVER_GLOW_WIDTH: 2,
+    RING_COLOR: 'rgba(255, 255, 255, 0.2)',
+    RING_WIDTH: 0.5,
+    HOVER_TIMEOUT: 120, // 2 seconds in frames
+    ICON_SIZE: 12,
+    ICON_MARGIN: 8,
+};
+export class Fleet extends BoundedBody {
+    constructor(ships, clan, canvasWidth, canvasHeight) {
+        var _a;
+        const formation = formationRegistry.getFormationForFleet(ships);
+        const formationOffsets = formation ? formation.getPosition(ships) : [];
+        const maxOffset = formationOffsets.reduce((max, offset) => {
+            const dist = Math.sqrt(offset.x * offset.x + offset.y * offset.y);
+            return Math.max(max, dist);
+        }, 0);
+        const radius = maxOffset + STARSHIP_CONFIG.FORMATION_PADDING;
+        const safePadding = radius * 1.2;
+        const x = Math.random() * (canvasWidth - 2 * safePadding) + safePadding;
+        const y = Math.random() * (canvasHeight - 2 * safePadding) + safePadding;
+        super(x, y, radius);
+        this.isHovered = false;
+        this.boundingRadius = radius;
+        this.id = ++fleetCounter;
+        this.name = `${FLEET_NAMES[this.id % FLEET_NAMES.length]} Fleet #${this.id}`;
+        this.members = ships;
+        this.size = ships.length;
+        this.isActive = true;
+        this.clan = clan;
+        this.state = 'PATROLLING';
+        this.hoverTimer = 0;
+        this.formation = formation;
+        if (!this.formation || formationOffsets.length === 0) {
+            console.warn(`Fleet ${this.name} (${this.id}) created but got no valid formation or positions. Fleet will be inactive.`);
+            this.isActive = false;
+        }
+        this.radius = radius;
+        this.hoverRadius = this.radius * 1.2; // 20% larger hover area
+        this.speedMultiplier = Math.random() * 0.2 + 0.8; // Speed between 80% and 100% of normal
+        const baseSpeed = STARSHIP_CONFIG.MAX_SPEED * this.speedMultiplier;
+        const angle = Math.random() * 2 * Math.PI;
+        this.vx = Math.cos(angle) * baseSpeed;
+        this.vy = Math.sin(angle) * baseSpeed;
+        this.rotation = Math.atan2(this.vy, this.vx); // Initial rotation
+        this.targetRotation = this.rotation;
+        const rotatedOffsets = ((_a = this.formation) === null || _a === void 0 ? void 0 : _a.getPosition(this.members).map(offset => {
+            const rotatedX = offset.x * Math.cos(this.rotation) - offset.y * Math.sin(this.rotation);
+            const rotatedY = offset.x * Math.sin(this.rotation) + offset.y * Math.cos(this.rotation);
+            return { x: rotatedX, y: rotatedY };
+        })) || [];
+        this.members.forEach((ship, i) => {
+            ship.fleet = this;
+            ship.state = 'IN_FORMATION';
+            if (i >= rotatedOffsets.length)
+                return;
+            const offset = rotatedOffsets[i];
+            ship.x = this.x + offset.x;
+            ship.y = this.y + offset.y;
+            ship.rotation = this.rotation + Math.PI / 2;
+        });
+        // Register with the clan
+        this.clan.fleets.push(this);
+        this.clan.starships.push(...this.members);
+        this.clan.fleetsCount = this.clan.fleets.length;
+        this.clan.starshipsCount = this.clan.starships.length;
+    }
+    disband() {
+        this.isActive = false;
+        // Unregister from the clan
+        const fleetIndex = this.clan.fleets.indexOf(this);
+        if (fleetIndex > -1) {
+            this.clan.fleets.splice(fleetIndex, 1);
+        }
+        this.clan.fleetsCount = this.clan.fleets.length;
+        this.members.forEach(ship => {
+            ship.fleet = null;
+            ship.state = 'IDLE';
+            const shipIndex = this.clan.starships.indexOf(ship);
+            if (shipIndex > -1) {
+                this.clan.starships.splice(shipIndex, 1);
+            }
+        });
+        this.clan.starshipsCount = this.clan.starships.length;
+    }
+    beginReforming() {
+        if (!this.formation)
+            return;
+        this.state = 'REFORMING';
+        this.targetRotation = Math.atan2(this.vy, this.vx);
+        const formationOffsets = this.formation.getPosition(this.members);
+        const sortedShips = [];
+        if (this.formation.type === 'Strict') {
+            const strictFormation = this.formation;
+            const availableShips = [...this.members];
+            strictFormation.composition.forEach(role => {
+                for (let i = 0; i < role.count; i++) {
+                    const shipIndex = availableShips.findIndex(s => s.shipClass.name === role.shipClassName);
+                    if (shipIndex !== -1) {
+                        sortedShips.push(availableShips.splice(shipIndex, 1)[0]);
+                    }
+                }
+            });
+            sortedShips.push(...availableShips);
+        }
+        else {
+            const unassignedShips = [...this.members];
+            const unassignedSlots = [...formationOffsets];
+            while (unassignedShips.length > 0 && unassignedSlots.length > 0) {
+                let bestShipIndex = -1;
+                let bestSlotIndex = -1;
+                let closestDistSq = Infinity;
+                for (let i = 0; i < unassignedShips.length; i++) {
+                    for (let j = 0; j < unassignedSlots.length; j++) {
+                        const ship = unassignedShips[i];
+                        const slot = unassignedSlots[j];
+                        const distSq = (ship.x - (this.x + slot.x)) ** 2 + (ship.y - (this.y + slot.y)) ** 2;
+                        if (distSq < closestDistSq) {
+                            closestDistSq = distSq;
+                            bestShipIndex = i;
+                            bestSlotIndex = j;
+                        }
+                    }
+                }
+                if (bestShipIndex !== -1 && bestSlotIndex !== -1) {
+                    sortedShips.push(unassignedShips.splice(bestShipIndex, 1)[0]);
+                    unassignedSlots.splice(bestSlotIndex, 1);
+                }
+                else {
+                    break;
+                }
+            }
+            sortedShips.push(...unassignedShips);
+        }
+        this.members = sortedShips;
+    }
+    getBoundingBox() {
+        if (this.members.length === 0) {
+            return { minX: this.x, minY: this.y, maxX: this.x, maxY: this.y };
+        }
+        return this.members.reduce((acc, ship) => ({
+            minX: Math.min(acc.minX, ship.x - ship.boundingRadius),
+            minY: Math.min(acc.minY, ship.y - ship.boundingRadius),
+            maxX: Math.max(acc.maxX, ship.x + ship.boundingRadius),
+            maxY: Math.max(acc.maxY, ship.y + ship.boundingRadius),
+        }), {
+            minX: Infinity,
+            minY: Infinity,
+            maxX: -Infinity,
+            maxY: -Infinity,
+        });
+    }
+    updateShipPositions() {
+        if (!this.formation || this.members.length === 0)
+            return true;
+        let allShipsInPosition = true;
+        const formationOffsets = this.formation.getPosition(this.members);
+        this.members.forEach((ship, i) => {
+            if (i >= formationOffsets.length)
+                return;
+            let offset = formationOffsets[i];
+            const rotatedX = offset.x * Math.cos(this.rotation) - offset.y * Math.sin(this.rotation);
+            const rotatedY = offset.x * Math.sin(this.rotation) + offset.y * Math.cos(this.rotation);
+            const targetX = this.x + rotatedX;
+            const targetY = this.y + rotatedY;
+            ship.accelerateToPosition(targetX, targetY);
+            const dx = targetX - ship.x;
+            const dy = targetY - ship.y;
+            const dist = Math.sqrt(dx * dx + dy * dy);
+            if (dist > 1) {
+                allShipsInPosition = false;
+            }
+        });
+        return allShipsInPosition;
+    }
+    update(ctx, width, height) {
+        if (!this.isActive || !this.formation)
+            return;
+        this.x += this.vx;
+        this.y += this.vy;
+        const padding = this.radius * 0.2;
+        let bounced = false;
+        const { minX, minY, maxX, maxY } = this.getBoundingBox();
+        let changed = false;
+        if (minX < padding && this.vx < 0) {
+            this.vx *= -1;
+            changed = true;
+        }
+        if (maxX > width - padding && this.vx > 0) {
+            this.vx *= -1;
+            changed = true;
+        }
+        if (minY < padding && this.vy < 0) {
+            this.vy *= -1;
+            changed = true;
+        }
+        if (maxY > height - padding && this.vy > 0) {
+            this.vy *= -1;
+            changed = true;
+        }
+        if (changed) {
+            bounced = true;
+        }
+        if (bounced && this.state !== 'REFORMING') {
+            this.beginReforming();
+        }
+        if (this.state === 'REFORMING') {
+            let angleDiff = this.targetRotation - this.rotation;
+            while (angleDiff > Math.PI)
+                angleDiff -= 2 * Math.PI;
+            while (angleDiff < -Math.PI)
+                angleDiff += 2 * Math.PI;
+            this.rotation += angleDiff * 0.05;
+            const areAllShipsInPosition = this.updateShipPositions();
+            const isRotationComplete = Math.abs(angleDiff) < 0.01;
+            if (isRotationComplete && areAllShipsInPosition) {
+                this.state = 'PATROLLING';
+                this.rotation = this.targetRotation;
+                const baseSpeed = STARSHIP_CONFIG.MAX_SPEED * this.speedMultiplier * (Math.random() * 0.2 + 0.9);
+                this.vx = Math.cos(this.rotation) * baseSpeed;
+                this.vy = Math.sin(this.rotation) * baseSpeed;
+            }
+        }
+        else if (this.state === 'PATROLLING') {
+            this.rotation = Math.atan2(this.vy, this.vx);
+            const currentOffsets = this.formation.getPosition(this.members);
+            this.members.forEach((ship, i) => {
+                if (i >= currentOffsets.length)
+                    return;
+                const offset = currentOffsets[i];
+                const rotatedX = offset.x * Math.cos(this.rotation) - offset.y * Math.sin(this.rotation);
+                const rotatedY = offset.x * Math.sin(this.rotation) + offset.y * Math.cos(this.rotation);
+                ship.x = this.x + rotatedX;
+                ship.y = this.y + rotatedY;
+                ship.vx = this.vx;
+                ship.vy = this.vy;
+                ship.rotation = this.rotation + Math.PI / 2;
+            });
+        }
+    }
+    drawHoverLabel(ctx) {
+        const iconY = this.y - this.radius - FLEET_CONFIG.ICON_MARGIN - FLEET_CONFIG.ICON_SIZE;
+        ctx.save();
+        ctx.translate(this.x, iconY);
+        ctx.fillStyle = this.clan.color;
+        ctx.strokeStyle = this.clan.color;
+        ctx.lineWidth = 1.5;
+        this.clan.icon(ctx, FLEET_CONFIG.ICON_SIZE);
+        ctx.restore();
+    }
+    drawDebugInfo(ctx) {
+        const startX = this.x + this.radius + 15;
+        let startY = this.y - (this.members.length / 2 * 12);
+        const boxPadding = 10;
+        const lineHeight = 14;
+        const infoLines = [
+            `Fleet: ${this.name} (ID: ${this.id})`,
+            `Clan: ${this.clan.name}`,
+            `Ships: ${this.members.length}`,
+            `Formation: ${this.formation ? this.formation.name : 'None'}`,
+            `State: ${this.state}`,
+            '--- Roster ---',
+            ...this.members.map(ship => `> ${ship.name} (${ship.shipClass.name})`),
+        ];
+        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;
+        // Draw background box
+        ctx.fillStyle = 'rgba(0, 0, 0, 0.7)';
+        ctx.strokeStyle = this.clan.color;
+        ctx.lineWidth = 1;
+        ctx.beginPath();
+        ctx.roundRect(startX, boxY, boxWidth, boxHeight, 5);
+        ctx.fill();
+        ctx.stroke();
+        // Draw text
+        ctx.fillStyle = 'white';
+        ctx.font = '10px "Roboto Mono", monospace';
+        ctx.textAlign = 'left';
+        ctx.textBaseline = 'top';
+        infoLines.forEach((line, index) => {
+            if (line.startsWith('>')) {
+                ctx.fillStyle = '#aaa';
+            }
+            else if (line.startsWith('---')) {
+                ctx.fillStyle = '#ccc';
+            }
+            else {
+                ctx.fillStyle = 'white';
+            }
+            ctx.fillText(line, startX + boxPadding, boxY + boxPadding + index * lineHeight);
+        });
+    }
+    draw(ctx) {
+        var _a;
+        if (!this.isActive)
+            return;
+        this.isHovered = this.hoverTimer > 0;
+        if (this.isHovered) {
+            ctx.strokeStyle = FLEET_CONFIG.HOVER_GLOW_COLOR;
+            ctx.lineWidth = FLEET_CONFIG.HOVER_GLOW_WIDTH;
+            ctx.shadowColor = FLEET_CONFIG.HOVER_GLOW_COLOR;
+            ctx.shadowBlur = 10;
+            ctx.beginPath();
+            ctx.arc(this.x, this.y, this.radius, 0, Math.PI * 2);
+            ctx.stroke();
+            ctx.shadowBlur = 0;
+            this.drawHoverLabel(ctx);
+            if (DEBUG_CONFIG.SHOW_DEBUG_INFO && DEBUG_CONFIG.SHOW_ENTITY_HOVER_INFO) {
+                this.drawDebugInfo(ctx);
+            }
+        }
+        else {
+            ctx.beginPath();
+            ctx.strokeStyle = FLEET_CONFIG.RING_COLOR;
+            ctx.lineWidth = FLEET_CONFIG.RING_WIDTH;
+            ctx.setLineDash([2, 3]);
+            ctx.arc(this.x, this.y, this.radius, 0, Math.PI * 2);
+            ctx.stroke();
+            ctx.setLineDash([]);
+        }
+        if (DEBUG_CONFIG.SHOW_DEBUG_INFO && DEBUG_CONFIG.SHOW_FORMATION_TARGET_DOTS && this.state === 'REFORMING') {
+            const formationOffsets = ((_a = this.formation) === null || _a === void 0 ? void 0 : _a.getPosition(this.members)) || [];
+            this.members.forEach((ship, i) => {
+                if (i >= formationOffsets.length)
+                    return;
+                // Ideal position (RED)
+                const offset = formationOffsets[i];
+                const rotatedX = offset.x * Math.cos(this.rotation) - offset.y * Math.sin(this.rotation);
+                const rotatedY = offset.x * Math.sin(this.rotation) + offset.y * Math.cos(this.rotation);
+                const idealX = this.x + rotatedX;
+                const idealY = this.y + rotatedY;
+                // Ship's immediate target (YELLOW) - This is a simplification.
+                // In the current logic, the idealX/Y IS the target.
+                const targetX = idealX;
+                const targetY = idealY;
+                // Compare ideal vs target to decide color
+                const dx = idealX - targetX;
+                const dy = idealY - targetY;
+                const distSq = dx * dx + dy * dy;
+                if (distSq < 0.1) {
+                    // Positions match, draw GREEN
+                    ctx.fillStyle = 'lime';
+                    ctx.beginPath();
+                    ctx.arc(idealX, idealY, 2, 0, Math.PI * 2);
+                    ctx.fill();
+                }
+                else {
+                    // Positions do not match, draw RED and YELLOW
+                    ctx.fillStyle = 'red';
+                    ctx.beginPath();
+                    ctx.arc(idealX, idealY, 2, 0, Math.PI * 2);
+                    ctx.fill();
+                    ctx.fillStyle = 'yellow';
+                    ctx.beginPath();
+                    ctx.arc(targetX, targetY, 2, 0, Math.PI * 2);
+                    ctx.fill();
+                }
+            });
+        }
+        this.members.forEach(ship => ship.draw(ctx));
+    }
+}

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

@@ -0,0 +1,51 @@
+/**
+ * @fileoverview Defines all fleet formations and a registry to manage them.
+ */
+import type { Starship } from './starship';
+type FormationCategory = 'Military' | 'Mixed';
+/**
+ * Common properties for all formations.
+ */
+interface IFormation {
+    name: string;
+    category: FormationCategory;
+    description: string;
+    getPosition: (ships: Starship[]) => {
+        x: number;
+        y: number;
+    }[];
+}
+/**
+ * Strict formations are role-dependent and class-specific.
+ * They require a specific composition of ship classes to be effective.
+ */
+export interface StrictFormation extends IFormation {
+    type: 'Strict';
+    composition: {
+        shipClassName: string;
+        count: number;
+    }[];
+}
+/**
+ * Free formations are geometry-based and adaptable to any ship composition.
+ * They prioritize spatial arrangement over specific ship roles.
+ */
+export interface FreeFormation extends IFormation {
+    type: 'Free';
+}
+export type Formation = StrictFormation | FreeFormation;
+declare class FormationRegistry {
+    private formations;
+    private strictFormations;
+    private freeFormations;
+    constructor();
+    /**
+     * Finds a suitable formation for a given fleet based on its composition.
+     * @param fleetShips The list of starships in the fleet.
+     * @returns A formation, or null if no suitable formation is found.
+     */
+    getFormationForFleet(fleetShips: Starship[]): Formation | null;
+    getAllFormations(): Formation[];
+}
+export declare const formationRegistry: FormationRegistry;
+export {};