@where-stars-drift/core 1.0.0

package/src/entities/fleet.ts

@@ -0,0 +1,446 @@
+
+/**
+ * @fileoverview Defines the Fleet class for managing groups of starships.
+ */
+import { Starship, STARSHIP_CONFIG } from './starship';
+import type { Hoverable } from '../base/hoverable';
+import type { Clan } from './clans';
+import { formationRegistry, Formation, StrictFormation } 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"];
+
+type FleetState = 'PATROLLING' | 'REFORMING';
+
+// --- 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 implements Hoverable {
+    id: number;
+    name: string;
+    members: Starship[];
+    size: number;
+    isActive: boolean;
+    clan: Clan;
+    state: FleetState;
+    isHovered: boolean = false;
+    hoverTimer: number;
+    formation: Formation | null;
+    
+    // Fleet movement properties
+    radius: number;
+    hoverRadius: number;
+    speedMultiplier: number;
+    rotation: number; // Current visual rotation
+    targetRotation: number; // Target visual rotation
+
+    constructor(ships: Starship[], clan: Clan, canvasWidth: number, canvasHeight: number) {
+        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.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 = this.formation?.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;
+    }
+
+
+    private 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: Starship[] = [];
+
+        if (this.formation.type === 'Strict') {
+            const strictFormation = this.formation as StrictFormation;
+            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;
+    }
+
+
+    private 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,
+        });
+    }
+
+    private updateShipPositions(): boolean {
+      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: CanvasRenderingContext2D, width: number, height: number) {
+        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;
+            });
+        }
+    }
+    
+    private drawHoverLabel(ctx: CanvasRenderingContext2D) {
+        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();
+    }
+
+    private drawDebugInfo(ctx: CanvasRenderingContext2D) {
+        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: CanvasRenderingContext2D) {
+        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 = this.formation?.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));
+    }
+}