From f7836a331775bff8a8da2868ea1c28d5de5fc104 Mon Sep 17 00:00:00 2001
From: ymmot239 <pacman239sa@gmail.com>
Date: Tue, 9 Sep 2025 10:42:38 -0500
Subject: [PATCH 01/11] Added pause dialogs

added pause dialogs and messages to handle the client-side pause notification
---
 src/client/game/admin-dialogs.tsx | 31 +++++++++++++++++++++++++++++++
 src/client/game/game.tsx          | 28 ++++++++++++++++++++++++----
 src/common/game-end-reasons.ts    |  2 ++
 3 files changed, 57 insertions(+), 4 deletions(-)
 create mode 100644 src/client/game/admin-dialogs.tsx

diff --git a/src/client/game/admin-dialogs.tsx b/src/client/game/admin-dialogs.tsx
new file mode 100644
index 00000000..d969431a
--- /dev/null
+++ b/src/client/game/admin-dialogs.tsx
@@ -0,0 +1,31 @@
+import { Dialog, DialogBody, NonIdealState } from "@blueprintjs/core";
+import { useState } from "react";
+import { bgColor, textColor } from "../check-dark-mode";
+
+interface DrawDialogProps {
+    dialogText: string;
+}
+
+/**
+ * Shows a paused dialog that cannot be closed
+ * @param props - dialog text
+ * @returns - draw dialog
+ */
+export function PauseDialog(props: DrawDialogProps) {
+    const [isOpen, setIsOpen] = useState(true);
+    return (
+        <Dialog
+            className={bgColor()}
+            isOpen={isOpen}
+            onClose={() => setIsOpen(false)}
+            canOutsideClickClose={false}
+            canEscapeKeyClose={false}
+        >
+            <DialogBody>
+                <NonIdealState>
+                    <h4 className={textColor()}>{props.dialogText || "Game Paused"}</h4>
+                </NonIdealState>
+            </DialogBody>
+        </Dialog>
+    );
+}
\ No newline at end of file
diff --git a/src/client/game/game.tsx b/src/client/game/game.tsx
index 74c0dcb0..57a4f66b 100644
--- a/src/client/game/game.tsx
+++ b/src/client/game/game.tsx
@@ -27,6 +27,7 @@ import { NonIdealState, Spinner } from "@blueprintjs/core";
 import { AcceptDrawDialog, OfferDrawDialog } from "./draw-dialog";
 import { bgColor } from "../check-dark-mode";
 import "../colors.css";
+import { PauseDialog } from "./admin-dialogs";
 
 /**
  * Creates a MessageHandler function to handle move messages and game interruptions.
@@ -40,6 +41,7 @@ function getMessageHandler(
     setGameInterruptedReason: Dispatch<GameInterruptedReason>,
     setGameEndedReason: Dispatch<GameEndReason>,
     setGameHoldReason: Dispatch<GameHoldReason>,
+    setPaused : Dispatch<boolean>,
 ): MessageHandler {
     return (message) => {
         if (message instanceof MoveMessage) {
@@ -62,6 +64,11 @@ function getMessageHandler(
             setGameEndedReason(message.reason);
         } else if (message instanceof GameHoldMessage) {
             setGameHoldReason(message.reason);
+            if(message.reason === GameHoldReason.GAME_PAUSED){
+                setPaused(true);
+            } else if(message.reason === GameHoldReason.GAME_UNPAUSED){
+                setPaused(false);
+            }
         }
     };
 }
@@ -77,6 +84,7 @@ export function Game(): JSX.Element {
     const [gameEndedReason, setGameEndedReason] = useState<GameEndReason>();
     const [gameHoldReason, setGameHoldReason] = useState<GameHoldReason>();
     const [rotation, setRotation] = useState<number>(0);
+    const [paused, setPause] = useState<boolean>(false);
 
     /** send any messages using our defined message handler inside a message socket for handling */
     const sendMessage = useSocket(
@@ -86,6 +94,7 @@ export function Game(): JSX.Element {
             setGameInterruptedReason,
             setGameEndedReason,
             setGameHoldReason,
+            setPause,
         ),
     );
 
