spawn

src/client/ClientGameRunner.ts

@@ -524,7 +524,7 @@ export class ClientGameRunner {
         if (
           !this.gameView.inSpawnPhase() &&
           !hasGoneToPlayer &&
-          this.gameView.myPlayer()
+          this.gameView.myPlayer()?.nameLocation()
         ) {
           hasGoneToPlayer = true;
           this.eventBus.emit(new GoToPlayerEvent(this.gameView.myPlayer()!, 8));

src/client/graphics/layers/GameRightSidebar.ts

@@ -58,7 +58,6 @@ export class GameRightSidebar extends LitElement implements Layer {
       this.game?.config()?.gameConfig()?.gameType === GameType.Singleplayer ||
       this.game.config().isReplay();
     this._isVisible = true;
-    this.game.inSpawnPhase();
 
     this.eventBus.on(SpawnBarVisibleEvent, (e) => {
       this.spawnBarVisible = e.visible;
@@ -113,10 +112,6 @@ export class GameRightSidebar extends LitElement implements Layer {
     }
 
     const maxTimerValue = this.game.config().gameConfig().maxTimerValue;
-    const spawnPhaseTurns = this.game.config().numSpawnPhaseTurns();
-    const ticks = this.game.ticks();
-    const gameTicks = Math.max(0, ticks - spawnPhaseTurns);
-    const elapsedSeconds = Math.floor(gameTicks / 10); // 10 ticks per second
 
     if (this.game.inSpawnPhase()) {
       this.timer =
@@ -126,6 +121,8 @@ export class GameRightSidebar extends LitElement implements Layer {
       return;
     }
 
+    const elapsedSeconds = Math.floor(this.game.elapsedGameSeconds());
+
     if (this.hasWinner) {
       return;
     }

src/client/graphics/layers/SpawnTimer.ts

@@ -1,7 +1,7 @@
 import { LitElement, html } from "lit";
 import { customElement } from "lit/decorators.js";
 import { EventBus, GameEvent } from "../../../core/EventBus";
-import { GameMode, Team } from "../../../core/game/Game";
+import { GameMode, GameType, Team } from "../../../core/game/Game";
 import { GameView } from "../../../core/game/GameView";
 import { TransformHandler } from "../TransformHandler";
 import { Layer } from "./Layer";
@@ -41,6 +41,17 @@ export class SpawnTimer extends LitElement implements Layer {
   }
 
   tick() {
+    if (
+      this.game.config().gameConfig().gameType === GameType.Singleplayer &&
+      this.game.inSpawnPhase()
+    ) {
+      // Singleplayer has no spawn countdown.
+      this.ratios = [];
+      this.colors = [];
+      this.requestUpdate();
+      return;
+    }
+
     if (this.game.inSpawnPhase()) {
       // During spawn phase, only one segment filling full width
       this.ratios = [

src/core/GameRunner.ts

@@ -2,11 +2,13 @@ import { placeName } from "../client/graphics/NameBoxCalculator";
 import { getGameLogicConfig } from "./configuration/ConfigLoader";
 import { Executor } from "./execution/ExecutionManager";
 import { RecomputeRailClusterExecution } from "./execution/RecomputeRailClusterExecution";
+import { SpawnTimerExecution } from "./execution/SpawnTimerExecution";
 import { WinCheckExecution } from "./execution/WinCheckExecution";
 import {
   AllPlayers,
   BuildableUnit,
   Game,
+  GameType,
   GameUpdates,
   NameViewData,
   Player,
@@ -104,6 +106,9 @@ export class GameRunner {
     if (this.game.config().spawnNations()) {
       this.game.addExecution(...this.execManager.nationExecutions());
     }
+    if (this.game.config().gameConfig().gameType !== GameType.Singleplayer) {
+      this.game.addExecution(new SpawnTimerExecution());
+    }
     this.game.addExecution(new WinCheckExecution());
     if (!this.game.config().isUnitDisabled(UnitType.Factory)) {
       this.game.addExecution(
@@ -130,6 +135,7 @@ export class GameRunner {
     );
     this.currTurn++;
 
+    const wasInSpawnPhase = this.game.inSpawnPhase();
     let updates: GameUpdates;
     let tickExecutionDuration: number = 0;
 
@@ -164,7 +170,12 @@ export class GameRunner {
         );
     }
 
-    if (this.game.ticks() < 3 || this.game.ticks() % 30 === 0) {
+    const spawnJustEnded = wasInSpawnPhase && !this.game.inSpawnPhase();
+    if (
+      spawnJustEnded ||
+      this.game.ticks() < 3 ||
+      this.game.ticks() % 30 === 0
+    ) {
       this.game.players().forEach((p) => {
         this.playerViewData[p.id()] = placeName(this.game, p);
       });

src/core/execution/SpawnExecution.ts

@@ -1,6 +1,7 @@
 import {
   Execution,
   Game,
+  GameType,
   Player,
   PlayerInfo,
   PlayerType,
@@ -39,11 +40,6 @@ export class SpawnExecution implements Execution {
   tick(ticks: number) {
     this.active = false;
 
-    if (!this.mg.inSpawnPhase()) {
-      this.active = false;
-      return;
-    }
-
     let player: Player | null = null;
     if (this.mg.hasPlayer(this.playerInfo.id)) {
       player = this.mg.player(this.playerInfo.id);
@@ -76,6 +72,15 @@ export class SpawnExecution implements Execution {
     }
 
     player.setSpawnTile(spawn.center);
+
+    if (
+      this.mg.config().gameConfig().gameType === GameType.Singleplayer &&
+      this.playerInfo.playerType === PlayerType.Human
+    ) {
+      // In singleplayer, spawn ends when player selects
+      // a spawn location.
+      this.mg.endSpawnPhase();
+    }
   }
 
   isActive(): boolean {

src/core/execution/SpawnTimerExecution.ts

@@ -0,0 +1,23 @@
+import { Execution, Game } from "../game/Game";
+
+export class SpawnTimerExecution implements Execution {
+  private mg: Game;
+
+  init(mg: Game, ticks: number): void {
+    this.mg = mg;
+  }
+
+  tick(ticks: number): void {
+    if (this.mg.ticks() > this.mg.config().numSpawnPhaseTurns()) {
+      this.mg.endSpawnPhase();
+    }
+  }
+
+  isActive(): boolean {
+    return this.mg.inSpawnPhase();
+  }
+
+  activeDuringSpawnPhase(): boolean {
+    return true;
+  }
+}

src/core/execution/WinCheckExecution.ts

@@ -64,8 +64,7 @@ export class WinCheckExecution implements Execution {
     }
 
     const max = sorted[0];
-    const timeElapsed =
-      (this.mg.ticks() - this.mg.config().numSpawnPhaseTurns()) / 10;
+    const timeElapsed = this.mg.elapsedGameSeconds();
     const numTilesWithoutFallout =
       this.mg.numLandTiles() - this.mg.numTilesWithFallout();
     if (
@@ -100,8 +99,7 @@ export class WinCheckExecution implements Execution {
       return;
     }
     const max = sorted[0];
-    const timeElapsed =
-      (this.mg.ticks() - this.mg.config().numSpawnPhaseTurns()) / 10;
+    const timeElapsed = this.mg.elapsedGameSeconds();
     const numTilesWithoutFallout =
       this.mg.numLandTiles() - this.mg.numTilesWithFallout();
     const percentage = (max[1] / numTilesWithoutFallout) * 100;

src/core/game/Game.ts

@@ -865,10 +865,12 @@ export interface Game extends GameMap {
   // Immunity timer
   isSpawnImmunityActive(): boolean;
   isNationSpawnImmunityActive(): boolean;
+  elapsedGameSeconds(): number;
 
   // Game State
   ticks(): Tick;
   inSpawnPhase(): boolean;
+  endSpawnPhase(): void;
   executeNextTick(): GameUpdates;
   drainPackedTileUpdates(): Uint32Array;
   recordMotionPlan(record: MotionPlanRecord): void;

src/core/game/GameImpl.ts

@@ -18,6 +18,7 @@ import {
   Execution,
   Game,
   GameMode,
+  GameType,
   GameUpdates,
   HumansVsNations,
   MessageType,
@@ -76,6 +77,7 @@ export type CellString = string;
 
 export class GameImpl implements Game {
   private _ticks = 0;
+  private startTick: number | null = null;
 
   private unInitExecs: Execution[] = [];
 
@@ -409,7 +411,15 @@ export class GameImpl implements Game {
   }
 
   inSpawnPhase(): boolean {
-    return this._ticks <= this.config().numSpawnPhaseTurns();
+    return this.startTick === null;
+  }
+
+  endSpawnPhase(): void {
+    this.startTick = this._ticks;
+    this.addUpdate({
+      type: GameUpdateType.SpawnPhaseEnd,
+      startTick: this.startTick,
+    });
   }
 
   ticks(): number {
@@ -458,6 +468,17 @@ export class GameImpl implements Game {
     for (const tile of waterChangedTiles) {
       this.recordTileUpdate(tile);
     }
+
+    if (
+      this.config().gameConfig().gameType !== GameType.Singleplayer &&
+      this._ticks === this.startTick
+    ) {
+      this.addUpdate({
+        type: GameUpdateType.SpawnPhaseEnd,
+        startTick: this.startTick,
+      });
+    }
+
     this._ticks++;
     return this.updates;
   }
@@ -819,20 +840,30 @@ export class GameImpl implements Game {
 
   public isSpawnImmunityActive(): boolean {
     return (
-      this.config().numSpawnPhaseTurns() +
-        this.config().spawnImmunityDuration() >
-      this.ticks()
+      this.inSpawnPhase() ||
+      this.ticksSinceStart() < this.config().spawnImmunityDuration()
     );
   }
 
+  public elapsedGameSeconds(): number {
+    return this.ticksSinceStart() / 10;
+  }
+
   public isNationSpawnImmunityActive(): boolean {
     return (
-      this.config().numSpawnPhaseTurns() +
-        this.config().nationSpawnImmunityDuration() >
-      this.ticks()
+      this.inSpawnPhase() ||
+      this.ticksSinceStart() < this.config().nationSpawnImmunityDuration()
     );
   }
 
+  private ticksSinceStart(): number {
+    if (this.inSpawnPhase()) {
+      return 0;
+    }
+
+    return Math.max(0, this.ticks() - this.startTick!);
+  }
+
   sendEmojiUpdate(msg: EmojiMessage): void {
     this.addUpdate({
       type: GameUpdateType.Emoji,

src/core/game/GameUpdates.ts

@@ -66,6 +66,7 @@ export enum GameUpdateType {
   RailroadSnapEvent,
   ConquestEvent,
   EmbargoEvent,
+  SpawnPhaseEnd,
   GamePaused,
 }
 
@@ -90,6 +91,7 @@ export type GameUpdate =
   | RailroadSnapUpdate
   | ConquestUpdate
   | EmbargoUpdate
+  | SpawnPhaseEndUpdate
   | GamePausedUpdate;
 
 export interface BonusEventUpdate {
@@ -290,6 +292,11 @@ export interface EmbargoUpdate {
   embargoedID: number;
 }
 
+export interface SpawnPhaseEndUpdate {
+  type: GameUpdateType.SpawnPhaseEnd;
+  startTick: Tick;
+}
+
 export interface GamePausedUpdate {
   type: GameUpdateType.GamePaused;
   paused: boolean;

src/core/game/GameView.ts

@@ -37,6 +37,7 @@ import {
   GameUpdateType,
   GameUpdateViewData,
   PlayerUpdate,
+  SpawnPhaseEndUpdate,
   UnitUpdate,
 } from "./GameUpdates";
 import { MotionPlanRecord, unpackMotionPlans } from "./MotionPlans";
@@ -664,6 +665,7 @@ type TrainPlanState = {
 
 export class GameView implements GameMap {
   private lastUpdate: GameUpdateViewData | null;
+  private startTick: Tick | null = null;
   private smallIDToID = new Map<number, PlayerID>();
   private _players = new Map<PlayerID, PlayerView>();
   private _units = new Map<number, UnitView>();
@@ -799,6 +801,14 @@ export class GameView implements GameMap {
     if (gu.updates === null) {
       throw new Error("lastUpdate.updates not initialized");
     }
+
+    const spawnPhaseEndUpdate = gu.updates[GameUpdateType.SpawnPhaseEnd][0] as
+      | SpawnPhaseEndUpdate
+      | undefined;
+    if (spawnPhaseEndUpdate) {
+      this.startTick = spawnPhaseEndUpdate.startTick;
+    }
+
     const myDisplayName = formatPlayerDisplayName(
       this._myUsername,
       this._myClanTag,
@@ -1215,21 +1225,33 @@ export class GameView implements GameMap {
     return this.lastUpdate.tick;
   }
   inSpawnPhase(): boolean {
-    return this.ticks() <= this._config.numSpawnPhaseTurns();
+    return this.startTick === null;
   }
+
   isSpawnImmunityActive(): boolean {
     return (
-      this._config.numSpawnPhaseTurns() + this._config.spawnImmunityDuration() >
-      this.ticks()
+      this.inSpawnPhase() ||
+      this.ticksSinceStart() < this._config.spawnImmunityDuration()
     );
   }
   isNationSpawnImmunityActive(): boolean {
     return (
-      this._config.numSpawnPhaseTurns() +
-        this._config.nationSpawnImmunityDuration() >
-      this.ticks()
+      this.inSpawnPhase() ||
+      this.ticksSinceStart() < this._config.nationSpawnImmunityDuration()
     );
   }
+
+  elapsedGameSeconds(): number {
+    return this.ticksSinceStart() / 10;
+  }
+
+  ticksSinceStart(): Tick {
+    if (this.inSpawnPhase()) {
+      return 0;
+    }
+
+    return Math.max(0, this.ticks() - this.startTick!);
+  }
   config(): Config {
     return this._config;
   }