fix: SAMs unable to target warheads due to close spawns

src/client/render/frame/derive/NukeTelegraphs.ts

@@ -47,10 +47,16 @@ export function extractNukeTelegraphs(
   localPlayerID = 0,
   relationMatrix?: Uint8Array,
   relationSize = 0,
+  motionPlans?: ReadonlyMap<number, { startTick: number }>,
+  currentTick = 0,
 ): NukeTelegraphData[] {
   const telegraphs: NukeTelegraphData[] = [];
   for (const u of units.values()) {
     if (u.targetTile === null || !u.isActive) continue;
+
+    const plan = motionPlans?.get(u.id);
+    if (plan && plan.startTick > currentTick) continue;
+
     const mag = NUKE_MAGNITUDES[u.unitType];
     if (!mag) continue;
     telegraphs.push({
@@ -80,11 +86,17 @@ export function extractNukeTelegraphsFromIds(
   localPlayerID = 0,
   relationMatrix?: Uint8Array,
   relationSize = 0,
+  motionPlans?: ReadonlyMap<number, { startTick: number }>,
+  currentTick = 0,
 ): NukeTelegraphData[] {
   const telegraphs: NukeTelegraphData[] = [];
   for (const id of nukeIds) {
     const u = units.get(id);
     if (!u || u.targetTile === null || !u.isActive) continue;
+
+    const plan = motionPlans?.get(u.id);
+    if (plan && plan.startTick > currentTick) continue;
+
     const mag = NUKE_MAGNITUDES[u.unitType];
     if (!mag) continue;
     telegraphs.push({

src/client/render/gl/passes/PointLightPass.ts

@@ -187,7 +187,7 @@ export class PointLightPass {
     this.lastUnitsUpdateMs = performance.now();
 
     for (const unit of units.values()) {
-      if (!unit.isActive) continue;
+      if (!unit.isActive || unit.waitTicks > 0) continue;
       const typeIdx = this.typeToIdx.get(unit.unitType);
       if (typeIdx === undefined) continue;
       const cfg = this.typeConfigs[typeIdx];

src/client/render/gl/passes/UnitPass.ts

@@ -435,7 +435,7 @@ export class UnitPass {
     this.lastUnitsUpdateMs = performance.now();
 
     for (const unit of units.values()) {
-      if (!unit.isActive) continue;
+      if (!unit.isActive || unit.waitTicks > 0) continue;
 
       let atlasIdx = this.typeToAtlasCol.get(unit.unitType);
 

src/client/render/types/Renderer.ts

@@ -98,6 +98,7 @@ export interface UnitState {
   reachedTarget: boolean;
   retreating: boolean;
   targetable: boolean;
+  waitTicks: number;
   markedForDeletion: number | false; // -1 -> false, else tick
   health: number | null;
   underConstruction: boolean;

src/client/view/GameView.ts

@@ -622,6 +622,8 @@ export class GameView implements GameMap {
       // carried over on the frame from the last rebuild.
       f.relationMatrix,
       f.relationSize,
+      this.unitMotionPlans,
+      gu.tick,
     );
     f.attackRings = this._myPlayer
       ? extractAttackRings(

src/client/view/UnitView.ts

@@ -1,4 +1,5 @@
 import {
+  NukeState,
   Tick,
   TrainType,
   TransportShipState,
@@ -57,6 +58,7 @@ function unitStateFromUpdate(u: UnitUpdate): UnitState {
       (u.transportShipState?.isRetreating ?? false) ||
       u.warshipState?.state === "retreating",
     targetable: u.targetable,
+    waitTicks: u.nukeState?.waitTicks ?? 0,
     markedForDeletion: u.markedForDeletion,
     health: u.health ?? null,
     underConstruction: u.underConstruction ?? false,
@@ -86,6 +88,7 @@ function applyUpdateInPlace(target: UnitState, u: UnitUpdate): void {
     (u.transportShipState?.isRetreating ?? false) ||
     u.warshipState?.state === "retreating";
   target.targetable = u.targetable;
+  target.waitTicks = u.nukeState?.waitTicks ?? 0;
   target.markedForDeletion = u.markedForDeletion;
   target.health = u.health ?? null;
   target.underConstruction = u.underConstruction ?? false;
@@ -108,6 +111,7 @@ export class UnitView {
   /** Engine-only fields not in UnitState. Use warshipState() / transportShipState() to read. */
   private _warshipState?: WarshipState;
   private _transportShipState?: TransportShipState;
+  private _nukeState?: NukeState;
   private _createdAt: Tick;
 
   constructor(
@@ -117,6 +121,7 @@ export class UnitView {
     this.state = unitStateFromUpdate(data);
     this._warshipState = data.warshipState;
     this._transportShipState = data.transportShipState;
+    this._nukeState = data.nukeState;
     this.lastPos.push(data.pos);
     this._createdAt = this.gameView.ticks();
     if (this.state.underConstruction) {
@@ -150,6 +155,7 @@ export class UnitView {
     applyUpdateInPlace(this.state, data);
     this._warshipState = data.warshipState;
     this._transportShipState = data.transportShipState;
+    this._nukeState = data.nukeState;
     // constructionStartTick: set on transition into underConstruction.
     if (this.state.underConstruction && !wasUnderConstruction) {
       this.state.constructionStartTick = this.gameView.ticks();
@@ -214,6 +220,15 @@ export class UnitView {
   ): void {
     throw new Error("updateTransportShipState is not supported on UnitView");
   }
+  nukeState(): NukeState {
+    if (this._nukeState === undefined) {
+      throw new Error("nukeState called on non-nuke unit");
+    }
+    return this._nukeState;
+  }
+  updateNukeState(_update: NukeState): void {
+    throw new Error("updateNukeState is not supported on UnitView");
+  }
   tile(): TileRef {
     return this.state.pos;
   }

src/core/execution/MIRVExecution.ts

@@ -33,6 +33,8 @@ export class MirvExecution implements Execution {
   private random: PseudoRandom;
 
   private pathFinder: ParabolaUniversalPathFinder;
+  private fullPath: TileRef[] = [];
+  private pathIndex = 0;
 
   private targetPlayer: Player | TerraNullius;
 
@@ -41,6 +43,9 @@ export class MirvExecution implements Execution {
 
   private speed: number = -1;
 
+  private stagedTargets: TileRef[] = [];
+  private warheadsSpawned = false;
+
   constructor(
     private player: Player,
     private dst: TileRef,
@@ -54,6 +59,9 @@ export class MirvExecution implements Execution {
     this.pathFinder = UniversalPathFinding.Parabola(mg, {
       increment: this.speed,
     });
+    this.baseX = this.mg.x(this.dst);
+    this.baseY = this.mg.y(this.dst);
+    this.stagedTargets = [this.dst];
 
     // Betrayal on launch
     if (this.targetPlayer.isPlayer()) {
@@ -81,12 +89,24 @@ export class MirvExecution implements Execution {
         targetTile: this.dst,
       });
       this.mg.stats().bombLaunch(this.player, this.targetPlayer, UnitType.MIRV);
-      const x = Math.floor(
-        (this.mg.x(this.dst) + this.mg.x(this.nuke.tile())) / 2,
-      );
-      const y = Math.max(0, this.mg.y(this.dst) - 500) + 50;
+      const x = Math.floor((this.baseX + this.mg.x(this.nuke.tile())) / 2);
+      const y = Math.max(0, this.baseY - 500) + 50;
       this.separateDst = this.mg.ref(x, y);
 
+      let result = this.pathFinder.next(
+        this.spawnTile,
+        this.separateDst,
+        this.speed,
+      );
+      while (result.status === PathStatus.NEXT) {
+        this.fullPath.push(result.node);
+        result = this.pathFinder.next(
+          this.spawnTile,
+          this.separateDst,
+          this.speed,
+        );
+      }
+
       this.mg.displayIncomingUnit(
         this.nuke.id(),
         // TODO TranslateText
@@ -104,61 +124,81 @@ export class MirvExecution implements Execution {
       }
     }
 
-    const result = this.pathFinder.next(
-      this.spawnTile,
-      this.separateDst,
-      this.speed,
-    );
-    if (result.status === PathStatus.COMPLETE) {
+    const remainingTicks = this.fullPath.length - this.pathIndex;
+
+    // Stagger destination finding across ticks 20 down to 11 before separation
+    if (remainingTicks <= 20 && remainingTicks > 10) {
+      for (let attempt = 0; attempt < 100; attempt++) {
+        if (this.stagedTargets.length >= this.warheadCount) break;
+
+        const target = this.tryGenerateTarget(this.stagedTargets);
+        if (target) this.stagedTargets.push(target);
+      }
+    }
+
+    // At <= 10 ticks before separation, re-validate tile ownership, finalize targets, sort, and instantiate NukeExecutions for SAM detection
+    if (remainingTicks <= 10 && !this.warheadsSpawned) {
+      this.warheadsSpawned = true;
+      // Compensate missed precomputing targets if remainingTicks started <15
+      const extraAttempts = (10 - remainingTicks) * 50;
+      this.finalizeDestinations(500 + extraAttempts);
+      this.spawnWarheadsWithWait();
+    }
+
+    if (this.pathIndex < this.fullPath.length) {
+      this.nuke.move(this.fullPath[this.pathIndex++]);
+    } else {
       this.separate();
       this.active = false;
       // Record stats
       this.mg.stats().bombLand(this.player, this.targetPlayer, UnitType.MIRV);
-      return;
-    } else if (result.status === PathStatus.NEXT) {
-      this.nuke.move(result.node);
     }
   }
 
-  private separate() {
-    if (this.nuke === null) {
-      throw new Error("uninitialized");
+  private finalizeDestinations(additionalAttempts = 500): void {
+    // Re-check target tile ownership at tick 10
+    this.stagedTargets = this.stagedTargets.filter(
+      (tile) => tile === this.dst || this.mg.owner(tile) === this.targetPlayer,
+    );
+
+    // Top-up loop using specified attempt budget if targets were lost or not yet filled
+    for (let attempt = 0; attempt < additionalAttempts; attempt++) {
+      if (this.stagedTargets.length >= this.warheadCount) break;
+      const target = this.tryGenerateTarget(this.stagedTargets);
+      if (target) this.stagedTargets.push(target);
     }
 
-    this.baseX = this.mg.x(this.dst);
-    this.baseY = this.mg.y(this.dst);
+    // Sort in place
+    this.stagedTargets.sort(
+      (a, b) =>
+        this.mg.manhattanDist(b, this.dst) - this.mg.manhattanDist(a, this.dst),
+    );
+  }
+
+  private spawnWarheadsWithWait(): void {
+    if (this.nuke === null) return;
 
-    const destinations = this.selectDestinations();
     const warheadSpeed = this.mg.config().nukeSpeed(UnitType.MIRVWarhead);
-    for (const [i, dst] of destinations.entries()) {
+    for (const [i, dst] of this.stagedTargets.entries()) {
       this.mg.addExecution(
         new NukeExecution(
           UnitType.MIRVWarhead,
           this.player,
           dst,
-          this.nuke.tile(),
+          this.separateDst,
           warheadSpeed + Math.floor((i / this.warheadCount) * 5),
-          //   this.random.nextInt(5, 9),
-          this.random.nextInt(0, 15),
+          10 + this.random.nextInt(0, 15),
         ),
       );
     }
-    this.nuke.delete(false);
   }
 
-  private selectDestinations(): TileRef[] {
-    const targets: TileRef[] = [this.dst];
-
-    for (let attempt = 0; attempt < 1000; attempt++) {
-      const target = this.tryGenerateTarget(targets);
-      if (target) targets.push(target);
-      if (targets.length >= this.warheadCount) break;
+  private separate() {
+    if (this.nuke === null) {
+      throw new Error("uninitialized");
     }
 
-    return targets.sort(
-      (a, b) =>
-        this.mg.manhattanDist(b, this.dst) - this.mg.manhattanDist(a, this.dst),
-    );
+    this.nuke.delete(false);
   }
 
   private tryGenerateTarget(taken: TileRef[]): TileRef | undefined {

src/core/execution/NukeExecution.ts

@@ -208,6 +208,7 @@ export class NukeExecution implements Execution {
         targetTile: this.dst,
         trajectory: this.getTrajectory(this.dst),
       });
+      this.nuke.updateNukeState({ waitTicks: this.waitTicks });
       this.recordMotionPlan(ticks);
       if (this.nuke.type() !== UnitType.MIRVWarhead) {
         this.maybeBreakAlliances();
@@ -252,7 +253,7 @@ export class NukeExecution implements Execution {
     }
 
     if (this.waitTicks > 0) {
-      this.waitTicks--;
+      this.nuke.updateNukeState({ waitTicks: --this.waitTicks });
       return;
     }
 

src/core/execution/SAMLauncherExecution.ts

@@ -77,7 +77,7 @@ class SAMTargetingSystem {
   ): InterceptionTile | undefined {
     const trajectory = unit.trajectory();
     const currentIndex = unit.trajectoryIndex();
-
+    const waitTicks = unit.nukeState().waitTicks ?? 0;
     // NukeExecution happens before SAMMissileExecution. It cannot intercept the final tick.
     const maxInterceptionIndex = trajectory.length - 2;
     for (let i = currentIndex; i <= maxInterceptionIndex; i++) {
@@ -87,7 +87,7 @@ class SAMTargetingSystem {
         this.mg.euclideanDistSquared(samTile, trajectoryTile.tile) <=
           rangeSquared
       ) {
-        const nukeTickToReach = i - currentIndex;
+        const nukeTickToReach = i - currentIndex + waitTicks;
         const samTickToReach = this.tickToReach(samTile, trajectoryTile.tile);
         const tickBeforeShooting = nukeTickToReach - samTickToReach;
         if (tickBeforeShooting >= 0) {
@@ -106,7 +106,7 @@ class SAMTargetingSystem {
     ) {
       const targetInFlightTile = trajectory[maxInterceptionIndex];
       if (targetInFlightTile && targetInFlightTile.targetable) {
-        const nukeTickToReach = maxInterceptionIndex - currentIndex;
+        const nukeTickToReach = maxInterceptionIndex - currentIndex + waitTicks;
         const samTickToReach = this.tickToReach(
           samTile,
           targetInFlightTile.tile,
@@ -306,14 +306,15 @@ export class SAMLauncherExecution implements Execution {
       this.player = this.sam.owner();
     }
 
-    const frontTime = this.sam.missileTimerQueue()[0];
-    if (frontTime !== undefined) {
+    while (this.sam.missileTimerQueue().length > 0) {
+      const frontTime = this.sam.missileTimerQueue()[0];
       const cooldown =
         this.mg.config().SAMCooldown() - (this.mg.ticks() - frontTime);
 
-      if (cooldown <= 0) {
-        this.sam.reloadMissile();
+      if (cooldown > 0) {
+        break;
       }
+      this.sam.reloadMissile();
     }
     if (this.sam.isInCooldown()) {
       return;