Add pause button when replaying (#726)

## Description:

This PR does two things:

1. Allow pausing on replay
2. As part of the refactoring, in singleplayer games, LocalServer now
waits for the last turn to complete execution before sending the next
turn. Previously, low end devices would sometimes fall behind getting
the "playing the past" bug where commands were delayed. Now when a
devices cannot keep up, the entire game slows down.

## Please complete the following:

- [ ] I have added screenshots for all UI updates
- [ ] I confirm I have thoroughly tested these changes and take full
responsibility for any bugs introduced
- [ ] I understand that submitting code with bugs that could have been
caught through manual testing blocks releases and new features for all
contributors

## Please put your Discord username so you can be contacted if a bug or
regression is found:

<DISCORD USERNAME>

Co-authored-by: evan <openfrontio@gmail.com>

src/client/LocalServer.ts

@@ -16,42 +16,58 @@ import { LobbyConfig } from "./ClientGameRunner";
 import { getPersistentIDFromCookie } from "./Main";
 
 export class LocalServer {
+  // All turns from the game record on replay.
+  private replayTurns: Turn[] = [];
+
   private turns: Turn[] = [];
+
   private intents: Intent[] = [];
   private startedAt: number;
 
-  private endTurnIntervalID;
-
   private paused = false;
 
   private winner: ClientSendWinnerMessage = null;
   private allPlayersStats: AllPlayersStats = {};
 
+  private turnsExecuted = 0;
+  private lastTurnCompletedTime = 0;
+
+  private turnCheckInterval: NodeJS.Timeout;
+
   constructor(
     private lobbyConfig: LobbyConfig,
     private clientConnect: () => void,
     private clientMessage: (message: ServerMessage) => void,
+    private isReplay: boolean,
   ) {}
 
   start() {
+    this.turnCheckInterval = setInterval(() => {
+      if (this.turnsExecuted == this.turns.length) {
+        if (
+          this.isReplay ||
+          Date.now() >
+            this.lastTurnCompletedTime +
+              this.lobbyConfig.serverConfig.turnIntervalMs()
+        ) {
+          this.endTurn();
+        }
+      }
+    }, 5);
+
     this.startedAt = Date.now();
-    if (!this.lobbyConfig.gameRecord) {
-      this.endTurnIntervalID = setInterval(
-        () => this.endTurn(),
-        this.lobbyConfig.serverConfig.turnIntervalMs(),
-      );
-    }
     this.clientConnect();
     if (this.lobbyConfig.gameRecord) {
-      this.turns = decompressGameRecord(this.lobbyConfig.gameRecord).turns;
-      console.log(`loaded turns: ${JSON.stringify(this.turns)}`);
+      this.replayTurns = decompressGameRecord(
+        this.lobbyConfig.gameRecord,
+      ).turns;
     }
     this.clientMessage(
       ServerStartGameMessageSchema.parse({
         type: "start",
         gameID: this.lobbyConfig.gameStartInfo.gameID,
         gameStartInfo: this.lobbyConfig.gameStartInfo,
-        turns: this.turns,
+        turns: [],
       }),
     );
   }
@@ -90,7 +106,7 @@ export class LocalServer {
         return;
       }
       // If we are replaying a game then verify hash.
-      const archivedHash = this.turns[clientMsg.turnNumber].hash;
+      const archivedHash = this.replayTurns[clientMsg.turnNumber].hash;
       if (!archivedHash) {
         console.warn(
           `no archived hash found for turn ${clientMsg.turnNumber}, client hash: ${clientMsg.hash}`,
@@ -121,10 +137,18 @@ export class LocalServer {
     }
   }
 
+  public turnComplete() {
+    this.turnsExecuted++;
+    this.lastTurnCompletedTime = Date.now();
+  }
+
   private endTurn() {
     if (this.paused) {
       return;
     }
+    if (this.replayTurns.length > 0) {
+      this.intents = this.replayTurns[this.turns.length].intents;
+    }
     const pastTurn: Turn = {
       turnNumber: this.turns.length,
       intents: this.intents,
@@ -139,7 +163,7 @@ export class LocalServer {
 
   public endGame(saveFullGame: boolean = false) {
     consolex.log("local server ending game");
-    clearInterval(this.endTurnIntervalID);
+    clearInterval(this.turnCheckInterval);
     const players: PlayerRecord[] = [
       {
         ip: null,