Added pause rollback

allowed pause to rollback the robot positions.
Also allowed saveGame to load from a saved positions, so hopefully less errors

Author: ymmot239

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 (

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" });
 });

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]);
             }
-        } 
+        }
     }
 }
 

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;

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) {

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;
     }

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 = [];
     }
 }

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();
+        });
     }
 }
 

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,
         });