@@ -136,6 +145,7 @@ export function Game(): JSX.Element {
         gameEndReason !== undefined ?
             <GameEndDialog reason={gameEndReason} side={side} />
         :   null;
+
     const gameOfferDialog =
         gameHoldReason !== undefined ?
             gameHoldReason === GameHoldReason.DRAW_CONFIRMATION ?
@@ -150,11 +160,20 @@ export function Game(): JSX.Element {
             :   null
         :   null;
 
+    const gamePauseDialog = 
+        gameHoldReason !== undefined ?
+            gameHoldReason === GameHoldReason.GAME_PAUSED ?
+                <PauseDialog dialogText={""}/>
+            : null
+        : null;
+
     /** make moves by making a copy of the chessboard and sending the move message */
-    const handleMove = (move: Move): void => {
-        setChess(chess.copy(move));
-        sendMessage(new MoveMessage(move));
-    };
+    const handleMove = paused? 
+            (move: Move): void => {
+                setChess(chess.copy(move));
+                sendMessage(new MoveMessage(move));
+            }
+        : (move:Move):void => {move;}; //send a do-nothing function if game is paused
 
     // return the chessboard wrapper, navbar, and potential end dialog
     return (
@@ -176,6 +195,7 @@ export function Game(): JSX.Element {
                 {gameEndDialog}
                 {gameOfferDialog}
                 {gameAcceptDialog}
+                {gamePauseDialog}
                 <Outlet />
             </div>
         </>
diff --git a/src/common/game-end-reasons.ts b/src/common/game-end-reasons.ts
index 8a20a22a..7b6c67cc 100644
--- a/src/common/game-end-reasons.ts
+++ b/src/common/game-end-reasons.ts
@@ -40,4 +40,6 @@ export enum GameHoldReason {
     DRAW_OFFERED = "draw-offered",
     DRAW_CONFIRMATION = "draw-confirmation",
     DRAW_DENIED = "draw-denied",
+    GAME_PAUSED = "game-paused",
+    GAME_UNPAUSED = "game-unpaused",
 }

From cafcf45e66a71f6bbd1a6f8e5c81830da2e095fb Mon Sep 17 00:00:00 2001
From: ymmot239 <pacman239sa@gmail.com>
Date: Tue, 9 Sep 2025 10:53:33 -0500
Subject: [PATCH 02/11] Notification dialog

Added a notification dialog to give the user information
eg. game has been unpaused, puzzle info, line changes, etc.
---
 src/client/game/admin-dialogs.tsx | 63 ++++++++++++++++++++++++++++---
 src/client/game/game.tsx          | 12 +++++-
 2 files changed, 67 insertions(+), 8 deletions(-)

diff --git a/src/client/game/admin-dialogs.tsx b/src/client/game/admin-dialogs.tsx
index d969431a..b5e6346f 100644
--- a/src/client/game/admin-dialogs.tsx
+++ b/src/client/game/admin-dialogs.tsx
@@ -1,15 +1,21 @@
-import { Dialog, DialogBody, NonIdealState } from "@blueprintjs/core";
+import {
+    Button,
+    Dialog,
+    DialogBody,
+    DialogFooter,
+    NonIdealState,
+} from "@blueprintjs/core";
 import { useState } from "react";
-import { bgColor, textColor } from "../check-dark-mode";
+import { bgColor, buttonColor, textColor } from "../check-dark-mode";
 
 interface DrawDialogProps {
-    dialogText: string;
+    dialogText?: string;
 }
 
 /**
  * Shows a paused dialog that cannot be closed
  * @param props - dialog text
- * @returns - draw dialog
+ * @returns - pause dialog
  */
 export function PauseDialog(props: DrawDialogProps) {
     const [isOpen, setIsOpen] = useState(true);
@@ -23,9 +29,54 @@ export function PauseDialog(props: DrawDialogProps) {
         >
             <DialogBody>
                 <NonIdealState>
-                    <h4 className={textColor()}>{props.dialogText || "Game Paused"}</h4>
+                    <h4 className={textColor()}>
+                        {props.dialogText || "Game Paused"}
+                    </h4>
+                </NonIdealState>
+            </DialogBody>
+        </Dialog>
+    );
+}
+
+interface NotificationDialogProps {
+    dialogText: string;
+}
+
+/**
+ * SHows a closable notification dialog
+ * @param props - dialog text
+ * @returns - notification dialog
+ */
+export function NotificationDialog(props: NotificationDialogProps) {
+    const [isOpen, setIsOpen] = useState(true);
+
+    /** okay button */
+    const actions = (
+        <Button
+            text="Continue"
+            rightIcon="arrow-right"
+            className={buttonColor()}
+            intent="primary"
+            onClick={() => {
+                close();
+            }}
+        />
+    );
+
+    return (
+        <Dialog
+            className={bgColor()}
+            isOpen={isOpen}
+            onClose={() => setIsOpen(false)}
+            canOutsideClickClose={true}
+            canEscapeKeyClose={true}
+        >
+            <DialogBody>
+                <NonIdealState>
+                    <h4 className={textColor()}>{props.dialogText}</h4>
                 </NonIdealState>
             </DialogBody>
+            <DialogFooter minimal actions={actions} />
         </Dialog>
     );
-}
\ No newline at end of file
+}
diff --git a/src/client/game/game.tsx b/src/client/game/game.tsx
index 57a4f66b..aa19a575 100644
--- a/src/client/game/game.tsx
+++ b/src/client/game/game.tsx
@@ -27,7 +27,7 @@ import { NonIdealState, Spinner } from "@blueprintjs/core";
 import { AcceptDrawDialog, OfferDrawDialog } from "./draw-dialog";
 import { bgColor } from "../check-dark-mode";
 import "../colors.css";
-import { PauseDialog } from "./admin-dialogs";
+import { NotificationDialog, PauseDialog } from "./admin-dialogs";
 
 /**
  * Creates a MessageHandler function to handle move messages and game interruptions.
@@ -163,7 +163,14 @@ export function Game(): JSX.Element {
     const gamePauseDialog = 
         gameHoldReason !== undefined ?
             gameHoldReason === GameHoldReason.GAME_PAUSED ?
-                <PauseDialog dialogText={""}/>
+                <PauseDialog />
+            : null
+        : null;
+
+    const gameUnpauseDialog = 
+        gameHoldReason !== undefined ?
+            gameHoldReason === GameHoldReason.GAME_UNPAUSED ?
+                <NotificationDialog dialogText="Game Unpaused"/>
             : null
         : null;
 
@@ -196,6 +203,7 @@ export function Game(): JSX.Element {
                 {gameOfferDialog}
                 {gameAcceptDialog}
                 {gamePauseDialog}
+                {gameUnpauseDialog}
                 <Outlet />
             </div>
         </>

From e384175a01a159c2803af676d7187648e9fd5a9a Mon Sep 17 00:00:00 2001
From: ymmot239 <pacman239sa@gmail.com>
Date: Tue, 9 Sep 2025 15:12:35 -0500
Subject: [PATCH 03/11] Server pause structure

added various gates to robot movement based on if the game is paused.
Allowed pausing/unpausing through an api call
---
 src/server/api/api.ts          | 24 ++++++++++++++++++
 src/server/api/game-manager.ts | 12 +++++----
 src/server/api/managers.ts     |  1 +
 src/server/command/executor.ts | 46 +++++++++++++++++++++++++++++-----
 4 files changed, 72 insertions(+), 11 deletions(-)

diff --git a/src/server/api/api.ts b/src/server/api/api.ts
index fff8970a..aab79d31 100644
--- a/src/server/api/api.ts
+++ b/src/server/api/api.ts
@@ -20,6 +20,7 @@ import { RegisterWebsocketMessage } from "../../common/message/message";
 import {
     clientManager,
     gameManager,
+    gamePaused,
     setGameManager,
     socketManager,
 } from "./managers";
@@ -46,6 +47,7 @@ import {
 import { robotManager } from "../robot/robot-manager";
 import { tcpServer } from "./tcp-interface";
 import { executor } from "../command/executor";
+import { GameHoldReason } from "../../common/game-end-reasons";
 
 /**
  * Helper function to move all robots from their home positions to their default positions
@@ -345,6 +347,28 @@ apiRouter.get("/get-puzzles", (_, res) => {
     return res.send(out);
 });
 
+/**
+ * Pause the game
+ * Todo: add authentication instead of an exposed pause call
+ */
+apiRouter.get("/pause-game", (_, res) => {
+    gamePaused.flag = true;
+    socketManager.sendToAll(new GameHoldMessage(GameHoldReason.GAME_PAUSED));
+    return res.send({ message: "success" });
+});
+
+/**
+ * Unpause the game
+ * Resumes any leftover commands queued in the command executor
+ * Todo: add authentication instead of an exposed unpause call
+ */
+apiRouter.get("/unpause-game", async (_, res) => {
+    gamePaused.flag = false;
+    await executor.finishExecution();
+    socketManager.sendToAll(new GameHoldMessage(GameHoldReason.GAME_UNPAUSED));
+    return res.send({ message: "success" });
+});
+
 /**
  * sends a drive message through the tcp connection
  *
diff --git a/src/server/api/game-manager.ts b/src/server/api/game-manager.ts
index 5a459ade..2d49471a 100644
--- a/src/server/api/game-manager.ts
+++ b/src/server/api/game-manager.ts
@@ -26,6 +26,7 @@ import { SaveManager } from "./save-manager";
 import { materializePath } from "../robot/path-materializer";
 import { DO_SAVES } from "../utils/env";
 import { executor } from "../command/executor";
+import { gamePaused } from "./managers";
 
 type GameState = {
     side: Side;
@@ -139,8 +140,8 @@ export class HumanGameManager extends GameManager {
         );
         const ids = this.clientManager.getIds();
         const currentSave = SaveManager.loadGame(id);
-        // update the internal chess object if it is a move massage
-        if (message instanceof MoveMessage) {
+        // update the internal chess object if it is a move massage and game not paused
+        if (message instanceof MoveMessage && !gamePaused.flag) {
             // Call path materializer and send to bots
             const command = materializePath(message.move);
 
@@ -210,7 +211,7 @@ export class HumanGameManager extends GameManager {
                     SaveManager.endGame(ids[0], ids[1]);
                 else SaveManager.endGame(ids[1], ids[0]);
             }
-        }
+        } 
     }
 }
 
@@ -245,7 +246,7 @@ export class ComputerGameManager extends GameManager {
      * @returns when the game ends
      */
     public async handleMessage(message: Message, id: string): Promise<void> {
-        if (message instanceof MoveMessage) {
+        if (message instanceof MoveMessage && !gamePaused.flag) {
             this.socketManager.sendToAll(new MoveMessage(message.move));
             this.chess.makeMove(message.move);
             if (DO_SAVES) {
@@ -321,7 +322,8 @@ export class PuzzleGameManager extends GameManager {
             //if the move is correct
             if (
                 this.moves[this.moveNumber].from === message.move.from &&
-                this.moves[this.moveNumber].to === message.move.to
+                this.moves[this.moveNumber].to === message.move.to &&
+                !gamePaused.flag
             ) {
                 const command = materializePath(message.move);
 
diff --git a/src/server/api/managers.ts b/src/server/api/managers.ts
index 37804692..c0b7f994 100644
--- a/src/server/api/managers.ts
+++ b/src/server/api/managers.ts
@@ -9,6 +9,7 @@ import { SocketManager } from "./socket-manager";
 export const socketManager = new SocketManager({});
 export const clientManager = new ClientManager(socketManager);
 export let gameManager: GameManager | null = null;
+export const gamePaused = {flag:false};
 
 export function setGameManager(manager: GameManager) {
     gameManager = manager;
diff --git a/src/server/command/executor.ts b/src/server/command/executor.ts
index bbde2d69..c2e8d35e 100644
--- a/src/server/command/executor.ts
+++ b/src/server/command/executor.ts
@@ -1,3 +1,4 @@
+import { gamePaused } from "../api/managers";
 import type { Command } from "./command";
 
 /**
@@ -18,6 +19,7 @@ export class CommandExecutor {
     constructor() {}
 
     private runningCommands: Command[] = [];
+    private oldCommands: Command[] = [];
 
     private checkRequirements(command: Command) {
         for (const req of command.requirements) {
@@ -41,17 +43,49 @@ export class CommandExecutor {
     public async execute(command: Command): Promise<void> {
         this.checkRequirements(command);
         this.runningCommands.push(command);
-        return command.execute().finally(() => {
-            const index = this.runningCommands.indexOf(command);
-            if (index >= 0) {
-                this.runningCommands.splice(index, 1);
-            }
-        });
+        if(!gamePaused.flag){ 
+            return command.execute().finally(() => {
+                this.oldCommands.unshift(command);
+                const index = this.runningCommands.indexOf(command);
+                if (index >= 0) {
+                    this.runningCommands.splice(index, 1);
+                }
+            })
+        }
+    }
+
+    /**
+     * run through the running command list
+     * mainly used to finish the backlog from a paused game
+     * @returns - The command to execute.
+     */
+    public async finishExecution() : Promise<void> {
+        return this.runningCommands.forEach((command) =>{
+            command.execute().finally(()=>{
+                this.oldCommands.unshift(command);
+                const index = this.runningCommands.indexOf(command);
+                if (index >= 0) {
+                    this.runningCommands.splice(index, 1);
+                }
+            })
+        })
+    }
+
+    public clearExecution(){
+        this.runningCommands = [];
     }
 
     public getRunningCommands(): ReadonlyArray<Command> {
         return this.runningCommands;
     }
+
+    public getOldCommands(): ReadonlyArray<Command> {
+        return this.oldCommands;
+    }
+
+    public clearOldCommands(){
+        this.oldCommands = [];
+    }
 }
 
 export const executor = new CommandExecutor();

From a872c3f3f8ca231c6dbcf993bd2f0ce2c6c5bf03 Mon Sep 17 00:00:00 2001
From: ymmot239 <pacman239sa@gmail.com>
Date: Mon, 22 Sep 2025 10:21:25 -0500
Subject: [PATCH 04/11] advanced stop procedure

added a stop for promises in progress
also added some hotfixes for pause
---
 src/client/game/admin-dialogs.tsx | 2 +-
 src/client/game/game.tsx          | 2 +-
 src/server/api/api.ts             | 3 +--
 src/server/command/command.ts     | 5 +++--
 src/server/robot/robot-manager.ts | 4 ++++
 src/server/robot/robot.ts         | 6 ++++++
 6 files changed, 16 insertions(+), 6 deletions(-)

diff --git a/src/client/game/admin-dialogs.tsx b/src/client/game/admin-dialogs.tsx
index b5e6346f..bc050016 100644
--- a/src/client/game/admin-dialogs.tsx
+++ b/src/client/game/admin-dialogs.tsx
@@ -58,7 +58,7 @@ export function NotificationDialog(props: NotificationDialogProps) {
             className={buttonColor()}
             intent="primary"
             onClick={() => {
-                close();
+                setIsOpen(false);
             }}
         />
     );
diff --git a/src/client/game/game.tsx b/src/client/game/game.tsx
index aa19a575..8e4ab1ee 100644
--- a/src/client/game/game.tsx
+++ b/src/client/game/game.tsx
@@ -175,7 +175,7 @@ export function Game(): JSX.Element {
         : null;
 
     /** make moves by making a copy of the chessboard and sending the move message */
-    const handleMove = paused? 
+    const handleMove = !paused? 
             (move: Move): void => {
                 setChess(chess.copy(move));
                 sendMessage(new MoveMessage(move));
diff --git a/src/server/api/api.ts b/src/server/api/api.ts
index 65f90f8e..c9853b8f 100644
--- a/src/server/api/api.ts
+++ b/src/server/api/api.ts
@@ -553,18 +553,17 @@ apiRouter.get("/get-puzzles", (_, res) => {
  */
 apiRouter.get("/pause-game", (_, res) => {
     gamePaused.flag = true;
+    robotManager.stopAllRobots();
     socketManager.sendToAll(new GameHoldMessage(GameHoldReason.GAME_PAUSED));
     return res.send({ message: "success" });
 });
 
 /**
  * Unpause the game
- * Resumes any leftover commands queued in the command executor
  * Todo: add authentication instead of an exposed unpause call
  */
 apiRouter.get("/unpause-game", async (_, res) => {
     gamePaused.flag = false;
-    await executor.finishExecution();
     socketManager.sendToAll(new GameHoldMessage(GameHoldReason.GAME_UNPAUSED));
     return res.send({ message: "success" });
 });
diff --git a/src/server/command/command.ts b/src/server/command/command.ts
index e955bada..75ce3949 100644
--- a/src/server/command/command.ts
+++ b/src/server/command/command.ts
@@ -1,3 +1,4 @@
+import { gamePaused } from "../api/managers";
 import { robotManager } from "../robot/robot-manager";
 
 /**
@@ -112,7 +113,7 @@ function isReversable(obj): obj is Reversible<typeof obj> {
  */
 export class ParallelCommandGroup extends CommandGroup {
     public async execute(): Promise<void> {
-        const promises = this.commands.map((move) => move.execute());
+        const promises = this.commands.map((move) => {gamePaused.flag?null:move.execute()});
         return Promise.all(promises).then(null);
     }
     public async reverse(): Promise<void> {
@@ -132,7 +133,7 @@ export class SequentialCommandGroup extends CommandGroup {
     public async execute(): Promise<void> {
         let promise = Promise.resolve();
         for (const command of this.commands) {
-            promise = promise.then(() => command.execute());
+            promise = promise.then(() => {gamePaused?null:command.execute()});
         }
         return promise;
     }
diff --git a/src/server/robot/robot-manager.ts b/src/server/robot/robot-manager.ts
index fd72e426..5945bf23 100644
--- a/src/server/robot/robot-manager.ts
+++ b/src/server/robot/robot-manager.ts
@@ -99,6 +99,10 @@ export class RobotManager {
         }
         indicesToIds.set(indices.toString(), robotId);
     }
+
+    stopAllRobots(){
+        Array.from(this.idsToRobots.values()).forEach((robot)=>{robot.sendStopPacket()})
+    }
 }
 
 export const robotManager = new RobotManager(
diff --git a/src/server/robot/robot.ts b/src/server/robot/robot.ts
index 7540ec82..2571a158 100644
--- a/src/server/robot/robot.ts
+++ b/src/server/robot/robot.ts
@@ -186,4 +186,10 @@ export class Robot {
             timeDeltaMs: timeDeltaMs,
         });
     }
+
+    public async sendStopPacket():Promise<void>{
+        await this.tunnel!.send({
+            type: PacketType.ESTOP,
+        });
+    }
 }

From 9fccb54b898647863717224480162e321317ff98 Mon Sep 17 00:00:00 2001
From: ymmot239 <pacman239sa@gmail.com>
Date: Mon, 22 Sep 2025 18:12:31 -0500
Subject: [PATCH 05/11] added robot saves

saved game state as well as robot positions in save files
---
 src/server/api/game-manager.ts |  7 +++++++
 src/server/api/save-manager.ts | 24 ++++++++++++++++++++----
 2 files changed, 27 insertions(+), 4 deletions(-)

diff --git a/src/server/api/game-manager.ts b/src/server/api/game-manager.ts
index 870ee267..a9b58791 100644
--- a/src/server/api/game-manager.ts
+++ b/src/server/api/game-manager.ts
@@ -26,6 +26,7 @@ import { SaveManager } from "./save-manager";
 import { materializePath } from "../robot/path-materializer";
 import { DO_SAVES } from "../utils/env";
 import { executor } from "../command/executor";
+import { robotManager } from "../robot/robot-manager";
 import { gamePaused } from "./managers";
 
 type GameState = {
@@ -160,6 +161,8 @@ export class HumanGameManager extends GameManager {
                         this.hostSide,
                         -1,
                         this.chess.pgn,
+                        this.chess.fen,
+                        robotManager.getIndicesToIds(),
                     );
                 } else {
                     SaveManager.saveGame(
@@ -168,6 +171,8 @@ export class HumanGameManager extends GameManager {
                         oppositeSide(this.hostSide),
                         -1,
                         this.chess.pgn,
+                        this.chess.fen,
+                        robotManager.getIndicesToIds(),
                     );
                 }
             }
@@ -278,6 +283,8 @@ export class ComputerGameManager extends GameManager {
                     this.hostSide,
                     this.difficulty,
                     this.chess.pgn,
+                    this.chess.fen,
+                    robotManager.getIndicesToIds(),
                 );
             }
 
diff --git a/src/server/api/save-manager.ts b/src/server/api/save-manager.ts
index 02f8ec59..b54b91fd 100644
--- a/src/server/api/save-manager.ts
+++ b/src/server/api/save-manager.ts
@@ -10,7 +10,7 @@
  * Modified: 9/20/24
  */
 
-import { Side } from "../../common/game-types";
+import { Side } from "../../common/game-types";2
 
 // Save files contain a date in ms and pgn string
 export interface iSave {
@@ -19,6 +19,10 @@ export interface iSave {
     hostWhite: boolean;
     aiDifficulty: number;
     game: string;
+    pos:string;
+    robotPos: Array<[string,string]>;
+    oldPos: string;
+    oldRobotPos: Array<[string,string]>;
 }
 
 export class SaveManager {
@@ -27,9 +31,9 @@ export class SaveManager {
      *
      * Finds or creates a save file
      * Save name is host id + client id
-     * Saves include the game start time and save pgn as json
-     *
-     * Input: host id, client id, game pgn
+     * Saves include the game start time and save fen as json
+     * Robots are saved as a map of indices to robots
+     * Input: host id, client id, game fen, robots
      * Output: boolean competed
      */
     public static saveGame(
@@ -38,16 +42,28 @@ export class SaveManager {
         hostSide: Side,
         aiDiff: number,
         pgn: string,
+        fen: string,
+        robots: Map<string, string>,
     ) {
         const day = new Date().getTime();
         const side = hostSide === Side.WHITE;
+        console.log(JSON.stringify(robots));
         const saveContents = {
             host: hostId,
             date: day,
             hostWhite: side,
             aiDifficulty: aiDiff,
             game: pgn,
+            pos: fen,
+            robotPos: Array.from(robots),
+            oldPos: "",
+            oldRobotPos: Array<[string,string]>(),
         };
+        const oldGame = SaveManager.loadGame(hostId + "+" + clientID);
+        if (oldGame && oldGame.pos !== null) {
+            saveContents.oldPos = oldGame.game;
+            saveContents.oldRobotPos = oldGame.robotPos;
+        }
         return FileManager.writeFile(hostId + "+" + clientID, saveContents);
     }
 

From c2d7b5ee29831bcf95f296e75ad8b22da1b9e80c Mon Sep 17 00:00:00 2001
From: ymmot239 <pacman239sa@gmail.com>
Date: Mon, 22 Sep 2025 20:04:15 -0500
Subject: [PATCH 06/11] Added pause rollback

allowed pause to rollback the robot positions.
Also allowed saveGame to load from a saved positions, so hopefully less errors
---
 src/client/game/game.tsx          | 27 ++++++++++--------
 src/server/api/api.ts             | 46 +++++++++++++++++++++----------
 src/server/api/game-manager.ts    |  2 +-
 src/server/api/managers.ts        |  2 +-
 src/server/api/save-manager.ts    | 11 ++++----
 src/server/command/command.ts     |  8 ++++--
 src/server/command/executor.ts    | 18 ++++++------
 src/server/robot/robot-manager.ts |  6 ++--
 src/server/robot/robot.ts         |  2 +-
 9 files changed, 75 insertions(+), 47 deletions(-)

diff --git a/src/client/game/game.tsx b/src/client/game/game.tsx
index 420e5e2a..5adac3a5 100644
--- a/src/client/game/game.tsx
+++ b/src/client/game/game.tsx
@@ -42,7 +42,7 @@ function getMessageHandler(
     setGameInterruptedReason: Dispatch<GameInterruptedReason>,
     setGameEndedReason: Dispatch<GameEndReason>,
     setGameHoldReason: Dispatch<GameHoldReason>,
-    setPaused : Dispatch<boolean>,
+    setPaused: Dispatch<boolean>,
 ): MessageHandler {
     return (message) => {
         if (message instanceof MoveMessage) {
@@ -65,9 +65,9 @@ function getMessageHandler(
             setGameEndedReason(message.reason);
         } else if (message instanceof GameHoldMessage) {
             setGameHoldReason(message.reason);
-            if(message.reason === GameHoldReason.GAME_PAUSED){
+            if (message.reason === GameHoldReason.GAME_PAUSED) {
                 setPaused(true);
-            } else if(message.reason === GameHoldReason.GAME_UNPAUSED){
+            } else if (message.reason === GameHoldReason.GAME_UNPAUSED) {
                 setPaused(false);
             }
         }
@@ -161,27 +161,30 @@ export function Game(): JSX.Element {
             :   null
         :   null;
 
-    const gamePauseDialog = 
+    const gamePauseDialog =
         gameHoldReason !== undefined ?
             gameHoldReason === GameHoldReason.GAME_PAUSED ?
                 <PauseDialog />
-            : null
-        : null;
+            :   null
+        :   null;
 
-    const gameUnpauseDialog = 
+    const gameUnpauseDialog =
         gameHoldReason !== undefined ?
             gameHoldReason === GameHoldReason.GAME_UNPAUSED ?
-                <NotificationDialog dialogText="Game Unpaused"/>
-            : null
-        : null;
+                <NotificationDialog dialogText="Game Unpaused" />
+            :   null
+        :   null;
 
     /** make moves by making a copy of the chessboard and sending the move message */
-    const handleMove = !paused? 
+    const handleMove =
+        !paused ?
             (move: Move): void => {
                 setChess(chess.copy(move));
                 sendMessage(new MoveMessage(move));
             }
-        : (move:Move):void => {move;}; //send a do-nothing function if game is paused
+        :   (move: Move): void => {
+                move;
+            }; //send a do-nothing function if game is paused
 
     // return the chessboard wrapper, navbar, and potential end dialog
     return (
diff --git a/src/server/api/api.ts b/src/server/api/api.ts
index da3017ea..a1490fe9 100644
--- a/src/server/api/api.ts
+++ b/src/server/api/api.ts
@@ -51,12 +51,12 @@ import {
     SpinRadiansCommand,
 } from "../command/move-command";
 import { GridIndices } from "../robot/grid-indices";
-import { puzzles, type PuzzleComponents } from "./puzzles";
 import {
     moveAllRobotsHomeToDefaultOptimized,
     moveAllRobotsToDefaultPositions,
-    moveAllRobotsFromBoardToHome,
 } from "../robot/path-materializer";
+import type { PuzzleComponents } from "./puzzles";
+import { puzzles } from "./puzzles";
 import { tcpServer } from "./tcp-interface";
 import { robotManager } from "../robot/robot-manager";
 import { executor } from "../command/executor";
@@ -76,7 +76,7 @@ async function setupDefaultRobotPositions(
                 moveAllRobotsToDefaultPositions(defaultPositionsMap);
             await executor.execute(command);
         } else {
-            setAllRobotsToDefaultPositions(defaultPositionsMap);
+            moveAllRobotsToDefaultPositions(defaultPositionsMap);
         }
     } else {
         if (isMoving) {
@@ -186,6 +186,17 @@ apiRouter.get("/client-information", async (req, res) => {
                 ),
             );
         }
+        const robotPos = new Map(
+            oldSave!.robotPos?.map<[string, GridIndices]>((obj) => [
+                obj[1],
+                new GridIndices(
+                    parseInt(obj[0].split(", ")[0]),
+                    parseInt(obj[0].split(", ")[1]),
+                ),
+            ]),
+        );
+        console.log(robotPos);
+        setAllRobotsToDefaultPositions(robotPos);
     }
     /**
      * Note the client currently redirects to home from the game over screen
@@ -285,7 +296,6 @@ apiRouter.post("/start-puzzle-game", async (req, res) => {
     const fen = puzzle.fen;
     const moves = puzzle.moves;
     const difficulty = puzzle.rating;
-    const tooltip = puzzle.tooltip;
 
     if (puzzle.robotDefaultPositions) {
         // Convert puzzle.robotDefaultPositions from Record<string, string> to Map<string, GridIndices>
@@ -322,7 +332,7 @@ apiRouter.post("/start-puzzle-game", async (req, res) => {
             new ChessEngine(),
             socketManager,
             fen,
-            tooltip,
+            "",
             moves,
             difficulty,
         ),
@@ -331,15 +341,6 @@ apiRouter.post("/start-puzzle-game", async (req, res) => {
     return res.send({ message: "success" });
 });
 
-/**
- * Returns robots to home after a game ends.
- */
-apiRouter.post("/return-home", async (_req, res) => {
-    const command = moveAllRobotsFromBoardToHome();
-    await executor.execute(command);
-    return res.send({ message: "success" });
-});
-
 /**
  * Returns all registered robot ids
  */
@@ -575,6 +576,23 @@ apiRouter.get("/pause-game", (_, res) => {
  */
 apiRouter.get("/unpause-game", async (_, res) => {
     gamePaused.flag = false;
+    const ids = clientManager.getIds();
+    if (ids) {
+        const oldSave = SaveManager.loadGame(ids[0]);
+        gameManager?.chess.loadFen(oldSave!.oldPos);
+        setAllRobotsToDefaultPositions(
+            new Map(
+                oldSave!.oldRobotPos?.map<[string, GridIndices]>((obj) => [
+                    obj[1],
+                    new GridIndices(
+                        parseInt(obj[0].split(", ")[0]),
+                        parseInt(obj[0].split(", ")[1]),
+                    ),
+                ]),
+            ),
+        );
+        socketManager.sendToAll(new SetChessMessage(oldSave!.oldPos));
+    }
     socketManager.sendToAll(new GameHoldMessage(GameHoldReason.GAME_UNPAUSED));
     return res.send({ message: "success" });
 });
diff --git a/src/server/api/game-manager.ts b/src/server/api/game-manager.ts
index 2b312f23..2d36d0e6 100644
--- a/src/server/api/game-manager.ts
+++ b/src/server/api/game-manager.ts
@@ -220,7 +220,7 @@ export class HumanGameManager extends GameManager {
                     SaveManager.endGame(ids[0], ids[1]);
                 else SaveManager.endGame(ids[1], ids[0]);
             }
-        } 
+        }
     }
 }
 
diff --git a/src/server/api/managers.ts b/src/server/api/managers.ts
index c0b7f994..fb41e9f1 100644
--- a/src/server/api/managers.ts
+++ b/src/server/api/managers.ts
@@ -9,7 +9,7 @@ import { SocketManager } from "./socket-manager";
 export const socketManager = new SocketManager({});
 export const clientManager = new ClientManager(socketManager);
 export let gameManager: GameManager | null = null;
-export const gamePaused = {flag:false};
+export const gamePaused = { flag: false };
 
 export function setGameManager(manager: GameManager) {
     gameManager = manager;
diff --git a/src/server/api/save-manager.ts b/src/server/api/save-manager.ts
index b54b91fd..5f77f233 100644
--- a/src/server/api/save-manager.ts
+++ b/src/server/api/save-manager.ts
@@ -10,7 +10,8 @@
  * Modified: 9/20/24
  */
 
-import { Side } from "../../common/game-types";2
+import { Side } from "../../common/game-types";
+2;
 
 // Save files contain a date in ms and pgn string
 export interface iSave {
@@ -19,10 +20,10 @@ export interface iSave {
     hostWhite: boolean;
     aiDifficulty: number;
     game: string;
-    pos:string;
-    robotPos: Array<[string,string]>;
+    pos: string;
+    robotPos: Array<[string, string]>;
     oldPos: string;
-    oldRobotPos: Array<[string,string]>;
+    oldRobotPos: Array<[string, string]>;
 }
 
 export class SaveManager {
@@ -57,7 +58,7 @@ export class SaveManager {
             pos: fen,
             robotPos: Array.from(robots),
             oldPos: "",
-            oldRobotPos: Array<[string,string]>(),
+            oldRobotPos: Array<[string, string]>(),
         };
         const oldGame = SaveManager.loadGame(hostId + "+" + clientID);
         if (oldGame && oldGame.pos !== null) {
diff --git a/src/server/command/command.ts b/src/server/command/command.ts
index 75ce3949..6c8796c8 100644
--- a/src/server/command/command.ts
+++ b/src/server/command/command.ts
@@ -113,7 +113,9 @@ function isReversable(obj): obj is Reversible<typeof obj> {
  */
 export class ParallelCommandGroup extends CommandGroup {
     public async execute(): Promise<void> {
-        const promises = this.commands.map((move) => {gamePaused.flag?null:move.execute()});
+        const promises = this.commands.map((move) => {
+            gamePaused.flag ? null : move.execute();
+        });
         return Promise.all(promises).then(null);
     }
     public async reverse(): Promise<void> {
@@ -133,7 +135,9 @@ export class SequentialCommandGroup extends CommandGroup {
     public async execute(): Promise<void> {
         let promise = Promise.resolve();
         for (const command of this.commands) {
-            promise = promise.then(() => {gamePaused?null:command.execute()});
+            promise = promise.then(() => {
+                gamePaused.flag ? null : command.execute();
+            });
         }
         return promise;
     }
diff --git a/src/server/command/executor.ts b/src/server/command/executor.ts
index c2e8d35e..28b85c0f 100644
--- a/src/server/command/executor.ts
+++ b/src/server/command/executor.ts
@@ -43,14 +43,14 @@ export class CommandExecutor {
     public async execute(command: Command): Promise<void> {
         this.checkRequirements(command);
         this.runningCommands.push(command);
-        if(!gamePaused.flag){ 
+        if (!gamePaused.flag) {
             return command.execute().finally(() => {
                 this.oldCommands.unshift(command);
                 const index = this.runningCommands.indexOf(command);
                 if (index >= 0) {
                     this.runningCommands.splice(index, 1);
                 }
-            })
+            });
         }
     }
 
@@ -59,19 +59,19 @@ export class CommandExecutor {
      * mainly used to finish the backlog from a paused game
      * @returns - The command to execute.
      */
-    public async finishExecution() : Promise<void> {
-        return this.runningCommands.forEach((command) =>{
-            command.execute().finally(()=>{
+    public async finishExecution(): Promise<void> {
+        return this.runningCommands.forEach((command) => {
+            command.execute().finally(() => {
                 this.oldCommands.unshift(command);
                 const index = this.runningCommands.indexOf(command);
                 if (index >= 0) {
                     this.runningCommands.splice(index, 1);
                 }
-            })
-        })
+            });
+        });
     }
 
-    public clearExecution(){
+    public clearExecution() {
         this.runningCommands = [];
     }
 
@@ -83,7 +83,7 @@ export class CommandExecutor {
         return this.oldCommands;
     }
 
-    public clearOldCommands(){
+    public clearOldCommands() {
         this.oldCommands = [];
     }
 }
diff --git a/src/server/robot/robot-manager.ts b/src/server/robot/robot-manager.ts
index 5945bf23..32daecfc 100644
--- a/src/server/robot/robot-manager.ts
+++ b/src/server/robot/robot-manager.ts
@@ -100,8 +100,10 @@ export class RobotManager {
         indicesToIds.set(indices.toString(), robotId);
     }
 
-    stopAllRobots(){
-        Array.from(this.idsToRobots.values()).forEach((robot)=>{robot.sendStopPacket()})
+    stopAllRobots() {
+        Array.from(this.idsToRobots.values()).forEach((robot) => {
+            robot.sendStopPacket();
+        });
     }
 }
 
diff --git a/src/server/robot/robot.ts b/src/server/robot/robot.ts
index 2571a158..62556b36 100644
--- a/src/server/robot/robot.ts
+++ b/src/server/robot/robot.ts
@@ -187,7 +187,7 @@ export class Robot {
         });
     }
 
-    public async sendStopPacket():Promise<void>{
+    public async sendStopPacket(): Promise<void> {
         await this.tunnel!.send({
             type: PacketType.ESTOP,
         });

From e166cf95143b9ad75f5e405fe3f0f84a97a1bcb5 Mon Sep 17 00:00:00 2001
From: ymmot239 <pacman239sa@gmail.com>
Date: Mon, 22 Sep 2025 20:29:46 -0500
Subject: [PATCH 07/11] pause on reload

Forced clients to be paused even on join or reload.
---
 src/client/game/game.tsx       | 16 +++++-------
 src/server/api/api.ts          | 47 ++++++++++++++++++++--------------
 src/server/api/save-manager.ts |  2 +-
 3 files changed, 35 insertions(+), 30 deletions(-)

diff --git a/src/client/game/game.tsx b/src/client/game/game.tsx
index 5adac3a5..c10d8741 100644
--- a/src/client/game/game.tsx
+++ b/src/client/game/game.tsx
@@ -104,11 +104,12 @@ export function Game(): JSX.Element {
         "game-state",
         async () => {
             return get("/game-state").then((gameState) => {
-                setChess(new ChessEngine(gameState.position));
-                if (gameState.gameEndReason !== undefined) {
-                    setGameInterruptedReason(gameState.gameEndReason);
+                setChess(new ChessEngine(gameState.state.position));
+                setPause(gameState.pause);
+                if (gameState.state.gameEndReason !== undefined) {
+                    setGameInterruptedReason(gameState.state.gameEndReason);
                 }
-                return gameState;
+                return gameState.state;
             });
         },
         false,
@@ -161,12 +162,7 @@ export function Game(): JSX.Element {
             :   null
         :   null;
 
-    const gamePauseDialog =
-        gameHoldReason !== undefined ?
-            gameHoldReason === GameHoldReason.GAME_PAUSED ?
-                <PauseDialog />
-            :   null
-        :   null;
+    const gamePauseDialog = paused ? <PauseDialog /> : null;
 
     const gameUnpauseDialog =
         gameHoldReason !== undefined ?
diff --git a/src/server/api/api.ts b/src/server/api/api.ts
index a1490fe9..7dd28429 100644
--- a/src/server/api/api.ts
+++ b/src/server/api/api.ts
@@ -221,7 +221,10 @@ apiRouter.get("/game-state", (req, res) => {
         return res.status(400).send({ message: "No game is currently active" });
     }
     const clientType = clientManager.getClientType(req.cookies.id);
-    return res.send(gameManager.getGameState(clientType));
+    return res.send({
+        state: gameManager.getGameState(clientType),
+        pause: gamePaused.flag,
+    });
 });
 
 /**
@@ -575,26 +578,32 @@ apiRouter.get("/pause-game", (_, res) => {
  * Todo: add authentication instead of an exposed unpause call
  */
 apiRouter.get("/unpause-game", async (_, res) => {
-    gamePaused.flag = false;
-    const ids = clientManager.getIds();
-    if (ids) {
-        const oldSave = SaveManager.loadGame(ids[0]);
-        gameManager?.chess.loadFen(oldSave!.oldPos);
-        setAllRobotsToDefaultPositions(
-            new Map(
-                oldSave!.oldRobotPos?.map<[string, GridIndices]>((obj) => [
-                    obj[1],
-                    new GridIndices(
-                        parseInt(obj[0].split(", ")[0]),
-                        parseInt(obj[0].split(", ")[1]),
-                    ),
-                ]),
-            ),
+    if (gamePaused.flag) {
+        gamePaused.flag = false;
+        const ids = clientManager.getIds();
+        if (ids) {
+            const oldSave = SaveManager.loadGame(ids[0]);
+            gameManager?.chess.loadFen(oldSave!.oldPos);
+            setAllRobotsToDefaultPositions(
+                new Map(
+                    oldSave!.oldRobotPos?.map<[string, GridIndices]>((obj) => [
+                        obj[1],
+                        new GridIndices(
+                            parseInt(obj[0].split(", ")[0]),
+                            parseInt(obj[0].split(", ")[1]),
+                        ),
+                    ]),
+                ),
+            );
+            socketManager.sendToAll(new SetChessMessage(oldSave!.oldPos));
+        }
+        socketManager.sendToAll(
+            new GameHoldMessage(GameHoldReason.GAME_UNPAUSED),
         );
-        socketManager.sendToAll(new SetChessMessage(oldSave!.oldPos));
+        return res.send({ message: "success" });
+    } else {
+        return res.send({ message: "game not paused" });
     }
-    socketManager.sendToAll(new GameHoldMessage(GameHoldReason.GAME_UNPAUSED));
-    return res.send({ message: "success" });
 });
 
 /**
diff --git a/src/server/api/save-manager.ts b/src/server/api/save-manager.ts
index 5f77f233..570bd958 100644
--- a/src/server/api/save-manager.ts
+++ b/src/server/api/save-manager.ts
@@ -62,7 +62,7 @@ export class SaveManager {
         };
         const oldGame = SaveManager.loadGame(hostId + "+" + clientID);
         if (oldGame && oldGame.pos !== null) {
-            saveContents.oldPos = oldGame.game;
+            saveContents.oldPos = oldGame.pos;
             saveContents.oldRobotPos = oldGame.robotPos;
         }
         return FileManager.writeFile(hostId + "+" + clientID, saveContents);

From c2dfc02ff7b0987b40f9ff94cf321ead5476bfdc Mon Sep 17 00:00:00 2001
From: ymmot239 <pacman239sa@gmail.com>
Date: Thu, 25 Sep 2025 14:50:08 -0500
Subject: [PATCH 08/11] Fixed merge conflicts

Added back some functions that were removed during a merge from main.
Also removed some unused functions in executor.
---
 src/server/api/api.ts          | 18 ++++++++++++++----
 src/server/command/executor.ts |  8 --------
 2 files changed, 14 insertions(+), 12 deletions(-)

diff --git a/src/server/api/api.ts b/src/server/api/api.ts
index 7dd28429..6fb1114d 100644
--- a/src/server/api/api.ts
+++ b/src/server/api/api.ts
@@ -51,12 +51,12 @@ import {
     SpinRadiansCommand,
 } from "../command/move-command";
 import { GridIndices } from "../robot/grid-indices";
+import { puzzles, type PuzzleComponents } from "./puzzles";
 import {
     moveAllRobotsHomeToDefaultOptimized,
     moveAllRobotsToDefaultPositions,
+    moveAllRobotsFromBoardToHome,
 } from "../robot/path-materializer";
-import type { PuzzleComponents } from "./puzzles";
-import { puzzles } from "./puzzles";
 import { tcpServer } from "./tcp-interface";
 import { robotManager } from "../robot/robot-manager";
 import { executor } from "../command/executor";
@@ -76,7 +76,7 @@ async function setupDefaultRobotPositions(
                 moveAllRobotsToDefaultPositions(defaultPositionsMap);
             await executor.execute(command);
         } else {
-            moveAllRobotsToDefaultPositions(defaultPositionsMap);
+            setAllRobotsToDefaultPositions(defaultPositionsMap);
         }
     } else {
         if (isMoving) {
@@ -299,6 +299,7 @@ apiRouter.post("/start-puzzle-game", async (req, res) => {
     const fen = puzzle.fen;
     const moves = puzzle.moves;
     const difficulty = puzzle.rating;
+    const tooltip = puzzle.tooltip;
 
     if (puzzle.robotDefaultPositions) {
         // Convert puzzle.robotDefaultPositions from Record<string, string> to Map<string, GridIndices>
@@ -335,7 +336,7 @@ apiRouter.post("/start-puzzle-game", async (req, res) => {
             new ChessEngine(),
             socketManager,
             fen,
-            "",
+            tooltip,
             moves,
             difficulty,
         ),
@@ -344,6 +345,15 @@ apiRouter.post("/start-puzzle-game", async (req, res) => {
     return res.send({ message: "success" });
 });
 
+/**
+ * Returns robots to home after a game ends.
+ */
+apiRouter.post("/return-home", async (_req, res) => {
+    const command = moveAllRobotsFromBoardToHome();
+    await executor.execute(command);
+    return res.send({ message: "success" });
+});
+
 /**
  * Returns all registered robot ids
  */
diff --git a/src/server/command/executor.ts b/src/server/command/executor.ts
index 28b85c0f..ef81c7eb 100644
--- a/src/server/command/executor.ts
+++ b/src/server/command/executor.ts
@@ -78,14 +78,6 @@ export class CommandExecutor {
     public getRunningCommands(): ReadonlyArray<Command> {
         return this.runningCommands;
     }
-
-    public getOldCommands(): ReadonlyArray<Command> {
-        return this.oldCommands;
-    }
-
-    public clearOldCommands() {
-        this.oldCommands = [];
-    }
 }
 
 export const executor = new CommandExecutor();

From 95d192c59ec545cda260b84b5047d2328f515347 Mon Sep 17 00:00:00 2001
From: ymmot239 <pacman239sa@gmail.com>
Date: Thu, 25 Sep 2025 17:21:43 -0500
Subject: [PATCH 09/11] Execution bugfix

Fixed the bug with executors not running all the commands
Also cleaned up the paused api being sent to the clients.
---
 src/client/game/game.tsx       | 8 ++++----
 src/server/api/api.ts          | 5 +----
 src/server/api/game-manager.ts | 2 ++
 src/server/command/command.ts  | 4 ++--
 4 files changed, 9 insertions(+), 10 deletions(-)

diff --git a/src/client/game/game.tsx b/src/client/game/game.tsx
index c10d8741..66c956e6 100644
--- a/src/client/game/game.tsx
+++ b/src/client/game/game.tsx
@@ -104,12 +104,12 @@ export function Game(): JSX.Element {
         "game-state",
         async () => {
             return get("/game-state").then((gameState) => {
-                setChess(new ChessEngine(gameState.state.position));
+                setChess(new ChessEngine(gameState.position));
                 setPause(gameState.pause);
-                if (gameState.state.gameEndReason !== undefined) {
-                    setGameInterruptedReason(gameState.state.gameEndReason);
+                if (gameState.gameEndReason !== undefined) {
+                    setGameInterruptedReason(gameState.gameEndReason);
                 }
-                return gameState.state;
+                return gameState;
             });
         },
         false,
diff --git a/src/server/api/api.ts b/src/server/api/api.ts
index 6fb1114d..8a9154d6 100644
--- a/src/server/api/api.ts
+++ b/src/server/api/api.ts
@@ -221,10 +221,7 @@ apiRouter.get("/game-state", (req, res) => {
         return res.status(400).send({ message: "No game is currently active" });
     }
     const clientType = clientManager.getClientType(req.cookies.id);
-    return res.send({
-        state: gameManager.getGameState(clientType),
-        pause: gamePaused.flag,
-    });
+    return res.send(gameManager.getGameState(clientType));
 });
 
 /**
diff --git a/src/server/api/game-manager.ts b/src/server/api/game-manager.ts
index 2d36d0e6..0331f467 100644
--- a/src/server/api/game-manager.ts
+++ b/src/server/api/game-manager.ts
@@ -34,6 +34,7 @@ type GameState = {
     side: Side;
     position: string;
     gameEndReason: GameEndReason | undefined;
+    pause: boolean;
     tooltip?: string;
     aiDifficulty?: number;
     difficulty?: number;
@@ -91,6 +92,7 @@ export abstract class GameManager {
             position: this.chess.pgn,
             gameEndReason: this.getGameEndReason(),
             tooltip: this.tooltip,
+            pause: gamePaused.flag,
         };
     }
 
diff --git a/src/server/command/command.ts b/src/server/command/command.ts
index 6c8796c8..bfeca6d3 100644
--- a/src/server/command/command.ts
+++ b/src/server/command/command.ts
@@ -114,7 +114,7 @@ function isReversable(obj): obj is Reversible<typeof obj> {
 export class ParallelCommandGroup extends CommandGroup {
     public async execute(): Promise<void> {
         const promises = this.commands.map((move) => {
-            gamePaused.flag ? null : move.execute();
+            if (!gamePaused.flag) return move.execute();
         });
         return Promise.all(promises).then(null);
     }
@@ -136,7 +136,7 @@ export class SequentialCommandGroup extends CommandGroup {
         let promise = Promise.resolve();
         for (const command of this.commands) {
             promise = promise.then(() => {
-                gamePaused.flag ? null : command.execute();
+                if (!gamePaused.flag) return command.execute();
             });
         }
         return promise;

From c2cc89bc7717df134510f5db386af6059209c558 Mon Sep 17 00:00:00 2001
From: Colin Wong <cwongmath@gmail.com>
Date: Mon, 29 Sep 2025 20:21:44 -0500
Subject: [PATCH 10/11] Apply suggestion from @Copilot

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
---
 src/client/game/admin-dialogs.tsx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/client/game/admin-dialogs.tsx b/src/client/game/admin-dialogs.tsx
index bc050016..b6bdc50a 100644
--- a/src/client/game/admin-dialogs.tsx
+++ b/src/client/game/admin-dialogs.tsx
@@ -43,7 +43,7 @@ interface NotificationDialogProps {
 }
 
 /**
- * SHows a closable notification dialog
+ * Shows a closable notification dialog
  * @param props - dialog text
  * @returns - notification dialog
  */

From fbffbc5c2aa22f65ac1e4c7d01d63b92a68c3983 Mon Sep 17 00:00:00 2001
From: ymmot239 <pacman239sa@gmail.com>
Date: Mon, 29 Sep 2025 20:46:20 -0500
Subject: [PATCH 11/11] Readability and small bugs

Added various changes recommended in the PR, such as promise resolution and execution problems.
---
 src/client/game/game.tsx       |  4 +---
 src/server/api/save-manager.ts |  1 -
 src/server/command/command.ts  |  9 ++++++---
 src/server/command/executor.ts | 20 +++++++++++---------
 4 files changed, 18 insertions(+), 16 deletions(-)

diff --git a/src/client/game/game.tsx b/src/client/game/game.tsx
index 66c956e6..52fdfc43 100644
--- a/src/client/game/game.tsx
+++ b/src/client/game/game.tsx
@@ -178,9 +178,7 @@ export function Game(): JSX.Element {
                 setChess(chess.copy(move));
                 sendMessage(new MoveMessage(move));
             }
-        :   (move: Move): void => {
-                move;
-            }; //send a do-nothing function if game is paused
+        :   () => {}; //send a do-nothing function if game is paused
 
     // return the chessboard wrapper, navbar, and potential end dialog
     return (
diff --git a/src/server/api/save-manager.ts b/src/server/api/save-manager.ts
index 570bd958..c88e93c0 100644
--- a/src/server/api/save-manager.ts
+++ b/src/server/api/save-manager.ts
@@ -11,7 +11,6 @@
  */
 
 import { Side } from "../../common/game-types";
-2;
 
 // Save files contain a date in ms and pgn string
 export interface iSave {
diff --git a/src/server/command/command.ts b/src/server/command/command.ts
index bfeca6d3..7b10d97f 100644
--- a/src/server/command/command.ts
+++ b/src/server/command/command.ts
@@ -113,9 +113,11 @@ function isReversable(obj): obj is Reversible<typeof obj> {
  */
 export class ParallelCommandGroup extends CommandGroup {
     public async execute(): Promise<void> {
-        const promises = this.commands.map((move) => {
-            if (!gamePaused.flag) return move.execute();
-        });
+        const promises = this.commands
+            .map((move) => {
+                if (!gamePaused.flag) return move.execute();
+            })
+            .filter(Boolean);
         return Promise.all(promises).then(null);
     }
     public async reverse(): Promise<void> {
@@ -137,6 +139,7 @@ export class SequentialCommandGroup extends CommandGroup {
         for (const command of this.commands) {
             promise = promise.then(() => {
                 if (!gamePaused.flag) return command.execute();
+                else return Promise.resolve();
             });
         }
         return promise;
diff --git a/src/server/command/executor.ts b/src/server/command/executor.ts
index ef81c7eb..b34d3f11 100644
--- a/src/server/command/executor.ts
+++ b/src/server/command/executor.ts
@@ -60,15 +60,17 @@ export class CommandExecutor {
      * @returns - The command to execute.
      */
     public async finishExecution(): Promise<void> {
-        return this.runningCommands.forEach((command) => {
-            command.execute().finally(() => {
-                this.oldCommands.unshift(command);
-                const index = this.runningCommands.indexOf(command);
-                if (index >= 0) {
-                    this.runningCommands.splice(index, 1);
-                }
-            });
-        });
+        return Promise.all(
+            this.runningCommands.map((command) => {
+                command.execute().finally(() => {
+                    this.oldCommands.unshift(command);
+                    const index = this.runningCommands.indexOf(command);
+                    if (index >= 0) {
+                        this.runningCommands.splice(index, 1);
+                    }
+                });
+            }),
+        ).then();
     }
 
     public clearExecution() {