Bot pause resume

src/client/game/admin-dialogs.tsx

@@ -0,0 +1,82 @@
+import {
+    Button,
+    Dialog,
+    DialogBody,
+    DialogFooter,
+    NonIdealState,
+} from "@blueprintjs/core";
+import { useState } from "react";
+import { bgColor, buttonColor, textColor } from "../check-dark-mode";
+
+interface DrawDialogProps {
+    dialogText?: string;
+}
+
+/**
+ * Shows a paused dialog that cannot be closed
+ * @param props - dialog text
+ * @returns - pause 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>
+    );
+}
+
+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={() => {
+                setIsOpen(false);
+            }}
+        />
+    );
+
+    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>
+    );
+}

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 { NotificationDialog, PauseDialog } from "./admin-dialogs";
 import { PuzzleTipBox } from "../PuzzleTipBox";
 
 /**
@@ -41,6 +42,7 @@ function getMessageHandler(
     setGameInterruptedReason: Dispatch<GameInterruptedReason>,
     setGameEndedReason: Dispatch<GameEndReason>,
     setGameHoldReason: Dispatch<GameHoldReason>,
+    setPaused: Dispatch<boolean>,
 ): MessageHandler {
     return (message) => {
         if (message instanceof MoveMessage) {
@@ -63,6 +65,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);
+            }
         }
     };
 }
@@ -78,6 +85,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(
@@ -87,6 +95,7 @@ export function Game(): JSX.Element {
             setGameInterruptedReason,
             setGameEndedReason,
             setGameHoldReason,
+            setPause,
         ),
     );
 
@@ -95,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,
@@ -137,6 +147,7 @@ export function Game(): JSX.Element {
         gameEndReason !== undefined ?
             <GameEndDialog reason={gameEndReason} side={side} />
         :   null;
+
     const gameOfferDialog =
         gameHoldReason !== undefined ?
             gameHoldReason === GameHoldReason.DRAW_CONFIRMATION ?
@@ -151,11 +162,25 @@ export function Game(): JSX.Element {
             :   null
         :   null;
 
+    const gamePauseDialog = paused ? <PauseDialog /> : null;
+
+    const gameUnpauseDialog =
+        gameHoldReason !== undefined ?
+            gameHoldReason === GameHoldReason.GAME_UNPAUSED ?
+                <NotificationDialog dialogText="Game Unpaused" />
+            :   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 (
@@ -182,6 +207,8 @@ export function Game(): JSX.Element {
                 {gameEndDialog}
                 {gameOfferDialog}
                 {gameAcceptDialog}
+                {gamePauseDialog}
+                {gameUnpauseDialog}
                 <Outlet />
             </div>
         </>

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",
 }

src/server/api/api.ts

@@ -33,7 +33,7 @@ import { Side } from "../../common/game-types";
 import { USE_VIRTUAL_ROBOTS, START_ROBOTS_AT_DEFAULT } from "../utils/env";
 import { SaveManager } from "./save-manager";
 
-import { VirtualBotTunnel, VirtualRobot } from "../simulator";
+import { VirtualBotTunnel } from "../simulator";
 import { Position } from "../robot/position";
 import { DEGREE } from "../../common/units";
 import { PacketType } from "../utils/tcp-packet";
@@ -50,15 +50,21 @@ 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";
+import {
+    gamePaused,
+    pauseGame,
+    setAllRobotsToDefaultPositions,
+    unpauseGame,
+} from "./pauseHandler";
 
 /**
  * Helper function to move all robots from their home positions to their default positions
@@ -74,7 +80,7 @@ async function setupDefaultRobotPositions(
                 moveAllRobotsToDefaultPositions(defaultPositionsMap);
             await executor.execute(command);
         } else {
-            setAllRobotsToDefaultPositions(defaultPositionsMap);
+            moveAllRobotsToDefaultPositions(defaultPositionsMap);
         }
     } else {
         if (isMoving) {
@@ -86,26 +92,6 @@ async function setupDefaultRobotPositions(
     }
 }
 
-function setAllRobotsToDefaultPositions(
-    defaultPositionsMap?: Map<string, GridIndices>,
-): void {
-    if (defaultPositionsMap) {
-        for (const [robotId, indices] of defaultPositionsMap.entries()) {
-            const robot = robotManager.getRobot(robotId);
-            robot.position = Position.fromGridIndices(indices);
-            if (robot instanceof VirtualRobot)
-                robot.updateTunnelPosition(robot.position);
-        }
-    } else {
-        for (const robot of robotManager.idsToRobots.values()) {
-            robot.position = Position.fromGridIndices(robot.defaultIndices);
-            if (robot instanceof VirtualRobot)
-                robot.updateTunnelPosition(robot.position);
-            robotManager.updateRobot(robot.id, robot.defaultIndices);
-        }
-    }
-}
-
 /**
  * An endpoint used to establish a websocket connection with the server.
  *
@@ -184,6 +170,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
@@ -208,7 +205,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,
+    });
 });
 
 /**
@@ -283,7 +283,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>
@@ -320,7 +319,7 @@ apiRouter.post("/start-puzzle-game", async (req, res) => {
             new ChessEngine(),
             socketManager,
             fen,
-            tooltip,
+            "",
             moves,
             difficulty,
         ),
@@ -329,15 +328,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
  */
@@ -556,6 +546,25 @@ 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) => {
+    return res.send(pauseGame(true));
+});
+
+/**
+ * Unpause the game
+ * Todo: add authentication instead of an exposed unpause call
+ */
+
+apiRouter.get("/unpause-game", async (_, res) => {
+    const unpausePacket = unpauseGame(true);
+
+    return res.send(unpausePacket);
+});
+
 /**
  * sends a drive message through the tcp connection
  *