From 70aae371d52f5db09dcf2d24cd0e0f114653cd5b Mon Sep 17 00:00:00 2001
From: ymmot239 <77180103+ymmot239@users.noreply.github.com>
Date: Fri, 18 Oct 2024 16:57:42 -0500
Subject: [PATCH 01/27] Short update

moving computers.
created most of the setup page
Need to create the server response to client moves.
---
 saves/puzzles                        |  0
 src/client/puzzle/puzzle-manager.tsx | 14 ++++++
 src/client/puzzle/puzzle.tsx         |  6 +--
 src/client/puzzle/select-puzzle.tsx  | 72 ++++++++++++++++++++++++++++
 src/client/puzzle/setup-puzzle.tsx   | 47 ++++++++++++++++++
 src/client/setup/setup.tsx           |  4 ++
 src/common/chess-engine.ts           | 18 +++++++
 src/server/api/api.ts                | 52 +++++++++++++++-----
 src/server/api/game-manager.ts       | 35 ++++++++++++++
 9 files changed, 233 insertions(+), 15 deletions(-)
 create mode 100644 saves/puzzles
 create mode 100644 src/client/puzzle/puzzle-manager.tsx
 create mode 100644 src/client/puzzle/select-puzzle.tsx
 create mode 100644 src/client/puzzle/setup-puzzle.tsx

diff --git a/saves/puzzles b/saves/puzzles
new file mode 100644
index 00000000..e69de29b
diff --git a/src/client/puzzle/puzzle-manager.tsx b/src/client/puzzle/puzzle-manager.tsx
new file mode 100644
index 00000000..1283bf55
--- /dev/null
+++ b/src/client/puzzle/puzzle-manager.tsx
@@ -0,0 +1,14 @@
+
+/**
+ * Class for managing saved puzzles and user completion status
+ * 
+ * Users are tracked by cookie id, though it doesn't save across devices and clients
+ */
+export class PuzzleManager{
+    public static getAllPuzzles(){
+
+    }
+    public static getPuzzle(){
+
+    }
+}
\ No newline at end of file
diff --git a/src/client/puzzle/puzzle.tsx b/src/client/puzzle/puzzle.tsx
index bb6d901c..2e3dc381 100644
--- a/src/client/puzzle/puzzle.tsx
+++ b/src/client/puzzle/puzzle.tsx
@@ -1,3 +1,3 @@
-export function Puzzle() {
-    return <></>;
-}
+export function Puzzle(): JSX.Element {
+    return <></>
+}
\ No newline at end of file
diff --git a/src/client/puzzle/select-puzzle.tsx b/src/client/puzzle/select-puzzle.tsx
new file mode 100644
index 00000000..631e6c17
--- /dev/null
+++ b/src/client/puzzle/select-puzzle.tsx
@@ -0,0 +1,72 @@
+import { Button, MenuItem } from "@blueprintjs/core";
+import { ItemRenderer, Select } from "@blueprintjs/select";
+import { post } from "../api";
+import { useNavigate } from "react-router-dom";
+import { PuzzleComponents } from "../../server/api/api";
+
+const renderPuzzleOptions: ItemRenderer<string> = (
+    puzzleNumber,
+    { modifiers, handleFocus, handleClick },
+) => {
+    return (
+        <MenuItem
+            key={puzzleNumber}
+            active={modifiers.active}
+            roleStructure="listoption"
+            text={"Puzzle Number " + puzzleNumber}
+            onFocus={handleFocus}
+            onClick={handleClick}
+        />
+    );
+};
+
+interface SelectPuzzleProps {
+    puzzles: Map<string, PuzzleComponents>;
+    selectedPuzzle: string | undefined;
+    onPuzzleSelected: (puzzle: string) => void;
+}
+
+export function SelectPuzzle(props: SelectPuzzleProps) {
+    const navigate = useNavigate();
+    const hasSelection = props.selectedPuzzle !== undefined;
+
+    const submit = (
+        <Button
+            text="Play"
+            icon="arrow-right"
+            intent="primary"
+            onClick={async () => {
+                if(props.selectedPuzzle){
+                    const promise = post("/start-puzzle-game", {
+                        puzzle: props.selectedPuzzle,
+                    });
+                    promise.then(()=>{
+                        navigate("/game")
+                    })
+                }
+            }}
+        />
+    );
+
+    return (
+        <>
+        <Select<string>
+            items={[...props.puzzles.keys()]}
+            itemRenderer={renderPuzzleOptions}
+            onItemSelect={props.onPuzzleSelected}
+            filterable={false}
+            popoverProps={{ minimal: true }}
+        >
+            <Button
+                text={
+                    hasSelection ?
+                        "Puzzle " + props.selectedPuzzle
+                    :   "Select a puzzle..."
+                }
+                rightIcon="double-caret-vertical"
+            />
+        </Select>
+        {submit}
+        </>
+    );
+}
diff --git a/src/client/puzzle/setup-puzzle.tsx b/src/client/puzzle/setup-puzzle.tsx
new file mode 100644
index 00000000..81f5826f
--- /dev/null
+++ b/src/client/puzzle/setup-puzzle.tsx
@@ -0,0 +1,47 @@
+import { useState } from "react";
+import { SetupBase } from "../setup/setup-base";
+import { SelectPuzzle } from "./select-puzzle";
+import { NonIdealState, Spinner } from "@blueprintjs/core";
+import { get, useEffectQuery } from "../api";
+import { Navigate } from "react-router-dom";
+
+export function SetupPuzzle() {
+    const [selectedPuzzle, setSelectedPuzzle] = useState<string | undefined>();
+
+    //const puzzles = get("/get-puzzles")
+    const { isPending, data, isError } = useEffectQuery(
+        "get-puzzles",
+        async () => {
+            return get("/get-puzzles").then((puzzles) => {
+                return puzzles;
+            });
+        },
+        false,
+    );
+
+    if (isPending) {
+        return (
+            <NonIdealState
+                icon={<Spinner intent="primary" />}
+                title="Loading..."
+            />
+        );
+    } else if (isError) {
+        return <Navigate to="/home" />;
+    }
+
+
+    if (data === undefined) {
+        return <Spinner intent="primary" />;
+    } else {
+        return (
+            <SetupBase>
+                <SelectPuzzle
+                    puzzles={data}
+                    selectedPuzzle={selectedPuzzle}
+                    onPuzzleSelected={setSelectedPuzzle}
+                />
+            </SetupBase>
+        );
+    }
+}
diff --git a/src/client/setup/setup.tsx b/src/client/setup/setup.tsx
index 6475268d..90fdcde8 100644
--- a/src/client/setup/setup.tsx
+++ b/src/client/setup/setup.tsx
@@ -4,6 +4,7 @@ import { Dispatch, useState } from "react";
 import { SetupGame } from "./setup-game";
 import { useNavigate } from "react-router-dom";
 import { GameType } from "../../common/client-types";
+import { SetupPuzzle } from "../puzzle/setup-puzzle";
 
 enum SetupType {
     MAIN = "main",
@@ -29,6 +30,9 @@ export function Setup(): JSX.Element {
                     }
                 />
             :   null}
+            {setupType === SetupType.PUZZLE ?
+                <SetupPuzzle />
+            :   null}
         </SetupBase>
     );
 }
diff --git a/src/common/chess-engine.ts b/src/common/chess-engine.ts
index 8e37ba63..f15c7f9f 100644
--- a/src/common/chess-engine.ts
+++ b/src/common/chess-engine.ts
@@ -15,6 +15,7 @@ export class ChessEngine {
         if (pgn !== undefined) {
             this.chess.loadPgn(pgn);
         }
+        
     }
 
     /**
@@ -38,6 +39,14 @@ export class ChessEngine {
         return this.chess.pgn();
     }
 
+    undo(){
+        this.chess.undo();
+    }
+
+    load(fen: string){
+        this.chess.load(fen);
+    }
+
     loadPgn(pgn: string) {
         this.chess.loadPgn(pgn);
     }
@@ -164,6 +173,15 @@ export class ChessEngine {
         return move;
     }
 
+    /**
+     * Makes a move on the chessboard.
+     * @returns the move that was made.
+     */
+    move(move:string):string{
+        this.chess.move(move);
+        return move;
+    }
+
     /**
      * Returns true if a move is a promotion, and false otherwise.
      * Assumes that chess hasn't been updated yet
diff --git a/src/server/api/api.ts b/src/server/api/api.ts
index 3d68f623..0e36a34a 100644
--- a/src/server/api/api.ts
+++ b/src/server/api/api.ts
@@ -16,6 +16,7 @@ import {
     ComputerGameManager,
     GameManager,
     HumanGameManager,
+    PuzzleGameManager,
 } from "./game-manager";
 import { ChessEngine } from "../../common/chess-engine";
 import { Side } from "../../common/game-types";
@@ -100,6 +101,20 @@ apiRouter.post("/start-human-game", (req, res) => {
     return res.send({ message: "success" });
 });
 
+apiRouter.post("/start-puzzle-game", (req, res) => {
+    const fen = req.query.fen as string;
+    const moves = req.query.difficulty as string[];
+    const difficulty = parseInt(req.query.difficulty as string);
+    gameManager = new PuzzleGameManager(
+        new ChessEngine(),
+        socketManager,
+        fen,
+        moves,
+        difficulty,
+    );
+    return res.send({ message: "success" });
+});
+
 apiRouter.get("/get-ids", (_, res) => {
     const ids = tcpServer.getConnectedIds();
     if (IS_DEVELOPMENT) {
@@ -108,24 +123,37 @@ apiRouter.get("/get-ids", (_, res) => {
     return res.send({ ids });
 });
 
+export interface PuzzleComponents{
+    fen:string,
+    moves:string[],
+    rating:number
+}
 /**
  * Returns a list of available puzzles to play.
  */
 apiRouter.get("/get-puzzles", (_, res) => {
-    return res.send({
-        puzzles: [
+    const puzzles: Map<string, PuzzleComponents> = 
+    new Map([
+        ["Puzzle 1",
             {
-                name: "Puzzle 1",
-                id: "puzzleId1",
-                rating: "1200",
-            },
+                fen:"8/1p3p1k/8/p1p2Kr1/P2pP3/1P1P4/2P5/8 w HAha - 0 1",
+                moves:["Kxg5"],
+                rating:511
+            }],
+        ["Puzzle 2",
             {
-                name: "Puzzle 2",
-                id: "puzzleId2",
-                rating: "1400",
-            },
-        ],
-    });
+                fen:"5rk1/p5pp/4q3/8/1P1P4/2P4P/P2p1RP1/5RK1 w HAha - 0 1",
+                moves:["Rxf8#"],
+                rating:514
+            }],
+        ["Puzzle 3",
+            {
+                fen:"8/3B4/2P2P2/1P1P1p2/3pP1p1/1pK5/2p4R/2k3r1 w HAha - 0 1",
+                moves:["Rb6+","d6","Rd6#"],
+                rating:1000
+            }],
+    ]);
+    return res.send(puzzles);
 });
 
 function doDriveRobot(message: DriveRobotMessage): boolean {
diff --git a/src/server/api/game-manager.ts b/src/server/api/game-manager.ts
index 5cb74a86..1c0872f1 100644
--- a/src/server/api/game-manager.ts
+++ b/src/server/api/game-manager.ts
@@ -146,3 +146,38 @@ export class ComputerGameManager extends GameManager {
         }
     }
 }
+
+export class PuzzleGameManager extends GameManager {
+    private moveNumber:number = 0;
+
+    constructor(
+        chess: ChessEngine,
+        socketManager: SocketManager,
+        fen: string,
+        private moves:string[],
+        protected difficulty: number,
+    ) {
+        super(chess, socketManager, Side.WHITE);
+        chess.load(fen);
+    }
+
+    public handleMessage(message: Message, id: string): void {
+        if (message instanceof MoveMessage) {
+            
+            if (this.moves[this.moveNumber]===message.move.to){
+                this.chess.makeMove(message.move);
+                this.chess.move(this.moves[this.moveNumber+1]);
+                this.moveNumber++;
+            }
+            else{
+                
+            }
+            
+
+        } else if (message instanceof GameInterruptedMessage) {
+            this.gameInterruptedReason = message.reason;
+            // Reflect end game reason back to client
+            this.socketManager.sendToSocket(id, message);
+        }
+    }
+}
\ No newline at end of file

From 4509c901bf2fd5319824a1ff78043f2da9dfc567 Mon Sep 17 00:00:00 2001
From: ymmot239 <77180103+ymmot239@users.noreply.github.com>
Date: Fri, 25 Oct 2024 18:21:14 -0500
Subject: [PATCH 02/27] intermediate push

code update for puzzle framework
---
 src/client/puzzle/select-puzzle.tsx | 52 ++++++++++++++++-------------
 src/client/puzzle/setup-puzzle.tsx  |  2 +-
 src/server/api/api.ts               | 12 +++++--
 src/server/api/game-manager.ts      |  4 +--
 4 files changed, 40 insertions(+), 30 deletions(-)

diff --git a/src/client/puzzle/select-puzzle.tsx b/src/client/puzzle/select-puzzle.tsx
index 631e6c17..80611a2f 100644
--- a/src/client/puzzle/select-puzzle.tsx
+++ b/src/client/puzzle/select-puzzle.tsx
@@ -13,7 +13,7 @@ const renderPuzzleOptions: ItemRenderer<string> = (
             key={puzzleNumber}
             active={modifiers.active}
             roleStructure="listoption"
-            text={"Puzzle Number " + puzzleNumber}
+            text={puzzleNumber}
             onFocus={handleFocus}
             onClick={handleClick}
         />
@@ -36,37 +36,41 @@ export function SelectPuzzle(props: SelectPuzzleProps) {
             icon="arrow-right"
             intent="primary"
             onClick={async () => {
-                if(props.selectedPuzzle){
+                if (props.selectedPuzzle && props.puzzles) {
+                    //console.log(props.puzzles.get(props.selectedPuzzle));
+                    const puzz = props.puzzles as Map<string, object>;
+                    console.log(puzz[props.selectedPuzzle]);
                     const promise = post("/start-puzzle-game", {
-                        puzzle: props.selectedPuzzle,
+                        puzzle: JSON.stringify(
+                            puzz[props.selectedPuzzle],
+                        ),
+                    });
+                    promise.then(() => {
+                        navigate("/game");
                     });
-                    promise.then(()=>{
-                        navigate("/game")
-                    })
                 }
             }}
         />
     );
-
     return (
         <>
-        <Select<string>
-            items={[...props.puzzles.keys()]}
-            itemRenderer={renderPuzzleOptions}
-            onItemSelect={props.onPuzzleSelected}
-            filterable={false}
-            popoverProps={{ minimal: true }}
-        >
-            <Button
-                text={
-                    hasSelection ?
-                        "Puzzle " + props.selectedPuzzle
-                    :   "Select a puzzle..."
-                }
-                rightIcon="double-caret-vertical"
-            />
-        </Select>
-        {submit}
+            <Select<string>
+                items={[...Object.keys(props.puzzles)]}
+                itemRenderer={renderPuzzleOptions}
+                onItemSelect={props.onPuzzleSelected}
+                filterable={false}
+                popoverProps={{ minimal: true }}
+            >
+                <Button
+                    text={
+                        hasSelection ?
+                            props.selectedPuzzle
+                        :   "Select a puzzle..."
+                    }
+                    rightIcon="double-caret-vertical"
+                />
+            </Select>
+            {submit}
         </>
     );
 }
diff --git a/src/client/puzzle/setup-puzzle.tsx b/src/client/puzzle/setup-puzzle.tsx
index 81f5826f..29a7255d 100644
--- a/src/client/puzzle/setup-puzzle.tsx
+++ b/src/client/puzzle/setup-puzzle.tsx
@@ -30,7 +30,7 @@ export function SetupPuzzle() {
         return <Navigate to="/home" />;
     }
 
-
+    
     if (data === undefined) {
         return <Spinner intent="primary" />;
     } else {
diff --git a/src/server/api/api.ts b/src/server/api/api.ts
index 0e36a34a..66d07eb6 100644
--- a/src/server/api/api.ts
+++ b/src/server/api/api.ts
@@ -102,7 +102,10 @@ apiRouter.post("/start-human-game", (req, res) => {
 });
 
 apiRouter.post("/start-puzzle-game", (req, res) => {
-    const fen = req.query.fen as string;
+    const puzzle = req.query.puzzle as object;
+    console.log(puzzle);
+    const fen = "";
+    console.log(fen);
     const moves = req.query.difficulty as string[];
     const difficulty = parseInt(req.query.difficulty as string);
     gameManager = new PuzzleGameManager(
@@ -153,7 +156,12 @@ apiRouter.get("/get-puzzles", (_, res) => {
                 rating:1000
             }],
     ]);
-    return res.send(puzzles);
+    const obj: { [key: string]: PuzzleComponents } = {};
+    puzzles.forEach((value, key) => {
+        obj[key] = value;
+    });
+    const a: string = JSON.stringify(obj);
+    return res.send(a);
 });
 
 function doDriveRobot(message: DriveRobotMessage): boolean {
diff --git a/src/server/api/game-manager.ts b/src/server/api/game-manager.ts
index 1c0872f1..98c0badf 100644
--- a/src/server/api/game-manager.ts
+++ b/src/server/api/game-manager.ts
@@ -169,9 +169,7 @@ export class PuzzleGameManager extends GameManager {
                 this.chess.move(this.moves[this.moveNumber+1]);
                 this.moveNumber++;
             }
-            else{
-                
-            }
+            
             
 
         } else if (message instanceof GameInterruptedMessage) {

From cdc30394ad520bf9d10f5f0cf1314c6f9207c867 Mon Sep 17 00:00:00 2001
From: Leo Nguyen <LQNguyen05-max@users.noreply.github.com>
Date: Fri, 25 Oct 2024 19:58:47 -0500
Subject: [PATCH 03/27] fix object problems

---
 src/common/game-end-reasons.ts |  1 +
 src/server/api/api.ts          | 59 ++++++++++++++++++----------------
 src/server/api/game-manager.ts | 25 ++++++++------
 3 files changed, 49 insertions(+), 36 deletions(-)

diff --git a/src/common/game-end-reasons.ts b/src/common/game-end-reasons.ts
index f08de3a2..747bf311 100644
--- a/src/common/game-end-reasons.ts
+++ b/src/common/game-end-reasons.ts
@@ -15,6 +15,7 @@ export enum GameFinishedReason {
     FIFTY_MOVES = "fifty-moves",
     // chess.js doesn't support the following:
     // FIVEFOLD_REPETITION,
+    PUZZLE_SOLVED = "puzzle-solved",
 }
 
 /**
diff --git a/src/server/api/api.ts b/src/server/api/api.ts
index 66d07eb6..88328e1c 100644
--- a/src/server/api/api.ts
+++ b/src/server/api/api.ts
@@ -102,12 +102,12 @@ apiRouter.post("/start-human-game", (req, res) => {
 });
 
 apiRouter.post("/start-puzzle-game", (req, res) => {
-    const puzzle = req.query.puzzle as object;
-    console.log(puzzle);
-    const fen = "";
-    console.log(fen);
-    const moves = req.query.difficulty as string[];
-    const difficulty = parseInt(req.query.difficulty as string);
+    const puzzle = JSON.parse(req.query.puzzle as string) as PuzzleComponents;
+    console.log(puzzle.fen);
+    const fen = puzzle.fen;
+    console.log();
+    const moves = puzzle.moves;
+    const difficulty = puzzle.rating;
     gameManager = new PuzzleGameManager(
         new ChessEngine(),
         socketManager,
@@ -126,35 +126,40 @@ apiRouter.get("/get-ids", (_, res) => {
     return res.send({ ids });
 });
 
-export interface PuzzleComponents{
-    fen:string,
-    moves:string[],
-    rating:number
+export interface PuzzleComponents {
+    fen: string;
+    moves: string[];
+    rating: number;
 }
 /**
  * Returns a list of available puzzles to play.
  */
 apiRouter.get("/get-puzzles", (_, res) => {
-    const puzzles: Map<string, PuzzleComponents> = 
-    new Map([
-        ["Puzzle 1",
+    const puzzles: Map<string, PuzzleComponents> = new Map([
+        [
+            "Puzzle 1",
             {
-                fen:"8/1p3p1k/8/p1p2Kr1/P2pP3/1P1P4/2P5/8 w HAha - 0 1",
-                moves:["Kxg5"],
-                rating:511
-            }],
-        ["Puzzle 2",
+                fen: "8/1p3p1k/8/p1p2Kr1/P2pP3/1P1P4/2P5/8 w - - 0 1",
+                moves: ["Kxg5"],
+                rating: 511,
+            },
+        ],
+        [
+            "Puzzle 2",
             {
-                fen:"5rk1/p5pp/4q3/8/1P1P4/2P4P/P2p1RP1/5RK1 w HAha - 0 1",
-                moves:["Rxf8#"],
-                rating:514
-            }],
-        ["Puzzle 3",
+                fen: "5rk1/p5pp/4q3/8/1P1P4/2P4P/P2p1RP1/5RK1 w",
+                moves: ["Rxf8#"],
+                rating: 514,
+            },
+        ],
+        [
+            "Puzzle 3",
             {
-                fen:"8/3B4/2P2P2/1P1P1p2/3pP1p1/1pK5/2p4R/2k3r1 w HAha - 0 1",
-                moves:["Rb6+","d6","Rd6#"],
-                rating:1000
-            }],
+                fen: "8/3B4/2P2P2/1P1P1p2/3pP1p1/1pK5/2p4R/2k3r1 w - - 0 1",
+                moves: ["Rb6+", "d6", "Rd6#"],
+                rating: 1000,
+            },
+        ],
     ]);
     const obj: { [key: string]: PuzzleComponents } = {};
     puzzles.forEach((value, key) => {
diff --git a/src/server/api/game-manager.ts b/src/server/api/game-manager.ts
index 98c0badf..027eacfb 100644
--- a/src/server/api/game-manager.ts
+++ b/src/server/api/game-manager.ts
@@ -11,6 +11,7 @@ import { ClientType } from "../../common/client-types";
 import { Side, oppositeSide } from "../../common/game-types";
 import {
     GameEndReason,
+    GameFinishedReason,
     GameEndReason as GameInterruptedReason,
 } from "../../common/game-end-reasons";
 
@@ -148,13 +149,13 @@ export class ComputerGameManager extends GameManager {
 }
 
 export class PuzzleGameManager extends GameManager {
-    private moveNumber:number = 0;
+    private moveNumber: number = 0;
 
     constructor(
         chess: ChessEngine,
         socketManager: SocketManager,
         fen: string,
-        private moves:string[],
+        private moves: string[],
         protected difficulty: number,
     ) {
         super(chess, socketManager, Side.WHITE);
@@ -163,19 +164,25 @@ export class PuzzleGameManager extends GameManager {
 
     public handleMessage(message: Message, id: string): void {
         if (message instanceof MoveMessage) {
-            
-            if (this.moves[this.moveNumber]===message.move.to){
+            if (this.moves[this.moveNumber] === message.move.to) {
                 this.chess.makeMove(message.move);
-                this.chess.move(this.moves[this.moveNumber+1]);
+                this.chess.move(this.moves[this.moveNumber + 1]);
                 this.moveNumber++;
             }
-            
-            
-
         } else if (message instanceof GameInterruptedMessage) {
             this.gameInterruptedReason = message.reason;
             // Reflect end game reason back to client
             this.socketManager.sendToSocket(id, message);
         }
     }
-}
\ No newline at end of file
+
+    public isGameEnded(): boolean {
+        return this.moveNumber === this.moves.length || super.isGameEnded();
+    }
+
+    public getGameEndReason(): GameEndReason | undefined {
+        if (this.moveNumber === this.moves.length) {
+            return GameFinishedReason.PUZZLE_SOLVED;
+        }
+    }
+}

From 0ca599ef4775ad554b632c1febfa01880eb67fce Mon Sep 17 00:00:00 2001
From: ymmot239 <77180103+ymmot239@users.noreply.github.com>
Date: Fri, 25 Oct 2024 20:10:43 -0500
Subject: [PATCH 04/27] Added game ended message handler

For use with the puzzle framework
---
 src/common/message/game-message.ts | 17 ++++++++++++++++-
 src/common/message/message.ts      |  4 ++++
 src/server/api/game-manager.ts     | 14 ++++++++++++--
 3 files changed, 32 insertions(+), 3 deletions(-)

diff --git a/src/common/message/game-message.ts b/src/common/message/game-message.ts
index 65532e42..50b683cb 100644
--- a/src/common/message/game-message.ts
+++ b/src/common/message/game-message.ts
@@ -1,6 +1,6 @@
 import { Message, MessageType } from "./message";
 import { Move } from "../game-types";
-import { GameInterruptedReason, GameHoldReason } from "../game-end-reasons";
+import { GameInterruptedReason, GameHoldReason, GameEndReason } from "../game-end-reasons";
 
 export class PositionMessage extends Message {
     constructor(public readonly pgn: string) {
@@ -65,3 +65,18 @@ export class GameHoldMessage extends Message {
         };
     }
 }
+
+export class GameEndMessage extends Message {
+    constructor(public readonly reason: GameEndReason) {
+        super();
+    }
+
+    protected type = MessageType.GAME_ENDED;
+
+    protected toObj(): object {
+        return {
+            ...super.toObj(),
+            reason: this.reason,
+        };
+    }
+}
\ No newline at end of file
diff --git a/src/common/message/message.ts b/src/common/message/message.ts
index d4e4046c..d634f6f1 100644
--- a/src/common/message/message.ts
+++ b/src/common/message/message.ts
@@ -36,6 +36,10 @@ export enum MessageType {
      * Indicates the game is waiting for a user to respond
      */
     GAME_HELD = "game-held",
+    /**
+     * Indicates the game has ended
+     */
+    GAME_ENDED = "game-ended",
     /**
      * A client-server message containing instructions for manually driving a robot.
      */
diff --git a/src/server/api/game-manager.ts b/src/server/api/game-manager.ts
index e8b61804..a55f87ca 100644
--- a/src/server/api/game-manager.ts
+++ b/src/server/api/game-manager.ts
@@ -5,6 +5,7 @@ import {
     GameInterruptedMessage,
     GameStartedMessage,
     GameHoldMessage,
+    GameEndMessage,
 } from "../../common/message/game-message";
 import { SocketManager } from "./socket-manager";
 import { ClientManager } from "./client-manager";
@@ -215,7 +216,7 @@ export class PuzzleGameManager extends GameManager {
         private moves: string[],
         protected difficulty: number,
     ) {
-        super(chess, socketManager, Side.WHITE);
+        super(chess, socketManager, Side.WHITE, false);
         chess.load(fen);
     }
 
@@ -226,15 +227,24 @@ export class PuzzleGameManager extends GameManager {
                 this.chess.move(this.moves[this.moveNumber + 1]);
                 this.moveNumber++;
             }
+            if(this.isGameEnded()){
+                console.log("yay");
+                const gameEnd = this.getGameEndReason()
+                if(gameEnd){
+                    this.socketManager.sendToSocket(id, new GameEndMessage(gameEnd));
+                }
+            }
+
         } else if (message instanceof GameInterruptedMessage) {
             this.gameInterruptedReason = message.reason;
             // Reflect end game reason back to client
             this.socketManager.sendToSocket(id, message);
         }
+
     }
 
     public isGameEnded(): boolean {
-        return this.moveNumber === this.moves.length || super.isGameEnded();
+        return this.moveNumber === this.moves.length-1 || super.isGameEnded();
     }
 
     public getGameEndReason(): GameEndReason | undefined {

From e992406d3e5aefc12c04f793fa547c6482f164ea Mon Sep 17 00:00:00 2001
From: ymmot239 <77180103+ymmot239@users.noreply.github.com>
Date: Mon, 4 Nov 2024 16:18:11 -0600
Subject: [PATCH 05/27] Finished puzzle page

Added game ended, set chess, and puzzle solved messages for notifying client of puzzle progress.
Created a puzzles.json for saving puzzles in server.
---
 saves/puzzles                       |  0
 src/client/game/game-end-dialog.tsx |  8 +++--
 src/client/game/game.tsx            | 26 ++++++++++++++--
 src/client/puzzle/select-puzzle.tsx |  8 ++---
 src/common/chess-engine.ts          |  7 +++--
 src/common/message/game-message.ts  | 14 +++++++++
 src/common/message/message.ts       |  4 +++
 src/common/message/parse-message.ts |  6 ++++
 src/server/api/api.ts               | 46 +++++++----------------------
 src/server/api/game-manager.ts      | 34 +++++++++++++++------
 src/server/api/puzzles.json         | 21 +++++++++++++
 11 files changed, 117 insertions(+), 57 deletions(-)
 delete mode 100644 saves/puzzles
 create mode 100644 src/server/api/puzzles.json

diff --git a/saves/puzzles b/saves/puzzles
deleted file mode 100644
index e69de29b..00000000
diff --git a/src/client/game/game-end-dialog.tsx b/src/client/game/game-end-dialog.tsx
index 943acbff..4c24df39 100644
--- a/src/client/game/game-end-dialog.tsx
+++ b/src/client/game/game-end-dialog.tsx
@@ -56,10 +56,12 @@ export function GameEndDialog(props: GameEndDialogProps) {
 function gameOverIcon(reason: GameEndReason, side: Side) {
     const whiteWon =
         reason === GameFinishedReason.BLACK_CHECKMATED ||
-        reason === GameInterruptedReason.BLACK_RESIGNED;
+        reason === GameInterruptedReason.BLACK_RESIGNED ||
+        reason === GameFinishedReason.PUZZLE_SOLVED;
     const blackWon =
         reason === GameFinishedReason.WHITE_CHECKMATED ||
-        reason === GameInterruptedReason.WHITE_RESIGNED;
+        reason === GameInterruptedReason.WHITE_RESIGNED || 
+        reason === GameFinishedReason.PUZZLE_SOLVED;
 
     const won = side === Side.WHITE ? whiteWon : blackWon;
     const lost = side === Side.WHITE ? blackWon : whiteWon;
@@ -99,6 +101,8 @@ function gameOverMessage(reason: GameEndReason) {
             return "Checkmate - White Wins";
         case GameFinishedReason.STALEMATE:
             return "Draw - Stalemate";
+        case GameFinishedReason.PUZZLE_SOLVED:
+                return "Puzzle Solved";
         case GameFinishedReason.THREEFOLD_REPETITION:
             return "Draw - Threefold Repetition";
         case GameFinishedReason.INSUFFICIENT_MATERIAL:
diff --git a/src/client/game/game.tsx b/src/client/game/game.tsx
index fd6cd741..43471fdb 100644
--- a/src/client/game/game.tsx
+++ b/src/client/game/game.tsx
@@ -1,8 +1,10 @@
 import { Dispatch, useState } from "react";
 
 import {
+    GameEndMessage,
     GameHoldMessage,
     GameInterruptedMessage,
+    SetChessMessage,
 } from "../../common/message/game-message";
 import { MoveMessage } from "../../common/message/game-message";
 import {
@@ -29,14 +31,28 @@ function getMessageHandler(
     chess: ChessEngine,
     setChess: Dispatch<ChessEngine>,
     setGameInterruptedReason: Dispatch<GameInterruptedReason>,
+    setGameEndedReason: Dispatch<GameEndReason>,
     setGameHoldReason: Dispatch<GameHoldReason>,
 ): MessageHandler {
     return (message) => {
         if (message instanceof MoveMessage) {
             // Must be a new instance of ChessEngine to trigger UI redraw
-            setChess(chess.copy(message.move));
+            // short wait so the pieces don't teleport into place
+            setTimeout(()=>{
+                setChess(chess.copy(message.move));
+            }, 500)
+        } else if (message instanceof SetChessMessage) { 
+            const fen = message.chess
+            if(fen){
+                setTimeout(() => {
+                    chess.load(fen);
+                    setChess(chess.copy());
+                }, 500);
+            }
         } else if (message instanceof GameInterruptedMessage) {
             setGameInterruptedReason(message.reason);
+        } else if (message instanceof GameEndMessage) {
+            setGameEndedReason(message.reason);
         } else if (message instanceof GameHoldMessage) {
             setGameHoldReason(message.reason);
         }
@@ -47,6 +63,7 @@ export function Game(): JSX.Element {
     const [chess, setChess] = useState(new ChessEngine());
     const [gameInterruptedReason, setGameInterruptedReason] =
         useState<GameInterruptedReason>();
+    const [gameEndedReason, setGameEndedReason] = useState<GameEndReason>();
     const [gameHoldReason, setGameHoldReason] = useState<GameHoldReason>();
 
     const sendMessage = useSocket(
@@ -54,6 +71,7 @@ export function Game(): JSX.Element {
             chess,
             setChess,
             setGameInterruptedReason,
+            setGameEndedReason,
             setGameHoldReason,
         ),
     );
@@ -87,7 +105,10 @@ export function Game(): JSX.Element {
 
     let gameEndReason: GameEndReason | undefined = undefined;
     const gameFinishedReason = chess.getGameFinishedReason();
-    if (gameFinishedReason !== undefined) {
+    if (gameEndedReason !== undefined) {
+        gameEndReason = gameEndedReason;
+    }
+    else if (gameFinishedReason !== undefined) {
         gameEndReason = gameFinishedReason;
     } else if (gameInterruptedReason !== undefined) {
         gameEndReason = gameInterruptedReason;
@@ -97,7 +118,6 @@ export function Game(): JSX.Element {
         gameEndReason !== undefined ?
             <GameEndDialog reason={gameEndReason} side={side} />
         :   null;
-
     const gameOfferDialog =
         gameHoldReason !== undefined ?
             gameHoldReason === GameHoldReason.DRAW_CONFIRMATION ?
diff --git a/src/client/puzzle/select-puzzle.tsx b/src/client/puzzle/select-puzzle.tsx
index 80611a2f..bfbfabf9 100644
--- a/src/client/puzzle/select-puzzle.tsx
+++ b/src/client/puzzle/select-puzzle.tsx
@@ -38,12 +38,10 @@ export function SelectPuzzle(props: SelectPuzzleProps) {
             onClick={async () => {
                 if (props.selectedPuzzle && props.puzzles) {
                     //console.log(props.puzzles.get(props.selectedPuzzle));
-                    const puzz = props.puzzles as Map<string, object>;
-                    console.log(puzz[props.selectedPuzzle]);
+                    const puzzle = props.puzzles as Map<string, object>;
+                    //console.log(puzz[props.selectedPuzzle]);
                     const promise = post("/start-puzzle-game", {
-                        puzzle: JSON.stringify(
-                            puzz[props.selectedPuzzle],
-                        ),
+                        puzzle: JSON.stringify(puzzle[props.selectedPuzzle]),
                     });
                     promise.then(() => {
                         navigate("/game");
diff --git a/src/common/chess-engine.ts b/src/common/chess-engine.ts
index f15c7f9f..16db5a49 100644
--- a/src/common/chess-engine.ts
+++ b/src/common/chess-engine.ts
@@ -39,9 +39,10 @@ export class ChessEngine {
         return this.chess.pgn();
     }
 
-    undo(){
-        this.chess.undo();
-    }
+    undo(): Move{
+        const undo = this.chess.undo();
+        return {"from":undo?.from, "to":undo?.to} as Move;
+    }   
 
     load(fen: string){
         this.chess.load(fen);
diff --git a/src/common/message/game-message.ts b/src/common/message/game-message.ts
index 50b683cb..cedbbc70 100644
--- a/src/common/message/game-message.ts
+++ b/src/common/message/game-message.ts
@@ -28,6 +28,20 @@ export class MoveMessage extends Message {
         };
     }
 }
+export class SetChessMessage extends Message {
+    constructor(public readonly chess: string) {
+        super();
+    }
+
+    protected type = MessageType.SET_CHESS;
+
+    protected toObj(): object {
+        return {
+            ...super.toObj(),
+            chess: this.chess,
+        };
+    }
+}
 export class GameStartedMessage extends Message {
     constructor() {
         super();
diff --git a/src/common/message/message.ts b/src/common/message/message.ts
index d634f6f1..ddbf9c29 100644
--- a/src/common/message/message.ts
+++ b/src/common/message/message.ts
@@ -22,6 +22,10 @@ export enum MessageType {
      * A two-way message containing a single move.
      */
     MOVE = "move",
+    /**
+     * Sets the client chess engine
+     */
+    SET_CHESS = "set-chess",
     /**
      * A server-client message used to tell player two a game has started.
      */
diff --git a/src/common/message/parse-message.ts b/src/common/message/parse-message.ts
index 89a6bc93..c9292c12 100644
--- a/src/common/message/parse-message.ts
+++ b/src/common/message/parse-message.ts
@@ -6,6 +6,8 @@ import {
     GameInterruptedMessage,
     GameStartedMessage,
     GameHoldMessage,
+    GameEndMessage,
+    SetChessMessage,
 } from "./game-message";
 
 /**
@@ -26,10 +28,14 @@ export function parseMessage(text: string): Message {
             return new GameInterruptedMessage(obj.reason);
         case MessageType.GAME_HELD:
             return new GameHoldMessage(obj.reason);
+        case MessageType.GAME_ENDED:
+            return new GameEndMessage(obj.reason);
         case MessageType.POSITION:
             return new PositionMessage(obj.pgn);
         case MessageType.MOVE:
             return new MoveMessage(obj.move);
+        case MessageType.SET_CHESS:
+            return new SetChessMessage(obj.chess);
         case MessageType.DRIVE_ROBOT:
             return new DriveRobotMessage(
                 obj.id,
diff --git a/src/server/api/api.ts b/src/server/api/api.ts
index 4c52ec35..f1a6d2d7 100644
--- a/src/server/api/api.ts
+++ b/src/server/api/api.ts
@@ -3,9 +3,11 @@ import { Router } from "express";
 
 import { parseMessage } from "../../common/message/parse-message";
 import {
+    GameEndMessage,
     GameHoldMessage,
     GameInterruptedMessage,
     MoveMessage,
+    SetChessMessage,
 } from "../../common/message/game-message";
 import {
     DriveRobotMessage,
@@ -23,9 +25,10 @@ import {
     PuzzleGameManager,
 } from "./game-manager";
 import { ChessEngine } from "../../common/chess-engine";
-import { Side } from "../../common/game-types";
+import { Move, Side } from "../../common/game-types";
 import { IS_DEVELOPMENT } from "../utils/env";
 import { SaveManager } from "./save-manager";
+import { readFileSync } from "fs";
 
 export const tcpServer = new TCPServer();
 
@@ -50,7 +53,9 @@ export const websocketHandler: WebsocketRequestHandler = (ws, req) => {
         } else if (
             message instanceof GameInterruptedMessage ||
             message instanceof MoveMessage ||
-            message instanceof GameHoldMessage
+            message instanceof SetChessMessage ||
+            message instanceof GameHoldMessage ||
+            message instanceof GameEndMessage
         ) {
             // TODO: Handle game manager not existing
             gameManager?.handleMessage(message, req.cookies.id);
@@ -164,45 +169,16 @@ apiRouter.get("/get-ids", (_, res) => {
 
 export interface PuzzleComponents {
     fen: string;
-    moves: string[];
+    moves: Move[];
     rating: number;
 }
 /**
  * Returns a list of available puzzles to play.
  */
 apiRouter.get("/get-puzzles", (_, res) => {
-    const puzzles: Map<string, PuzzleComponents> = new Map([
-        [
-            "Puzzle 1",
-            {
-                fen: "8/1p3p1k/8/p1p2Kr1/P2pP3/1P1P4/2P5/8 w - - 0 1",
-                moves: ["Kxg5"],
-                rating: 511,
-            },
-        ],
-        [
-            "Puzzle 2",
-            {
-                fen: "5rk1/p5pp/4q3/8/1P1P4/2P4P/P2p1RP1/5RK1 w",
-                moves: ["Rxf8#"],
-                rating: 514,
-            },
-        ],
-        [
-            "Puzzle 3",
-            {
-                fen: "8/3B4/2P2P2/1P1P1p2/3pP1p1/1pK5/2p4R/2k3r1 w - - 0 1",
-                moves: ["Rb6+", "d6", "Rd6#"],
-                rating: 1000,
-            },
-        ],
-    ]);
-    const obj: { [key: string]: PuzzleComponents } = {};
-    puzzles.forEach((value, key) => {
-        obj[key] = value;
-    });
-    const a: string = JSON.stringify(obj);
-    return res.send(a);
+    const puzzles: Map<string, PuzzleComponents> = JSON.parse(readFileSync("./src/server/api/puzzles.json",'utf-8'));
+    const out: string = JSON.stringify(puzzles);
+    return res.send(out);
 });
 
 function doDriveRobot(message: DriveRobotMessage): boolean {
diff --git a/src/server/api/game-manager.ts b/src/server/api/game-manager.ts
index a55f87ca..fa744140 100644
--- a/src/server/api/game-manager.ts
+++ b/src/server/api/game-manager.ts
@@ -6,11 +6,12 @@ import {
     GameStartedMessage,
     GameHoldMessage,
     GameEndMessage,
+    SetChessMessage,
 } from "../../common/message/game-message";
 import { SocketManager } from "./socket-manager";
 import { ClientManager } from "./client-manager";
 import { ClientType } from "../../common/client-types";
-import { Side, oppositeSide } from "../../common/game-types";
+import { Move, Side, oppositeSide } from "../../common/game-types";
 import {
     GameEndReason,
     GameFinishedReason,
@@ -213,29 +214,43 @@ export class PuzzleGameManager extends GameManager {
         chess: ChessEngine,
         socketManager: SocketManager,
         fen: string,
-        private moves: string[],
+        private moves: Move[],
         protected difficulty: number,
     ) {
-        super(chess, socketManager, Side.WHITE, false);
+        super(chess, socketManager, fen.split(" ")[1]==="w"?Side.WHITE:Side.BLACK, false);
         chess.load(fen);
     }
 
     public handleMessage(message: Message, id: string): void {
         if (message instanceof MoveMessage) {
-            if (this.moves[this.moveNumber] === message.move.to) {
+
+            //if the move is correct
+            if (this.moves[this.moveNumber].from === message.move.from && this.moves[this.moveNumber].to === message.move.to) {
                 this.chess.makeMove(message.move);
-                this.chess.move(this.moves[this.moveNumber + 1]);
+                this.moveNumber++;
+
+                //if there is another move, make it
+                if(this.moves[this.moveNumber]){
+                    this.chess.makeMove(this.moves[this.moveNumber]);
+                    this.socketManager.sendToSocket(id, new MoveMessage(this.moves[this.moveNumber]));
+                }
                 this.moveNumber++;
             }
+
+            //send an undo message
+            else{
+                this.socketManager.sendToSocket(id,new SetChessMessage(this.chess.fen));
+            }
+
+            //send a finished message
             if(this.isGameEnded()){
-                console.log("yay");
                 const gameEnd = this.getGameEndReason()
                 if(gameEnd){
                     this.socketManager.sendToSocket(id, new GameEndMessage(gameEnd));
                 }
             }
 
-        } else if (message instanceof GameInterruptedMessage) {
+        } else if (message instanceof (GameInterruptedMessage || GameEndMessage)) {
             this.gameInterruptedReason = message.reason;
             // Reflect end game reason back to client
             this.socketManager.sendToSocket(id, message);
@@ -244,12 +259,13 @@ export class PuzzleGameManager extends GameManager {
     }
 
     public isGameEnded(): boolean {
-        return this.moveNumber === this.moves.length-1 || super.isGameEnded();
+        return this.moveNumber >= this.moves.length || super.isGameEnded();
     }
 
     public getGameEndReason(): GameEndReason | undefined {
-        if (this.moveNumber === this.moves.length) {
+        if (this.moveNumber >= this.moves.length) {
             return GameFinishedReason.PUZZLE_SOLVED;
         }
+        return super.getGameEndReason();
     }
 }
diff --git a/src/server/api/puzzles.json b/src/server/api/puzzles.json
new file mode 100644
index 00000000..959609bb
--- /dev/null
+++ b/src/server/api/puzzles.json
@@ -0,0 +1,21 @@
+{
+    "Puzzle 1": {
+        "fen": "8/1p3p1k/8/p1p2Kr1/P2pP3/1P1P4/2P5/8 w - - 0 1",
+        "moves": [{ "from": "f5", "to": "g5" }],
+        "rating": 511
+    },
+    "Puzzle 2": {
+        "fen": "5rk1/p5pp/4q3/8/1P1P4/2P4P/P2p1RP1/5RK1 w",
+        "moves": [{ "from": "f2", "to": "f8" }],
+        "rating": 514
+    },
+    "Puzzle 3": {
+        "fen": "1r3k2/R4p2/5Kp1/1p1Pp3/2p1PbP1/2P2P2/4B3/8 b - - 0 1",
+        "moves": [
+            { "from": "b8", "to": "b6" },
+            { "from": "d5", "to": "d6" },
+            { "from": "b6", "to": "d6" }
+        ],
+        "rating": 1000
+    }
+}

From 60651c9ff17e51f0963dee44cdc4175aab4b84bb Mon Sep 17 00:00:00 2001
From: ymmot239 <77180103+ymmot239@users.noreply.github.com>
Date: Mon, 4 Nov 2024 16:28:31 -0600
Subject: [PATCH 06/27] Puzzle cleanup

Removed extra puzzle files and print statements.
Added some comments for readability
Ran prettier
---
 src/client/game/game-end-dialog.tsx  |  4 +--
 src/client/game/game.tsx             | 13 ++++----
 src/client/puzzle/puzzle-manager.tsx | 14 ---------
 src/client/puzzle/puzzle.tsx         |  3 --
 src/client/puzzle/select-puzzle.tsx  |  3 +-
 src/client/puzzle/setup-puzzle.tsx   |  3 +-
 src/client/router.tsx                |  5 ----
 src/common/chess-engine.ts           | 11 ++++---
 src/common/game-end-reasons.ts       |  2 ++
 src/common/message/game-message.ts   |  8 +++--
 src/server/api/api.ts                | 10 ++++---
 src/server/api/game-manager.ts       | 44 +++++++++++++++++++---------
 12 files changed, 59 insertions(+), 61 deletions(-)
 delete mode 100644 src/client/puzzle/puzzle-manager.tsx
 delete mode 100644 src/client/puzzle/puzzle.tsx

diff --git a/src/client/game/game-end-dialog.tsx b/src/client/game/game-end-dialog.tsx
index 4c24df39..aa8f3976 100644
--- a/src/client/game/game-end-dialog.tsx
+++ b/src/client/game/game-end-dialog.tsx
@@ -60,7 +60,7 @@ function gameOverIcon(reason: GameEndReason, side: Side) {
         reason === GameFinishedReason.PUZZLE_SOLVED;
     const blackWon =
         reason === GameFinishedReason.WHITE_CHECKMATED ||
-        reason === GameInterruptedReason.WHITE_RESIGNED || 
+        reason === GameInterruptedReason.WHITE_RESIGNED ||
         reason === GameFinishedReason.PUZZLE_SOLVED;
 
     const won = side === Side.WHITE ? whiteWon : blackWon;
@@ -102,7 +102,7 @@ function gameOverMessage(reason: GameEndReason) {
         case GameFinishedReason.STALEMATE:
             return "Draw - Stalemate";
         case GameFinishedReason.PUZZLE_SOLVED:
-                return "Puzzle Solved";
+            return "Puzzle Solved";
         case GameFinishedReason.THREEFOLD_REPETITION:
             return "Draw - Threefold Repetition";
         case GameFinishedReason.INSUFFICIENT_MATERIAL:
diff --git a/src/client/game/game.tsx b/src/client/game/game.tsx
index 43471fdb..4539c978 100644
--- a/src/client/game/game.tsx
+++ b/src/client/game/game.tsx
@@ -38,12 +38,12 @@ function getMessageHandler(
         if (message instanceof MoveMessage) {
             // Must be a new instance of ChessEngine to trigger UI redraw
             // short wait so the pieces don't teleport into place
-            setTimeout(()=>{
+            setTimeout(() => {
                 setChess(chess.copy(message.move));
-            }, 500)
-        } else if (message instanceof SetChessMessage) { 
-            const fen = message.chess
-            if(fen){
+            }, 500);
+        } else if (message instanceof SetChessMessage) {
+            const fen = message.chess;
+            if (fen) {
                 setTimeout(() => {
                     chess.load(fen);
                     setChess(chess.copy());
@@ -107,8 +107,7 @@ export function Game(): JSX.Element {
     const gameFinishedReason = chess.getGameFinishedReason();
     if (gameEndedReason !== undefined) {
         gameEndReason = gameEndedReason;
-    }
-    else if (gameFinishedReason !== undefined) {
+    } else if (gameFinishedReason !== undefined) {
         gameEndReason = gameFinishedReason;
     } else if (gameInterruptedReason !== undefined) {
         gameEndReason = gameInterruptedReason;
diff --git a/src/client/puzzle/puzzle-manager.tsx b/src/client/puzzle/puzzle-manager.tsx
deleted file mode 100644
index 1283bf55..00000000
--- a/src/client/puzzle/puzzle-manager.tsx
+++ /dev/null
@@ -1,14 +0,0 @@
-
-/**
- * Class for managing saved puzzles and user completion status
- * 
- * Users are tracked by cookie id, though it doesn't save across devices and clients
- */
-export class PuzzleManager{
-    public static getAllPuzzles(){
-
-    }
-    public static getPuzzle(){
-
-    }
-}
\ No newline at end of file
diff --git a/src/client/puzzle/puzzle.tsx b/src/client/puzzle/puzzle.tsx
deleted file mode 100644
index 2e3dc381..00000000
--- a/src/client/puzzle/puzzle.tsx
+++ /dev/null
@@ -1,3 +0,0 @@
-export function Puzzle(): JSX.Element {
-    return <></>
-}
\ No newline at end of file
diff --git a/src/client/puzzle/select-puzzle.tsx b/src/client/puzzle/select-puzzle.tsx
index bfbfabf9..b4e922b3 100644
--- a/src/client/puzzle/select-puzzle.tsx
+++ b/src/client/puzzle/select-puzzle.tsx
@@ -37,9 +37,8 @@ export function SelectPuzzle(props: SelectPuzzleProps) {
             intent="primary"
             onClick={async () => {
                 if (props.selectedPuzzle && props.puzzles) {
-                    //console.log(props.puzzles.get(props.selectedPuzzle));
+                    //convert puzzle to map and send to start puzzles
                     const puzzle = props.puzzles as Map<string, object>;
-                    //console.log(puzz[props.selectedPuzzle]);
                     const promise = post("/start-puzzle-game", {
                         puzzle: JSON.stringify(puzzle[props.selectedPuzzle]),
                     });
diff --git a/src/client/puzzle/setup-puzzle.tsx b/src/client/puzzle/setup-puzzle.tsx
index 29a7255d..d4b5f72a 100644
--- a/src/client/puzzle/setup-puzzle.tsx
+++ b/src/client/puzzle/setup-puzzle.tsx
@@ -8,7 +8,7 @@ import { Navigate } from "react-router-dom";
 export function SetupPuzzle() {
     const [selectedPuzzle, setSelectedPuzzle] = useState<string | undefined>();
 
-    //const puzzles = get("/get-puzzles")
+    //get puzzles from api
     const { isPending, data, isError } = useEffectQuery(
         "get-puzzles",
         async () => {
@@ -30,7 +30,6 @@ export function SetupPuzzle() {
         return <Navigate to="/home" />;
     }
 
-    
     if (data === undefined) {
         return <Spinner intent="primary" />;
     } else {
diff --git a/src/client/router.tsx b/src/client/router.tsx
index 145f65f8..23def9ff 100644
--- a/src/client/router.tsx
+++ b/src/client/router.tsx
@@ -2,7 +2,6 @@ import { createBrowserRouter } from "react-router-dom";
 import { Setup } from "./setup/setup";
 import { Debug } from "./debug/debug";
 import { Game } from "./game/game";
-import { Puzzle } from "./puzzle/puzzle";
 import { Lobby } from "./setup/lobby";
 import { Home } from "./home";
 
@@ -23,10 +22,6 @@ export const router = createBrowserRouter([
         path: "/lobby",
         element: <Lobby />,
     },
-    {
-        path: "/puzzle",
-        element: <Puzzle />,
-    },
     {
         path: "/game",
         element: <Game />,
diff --git a/src/common/chess-engine.ts b/src/common/chess-engine.ts
index 16db5a49..e924dd8a 100644
--- a/src/common/chess-engine.ts
+++ b/src/common/chess-engine.ts
@@ -15,7 +15,6 @@ export class ChessEngine {
         if (pgn !== undefined) {
             this.chess.loadPgn(pgn);
         }
-        
     }
 
     /**
@@ -39,12 +38,12 @@ export class ChessEngine {
         return this.chess.pgn();
     }
 
-    undo(): Move{
+    undo(): Move {
         const undo = this.chess.undo();
-        return {"from":undo?.from, "to":undo?.to} as Move;
-    }   
+        return { from: undo?.from, to: undo?.to } as Move;
+    }
 
-    load(fen: string){
+    load(fen: string) {
         this.chess.load(fen);
     }
 
@@ -178,7 +177,7 @@ export class ChessEngine {
      * Makes a move on the chessboard.
      * @returns the move that was made.
      */
-    move(move:string):string{
+    move(move: string): string {
         this.chess.move(move);
         return move;
     }
diff --git a/src/common/game-end-reasons.ts b/src/common/game-end-reasons.ts
index fd8c47da..fb5b4d1e 100644
--- a/src/common/game-end-reasons.ts
+++ b/src/common/game-end-reasons.ts
@@ -15,6 +15,8 @@ export enum GameFinishedReason {
     FIFTY_MOVES = "fifty-moves",
     // chess.js doesn't support the following:
     // FIVEFOLD_REPETITION,
+
+    /** Client solved a puzzle */
     PUZZLE_SOLVED = "puzzle-solved",
 }
 
diff --git a/src/common/message/game-message.ts b/src/common/message/game-message.ts
index cedbbc70..97aa50a7 100644
--- a/src/common/message/game-message.ts
+++ b/src/common/message/game-message.ts
@@ -1,6 +1,10 @@
 import { Message, MessageType } from "./message";
 import { Move } from "../game-types";
-import { GameInterruptedReason, GameHoldReason, GameEndReason } from "../game-end-reasons";
+import {
+    GameInterruptedReason,
+    GameHoldReason,
+    GameEndReason,
+} from "../game-end-reasons";
 
 export class PositionMessage extends Message {
     constructor(public readonly pgn: string) {
@@ -93,4 +97,4 @@ export class GameEndMessage extends Message {
             reason: this.reason,
         };
     }
-}
\ No newline at end of file
+}
diff --git a/src/server/api/api.ts b/src/server/api/api.ts
index f1a6d2d7..03939726 100644
--- a/src/server/api/api.ts
+++ b/src/server/api/api.ts
@@ -143,12 +143,12 @@ apiRouter.post("/start-human-game", (req, res) => {
 });
 
 apiRouter.post("/start-puzzle-game", (req, res) => {
+    //get puzzle components
     const puzzle = JSON.parse(req.query.puzzle as string) as PuzzleComponents;
-    console.log(puzzle.fen);
     const fen = puzzle.fen;
-    console.log();
     const moves = puzzle.moves;
     const difficulty = puzzle.rating;
+    //create game manager
     gameManager = new PuzzleGameManager(
         new ChessEngine(),
         socketManager,
@@ -173,10 +173,12 @@ export interface PuzzleComponents {
     rating: number;
 }
 /**
- * Returns a list of available puzzles to play.
+ * Returns a list of available puzzles to play from puzzles.json.
  */
 apiRouter.get("/get-puzzles", (_, res) => {
-    const puzzles: Map<string, PuzzleComponents> = JSON.parse(readFileSync("./src/server/api/puzzles.json",'utf-8'));
+    const puzzles: Map<string, PuzzleComponents> = JSON.parse(
+        readFileSync("./src/server/api/puzzles.json", "utf-8"),
+    );
     const out: string = JSON.stringify(puzzles);
     return res.send(out);
 });
diff --git a/src/server/api/game-manager.ts b/src/server/api/game-manager.ts
index fa744140..c4b81966 100644
--- a/src/server/api/game-manager.ts
+++ b/src/server/api/game-manager.ts
@@ -217,45 +217,61 @@ export class PuzzleGameManager extends GameManager {
         private moves: Move[],
         protected difficulty: number,
     ) {
-        super(chess, socketManager, fen.split(" ")[1]==="w"?Side.WHITE:Side.BLACK, false);
+        super(
+            chess,
+            socketManager,
+            fen.split(" ")[1] === "w" ? Side.WHITE : Side.BLACK,
+            false,
+        );
         chess.load(fen);
     }
 
     public handleMessage(message: Message, id: string): void {
         if (message instanceof MoveMessage) {
-
             //if the move is correct
-            if (this.moves[this.moveNumber].from === message.move.from && this.moves[this.moveNumber].to === message.move.to) {
+            if (
+                this.moves[this.moveNumber].from === message.move.from &&
+                this.moves[this.moveNumber].to === message.move.to
+            ) {
                 this.chess.makeMove(message.move);
                 this.moveNumber++;
 
                 //if there is another move, make it
-                if(this.moves[this.moveNumber]){
+                if (this.moves[this.moveNumber]) {
                     this.chess.makeMove(this.moves[this.moveNumber]);
-                    this.socketManager.sendToSocket(id, new MoveMessage(this.moves[this.moveNumber]));
+                    this.socketManager.sendToSocket(
+                        id,
+                        new MoveMessage(this.moves[this.moveNumber]),
+                    );
                 }
                 this.moveNumber++;
             }
 
             //send an undo message
-            else{
-                this.socketManager.sendToSocket(id,new SetChessMessage(this.chess.fen));
+            else {
+                this.socketManager.sendToSocket(
+                    id,
+                    new SetChessMessage(this.chess.fen),
+                );
             }
 
             //send a finished message
-            if(this.isGameEnded()){
-                const gameEnd = this.getGameEndReason()
-                if(gameEnd){
-                    this.socketManager.sendToSocket(id, new GameEndMessage(gameEnd));
+            if (this.isGameEnded()) {
+                const gameEnd = this.getGameEndReason();
+                if (gameEnd) {
+                    this.socketManager.sendToSocket(
+                        id,
+                        new GameEndMessage(gameEnd),
+                    );
                 }
             }
-
-        } else if (message instanceof (GameInterruptedMessage || GameEndMessage)) {
+        } else if (
+            message instanceof (GameInterruptedMessage || GameEndMessage)
+        ) {
             this.gameInterruptedReason = message.reason;
             // Reflect end game reason back to client
             this.socketManager.sendToSocket(id, message);
         }
-
     }
 
     public isGameEnded(): boolean {

From f2cf906f33323b54052befbd21c37ef4329a7d49 Mon Sep 17 00:00:00 2001
From: ymmot239 <77180103+ymmot239@users.noreply.github.com>
Date: Mon, 4 Nov 2024 18:57:51 -0600
Subject: [PATCH 07/27] added ratings

Added the puzzle difficulty rating to the nav bar for reference.
---
 src/client/game/game.tsx        | 2 +-
 src/client/game/navbar-menu.tsx | 2 ++
 src/server/api/game-manager.ts  | 9 +++++++++
 3 files changed, 12 insertions(+), 1 deletion(-)

diff --git a/src/client/game/game.tsx b/src/client/game/game.tsx
index 4539c978..07320ece 100644
--- a/src/client/game/game.tsx
+++ b/src/client/game/game.tsx
@@ -138,7 +138,7 @@ export function Game(): JSX.Element {
 
     return (
         <>
-            <NavbarMenu sendMessage={sendMessage} side={side} />
+            <NavbarMenu sendMessage={sendMessage} side={side} difficulty={data.difficulty}/>
             <div id="body-container">
                 <ChessboardWrapper
                     side={side}
diff --git a/src/client/game/navbar-menu.tsx b/src/client/game/navbar-menu.tsx
index 083563b0..8ade4677 100644
--- a/src/client/game/navbar-menu.tsx
+++ b/src/client/game/navbar-menu.tsx
@@ -20,6 +20,7 @@ import { Side } from "../../common/game-types";
 interface NavbarMenuProps {
     sendMessage: SendMessage;
     side: Side;
+    difficulty?:number;
 }
 
 export function NavbarMenu(props: NavbarMenuProps): JSX.Element {
@@ -60,6 +61,7 @@ export function NavbarMenu(props: NavbarMenuProps): JSX.Element {
                 />
             </NavbarGroup>
             <NavbarGroup align="right">
+                <Button minimal disabled text = {"rating: "+ props.difficulty} />
                 <Button icon="cog" minimal onClick={() => navigate("/debug")} />
             </NavbarGroup>
         </Navbar>
diff --git a/src/server/api/game-manager.ts b/src/server/api/game-manager.ts
index c4b81966..69f4cf43 100644
--- a/src/server/api/game-manager.ts
+++ b/src/server/api/game-manager.ts
@@ -226,6 +226,10 @@ export class PuzzleGameManager extends GameManager {
         chess.load(fen);
     }
 
+    public getDifficulty():number{
+        return this.difficulty;
+    }
+
     public handleMessage(message: Message, id: string): void {
         if (message instanceof MoveMessage) {
             //if the move is correct
@@ -284,4 +288,9 @@ export class PuzzleGameManager extends GameManager {
         }
         return super.getGameEndReason();
     }
+    
+    public getGameState(clientType: ClientType): object {
+
+        return {...super.getGameState(clientType), difficulty:this.difficulty};
+    }
 }

From 8207d239e921c776f467ca18ffc51b74de886b96 Mon Sep 17 00:00:00 2001
From: ymmot239 <77180103+ymmot239@users.noreply.github.com>
Date: Mon, 4 Nov 2024 19:00:03 -0600
Subject: [PATCH 08/27] readability changes

ran prettier
---
 src/client/game/game.tsx        |  6 +++++-
 src/client/game/navbar-menu.tsx |  4 ++--
 src/server/api/game-manager.ts  | 10 ++++++----
 3 files changed, 13 insertions(+), 7 deletions(-)

diff --git a/src/client/game/game.tsx b/src/client/game/game.tsx
index 07320ece..bfd2634b 100644
--- a/src/client/game/game.tsx
+++ b/src/client/game/game.tsx
@@ -138,7 +138,11 @@ export function Game(): JSX.Element {
 
     return (
         <>
-            <NavbarMenu sendMessage={sendMessage} side={side} difficulty={data.difficulty}/>
+            <NavbarMenu
+                sendMessage={sendMessage}
+                side={side}
+                difficulty={data.difficulty}
+            />
             <div id="body-container">
                 <ChessboardWrapper
                     side={side}
diff --git a/src/client/game/navbar-menu.tsx b/src/client/game/navbar-menu.tsx
index 8ade4677..abb1d2c9 100644
--- a/src/client/game/navbar-menu.tsx
+++ b/src/client/game/navbar-menu.tsx
@@ -20,7 +20,7 @@ import { Side } from "../../common/game-types";
 interface NavbarMenuProps {
     sendMessage: SendMessage;
     side: Side;
-    difficulty?:number;
+    difficulty?: number;
 }
 
 export function NavbarMenu(props: NavbarMenuProps): JSX.Element {
@@ -61,7 +61,7 @@ export function NavbarMenu(props: NavbarMenuProps): JSX.Element {
                 />
             </NavbarGroup>
             <NavbarGroup align="right">
-                <Button minimal disabled text = {"rating: "+ props.difficulty} />
+                <Button minimal disabled text={"rating: " + props.difficulty} />
                 <Button icon="cog" minimal onClick={() => navigate("/debug")} />
             </NavbarGroup>
         </Navbar>
diff --git a/src/server/api/game-manager.ts b/src/server/api/game-manager.ts
index 69f4cf43..26719c60 100644
--- a/src/server/api/game-manager.ts
+++ b/src/server/api/game-manager.ts
@@ -226,7 +226,7 @@ export class PuzzleGameManager extends GameManager {
         chess.load(fen);
     }
 
-    public getDifficulty():number{
+    public getDifficulty(): number {
         return this.difficulty;
     }
 
@@ -288,9 +288,11 @@ export class PuzzleGameManager extends GameManager {
         }
         return super.getGameEndReason();
     }
-    
-    public getGameState(clientType: ClientType): object {
 
-        return {...super.getGameState(clientType), difficulty:this.difficulty};
+    public getGameState(clientType: ClientType): object {
+        return {
+            ...super.getGameState(clientType),
+            difficulty: this.difficulty,
+        };
     }
 }

From d41f7b9095f755ed18855d51bd43b82a131bd3fa Mon Sep 17 00:00:00 2001
From: ymmot239 <77180103+ymmot239@users.noreply.github.com>
Date: Mon, 4 Nov 2024 19:08:56 -0600
Subject: [PATCH 09/27] navbar fix

made the difficulty rating only appear during puzzle games, and null for others.
---
 src/client/game/navbar-menu.tsx | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/client/game/navbar-menu.tsx b/src/client/game/navbar-menu.tsx
index abb1d2c9..0dc1913b 100644
--- a/src/client/game/navbar-menu.tsx
+++ b/src/client/game/navbar-menu.tsx
@@ -26,6 +26,10 @@ interface NavbarMenuProps {
 export function NavbarMenu(props: NavbarMenuProps): JSX.Element {
     // Store react router state for game
     const navigate = useNavigate();
+    const difficultyButton =
+        props.difficulty ?
+            <Button minimal disabled text={"rating: " + props.difficulty} />
+        :   null;
     return (
         <Navbar>
             <NavbarGroup>
@@ -61,7 +65,7 @@ export function NavbarMenu(props: NavbarMenuProps): JSX.Element {
                 />
             </NavbarGroup>
             <NavbarGroup align="right">
-                <Button minimal disabled text={"rating: " + props.difficulty} />
+                {difficultyButton}
                 <Button icon="cog" minimal onClick={() => navigate("/debug")} />
             </NavbarGroup>
         </Navbar>

From 27bba3d0aa84cd2ddc83534b97cb4fe246b6dccd Mon Sep 17 00:00:00 2001
From: ymmot239 <77180103+ymmot239@users.noreply.github.com>
Date: Mon, 4 Nov 2024 19:29:26 -0600
Subject: [PATCH 10/27] Update puzzles.json

added a 2915 rated 7 step puzzle
---
 src/server/api/puzzles.json | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/src/server/api/puzzles.json b/src/server/api/puzzles.json
index 959609bb..d35463e1 100644
--- a/src/server/api/puzzles.json
+++ b/src/server/api/puzzles.json
@@ -17,5 +17,18 @@
             { "from": "b6", "to": "d6" }
         ],
         "rating": 1000
+    },
+    "Puzzle 4": {
+        "fen": "r1b3k1/1pq1b1r1/p2p3Q/3Pp3/3p1P2/P2B3P/1PP3P1/1R3RK1 w - - 0 1",
+        "moves": [
+            { "from": "f4", "to": "e5" },
+            { "from": "d6", "to": "e5" },
+            { "from": "d5", "to": "d6" },
+            { "from": "c7", "to": "c6" },
+            { "from": "f1", "to": "f3" },
+            { "from": "c6", "to": "f3" },
+            { "from": "d3", "to": "c4" }
+        ],
+        "rating": 2915
     }
 }

From c9e472822506b919f4f089f6f81502c0870ea3ba Mon Sep 17 00:00:00 2001
From: ymmot239 <77180103+ymmot239@users.noreply.github.com>
Date: Mon, 4 Nov 2024 20:14:21 -0600
Subject: [PATCH 11/27] Update setup-base.tsx

rotation hotfix
---
 src/client/setup/setup-base.tsx | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/client/setup/setup-base.tsx b/src/client/setup/setup-base.tsx
index c424f7a6..95923558 100644
--- a/src/client/setup/setup-base.tsx
+++ b/src/client/setup/setup-base.tsx
@@ -17,6 +17,7 @@ export function SetupBase(props: SetupBaseProps): JSX.Element {
                 chess={new ChessEngine()}
                 side={Side.WHITE}
                 onMove={() => {}}
+                rotation={0}
             />
             <Dialog
                 isOpen

From 5191b5f0f1dddfad3859138d5fc9f8d0922e53c2 Mon Sep 17 00:00:00 2001
From: ymmot239 <77180103+ymmot239@users.noreply.github.com>
Date: Fri, 8 Nov 2024 18:37:18 -0600
Subject: [PATCH 12/27] fixed merge mistakes

Messed up importing in apis
Added back simulator and puzzle messages.
---
 src/server/api/api.ts | 43 ++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 42 insertions(+), 1 deletion(-)

diff --git a/src/server/api/api.ts b/src/server/api/api.ts
index d58903c6..907cecf9 100644
--- a/src/server/api/api.ts
+++ b/src/server/api/api.ts
@@ -170,8 +170,49 @@ apiRouter.get("/get-ids", (_, res) => {
     return res.send({ ids });
 });
 
+apiRouter.get("/do-smth", async (_, res) => {
+    const robotsEntries = Array.from(virtualRobots.entries());
+    const [, robot] =
+        robotsEntries[Math.floor(Math.random() * robotsEntries.length)];
+    await robot.sendDrivePacket(1);
+    await robot.sendTurnPacket(45 * DEGREE);
+
+    res.send({ message: "success" });
+});
+
+apiRouter.get("/get-simulator-robot-state", (_, res) => {
+    if (!USE_VIRTUAL_ROBOTS) {
+        return res.status(400).send({ message: "Simulator is not enabled." });
+    }
+    const robotsEntries = Array.from(virtualRobots.entries());
+
+    const robotState = Object.fromEntries(
+        robotsEntries.map(([id, robot]) => {
+            let headingRadians = robot.headingRadians;
+            let position = new Position(robot.position.x, robot.position.y);
+
+            const tunnel = robot.getTunnel();
+            if (tunnel instanceof VirtualBotTunnel) {
+                position = tunnel.position;
+                headingRadians = tunnel.headingRadians;
+            }
+            return [id, { position, headingRadians: headingRadians }];
+        }),
+    );
+    return res.send({
+        robotState,
+        messages: Array.from(VirtualBotTunnel.messages),
+    });
+});
+
+export interface PuzzleComponents {
+    fen: string;
+    moves: Move[];
+    rating: number;
+}
+
 /**
- * Returns a list of available puzzles to play.
+ * Returns a list of available puzzles to play from puzzles.json.
  */
 apiRouter.get("/get-puzzles", (_, res) => {
     const puzzles: Map<string, PuzzleComponents> = JSON.parse(

From f21eb5447c52717045235e5c7f69027c353496f7 Mon Sep 17 00:00:00 2001
From: ymmot239 <77180103+ymmot239@users.noreply.github.com>
Date: Fri, 8 Nov 2024 20:45:09 -0600
Subject: [PATCH 13/27] Added spectator support

Added support for spectators to view puzzle and Ai games.
This required a 1 second delay, so the games feel a bit weird, but they work.
Without it, the spectators would error because they had too many move commands at once.
---
 src/client/game/game.tsx        |  4 +-
 src/client/game/navbar-menu.tsx | 80 ++++++++++++++++++++-------------
 src/client/setup/setup.tsx      |  6 +--
 src/common/chess-engine.ts      |  2 +
 src/server/api/game-manager.ts  | 58 ++++++++++++++++++------
 5 files changed, 101 insertions(+), 49 deletions(-)

diff --git a/src/client/game/game.tsx b/src/client/game/game.tsx
index f5a91750..31da9b3a 100644
--- a/src/client/game/game.tsx
+++ b/src/client/game/game.tsx
@@ -142,12 +142,10 @@ export function Game(): JSX.Element {
     return (
         <>
             <NavbarMenu
-               
                 sendMessage={sendMessage}
-               
                 side={side}
                 difficulty={data.difficulty}
-           
+                AiDifficulty={data.AiDifficulty}
                 setRotation={setRotation}
             />
             <div id="body-container">
diff --git a/src/client/game/navbar-menu.tsx b/src/client/game/navbar-menu.tsx
index e9a41cde..c6cec138 100644
--- a/src/client/game/navbar-menu.tsx
+++ b/src/client/game/navbar-menu.tsx
@@ -21,7 +21,8 @@ import { Dispatch } from "react";
 interface NavbarMenuProps {
     sendMessage: SendMessage;
     side: Side;
-    difficulty?: number;
+    difficulty?: string;
+    AiDifficulty?: number;
     setRotation: Dispatch<React.SetStateAction<number>>; //set state type
 }
 
@@ -33,6 +34,16 @@ export function NavbarMenu(props: NavbarMenuProps): JSX.Element {
             <Button minimal disabled text={"rating: " + props.difficulty} />
         :   null;
 
+    const AiArray = ["Baby", "Beginner", "Intermediate", "Advances"];
+    const AiDifficultyButton =
+        props.AiDifficulty ?
+            <Button
+                minimal
+                disabled
+                text={"AI Difficulty: " + AiArray[props.AiDifficulty]}
+            />
+        :   null;
+
     /** create navbar rotate button */
     const rotateButton =
         props.side === Side.SPECTATOR ?
@@ -46,44 +57,53 @@ export function NavbarMenu(props: NavbarMenuProps): JSX.Element {
                     });
                 }}
             />
-        :   "";
+        :   undefined;
+
+    const resignButton =
+        props.side === Side.SPECTATOR ?
+            undefined
+        :   <Button
+                icon="flag"
+                minimal
+                text="Resign"
+                intent="danger"
+                onClick={async () => {
+                    props.sendMessage(
+                        new GameInterruptedMessage(
+                            props.side === Side.WHITE ?
+                                GameInterruptedReason.WHITE_RESIGNED
+                            :   GameInterruptedReason.BLACK_RESIGNED,
+                        ),
+                    );
+                }}
+            />;
+
+    const drawButton =
+        props.side === Side.SPECTATOR ?
+            undefined
+        :   <Button
+                icon="pause"
+                minimal
+                text="Draw"
+                intent="danger"
+                onClick={async () => {
+                    props.sendMessage(
+                        new GameHoldMessage(GameHoldReason.DRAW_CONFIRMATION),
+                    );
+                }}
+            />;
 
     return (
         <Navbar>
             <NavbarGroup>
                 <NavbarHeading>ChessBot</NavbarHeading>
                 <NavbarDivider />
-                <Button
-                    icon="flag"
-                    minimal
-                    text="Resign"
-                    intent="danger"
-                    onClick={async () => {
-                        props.sendMessage(
-                            new GameInterruptedMessage(
-                                props.side === Side.WHITE ?
-                                    GameInterruptedReason.WHITE_RESIGNED
-                                :   GameInterruptedReason.BLACK_RESIGNED,
-                            ),
-                        );
-                    }}
-                />
-                <Button
-                    icon="pause"
-                    minimal
-                    text="Draw"
-                    intent="danger"
-                    onClick={async () => {
-                        props.sendMessage(
-                            new GameHoldMessage(
-                                GameHoldReason.DRAW_CONFIRMATION,
-                            ),
-                        );
-                    }}
-                />
+                {resignButton}
+                {drawButton}
             </NavbarGroup>
             <NavbarGroup align="right">
                 {difficultyButton}
+                {AiDifficultyButton}
                 {rotateButton}
                 <h3>{props.side}</h3>
                 <Button icon="cog" minimal onClick={() => navigate("/debug")} />
diff --git a/src/client/setup/setup.tsx b/src/client/setup/setup.tsx
index a3567a07..879e60e0 100644
--- a/src/client/setup/setup.tsx
+++ b/src/client/setup/setup.tsx
@@ -50,9 +50,9 @@ export function Setup(): JSX.Element {
                     />
                 :   null}
                 {setupType === SetupType.PUZZLE ?
-                <SetupPuzzle />
-            :   null}
-        </SetupBase>
+                    <SetupPuzzle />
+                :   null}
+            </SetupBase>
         );
     } else {
         return <Navigate to="/lobby" />;
diff --git a/src/common/chess-engine.ts b/src/common/chess-engine.ts
index e924dd8a..a388b048 100644
--- a/src/common/chess-engine.ts
+++ b/src/common/chess-engine.ts
@@ -169,6 +169,8 @@ export class ChessEngine {
      * @returns the move that was made.
      */
     makeMove(move: Move): Move {
+        //const yay = this.chess.history[this.chess.history.length-1];
+        //if(yay!==undefined && !(move.from === yay.from || move.to === yay.to))
         this.chess.move(move);
         return move;
     }
diff --git a/src/server/api/game-manager.ts b/src/server/api/game-manager.ts
index cd8f3f23..b53a51d6 100644
--- a/src/server/api/game-manager.ts
+++ b/src/server/api/game-manager.ts
@@ -34,7 +34,9 @@ export abstract class GameManager {
         protected hostSide: Side,
         //true if host and client get reversed
         protected reverse: boolean,
-    ) {}
+    ) {
+        socketManager.sendToAll(new GameStartedMessage());
+    }
 
     public isGameEnded(): boolean {
         return (
@@ -83,8 +85,8 @@ export class HumanGameManager extends GameManager {
     ) {
         super(chess, socketManager, hostSide, reverse);
         // Notify other client the game has started
-        clientManager.sendToClient(new GameStartedMessage());
-        clientManager.sendToSpectators(new GameStartedMessage());
+        //clientManager.sendToClient(new GameStartedMessage());
+        //clientManager.sendToSpectators(new GameStartedMessage());
     }
 
     public handleMessage(message: Message, id: string): void {
@@ -176,7 +178,7 @@ export class HumanGameManager extends GameManager {
 
 export class ComputerGameManager extends GameManager {
     // The minimum amount of time to wait responding with a move.
-    MINIMUM_DELAY = 500;
+    MINIMUM_DELAY = 600;
 
     constructor(
         chess: ChessEngine,
@@ -195,7 +197,9 @@ export class ComputerGameManager extends GameManager {
 
     public handleMessage(message: Message, id: string): void {
         if (message instanceof MoveMessage) {
+            this.socketManager.sendToAll(new MoveMessage(message.move));
             this.chess.makeMove(message.move);
+
             SaveManager.saveGame(
                 id,
                 "ai",
@@ -215,8 +219,10 @@ export class ComputerGameManager extends GameManager {
             const move = this.chess.makeAiMove(this.difficulty);
             const elapsedTime = Date.now() - startTime;
             // If elapsed time is less than minimum delay, timeout is set to 1ms
+            new MoveMessage(move);
             setTimeout(() => {
-                this.socketManager.sendToSocket(id, new MoveMessage(move));
+                //this.socketManager.sendToSocket(id, new MoveMessage(move));
+                this.socketManager.sendToAll(new MoveMessage(move));
             }, this.MINIMUM_DELAY - elapsedTime);
             if (this.isGameEnded()) {
                 SaveManager.endGame(id, "ai");
@@ -225,13 +231,22 @@ export class ComputerGameManager extends GameManager {
             this.gameInterruptedReason = message.reason;
             SaveManager.endGame(id, "ai");
             // Reflect end game reason back to client
-            this.socketManager.sendToSocket(id, message);
+            //this.socketManager.sendToSocket(id, message);
+            this.socketManager.sendToAll(message);
         }
     }
+
+    public getGameState(clientType: ClientType): object {
+        return {
+            ...super.getGameState(clientType),
+            AiDifficulty: this.difficulty,
+        };
+    }
 }
 
 export class PuzzleGameManager extends GameManager {
     private moveNumber: number = 0;
+    MINIMUM_DELAY = 600;
 
     constructor(
         chess: ChessEngine,
@@ -253,32 +268,47 @@ export class PuzzleGameManager extends GameManager {
         return this.difficulty;
     }
 
-    public handleMessage(message: Message, id: string): void {
+    public handleMessage(message: Message): void {
         if (message instanceof MoveMessage) {
             //if the move is correct
             if (
                 this.moves[this.moveNumber].from === message.move.from &&
                 this.moves[this.moveNumber].to === message.move.to
             ) {
+                this.socketManager.sendToAll(new MoveMessage(message.move));
                 this.chess.makeMove(message.move);
                 this.moveNumber++;
-
                 //if there is another move, make it
                 if (this.moves[this.moveNumber]) {
                     this.chess.makeMove(this.moves[this.moveNumber]);
+                    
+                    /*
                     this.socketManager.sendToSocket(
                         id,
                         new MoveMessage(this.moves[this.moveNumber]),
-                    );
+                    );*/
+                    setTimeout(()=>{
+                        this.socketManager.sendToAll(
+                            new MoveMessage(this.moves[this.moveNumber]),
+                        );
+                        this.moveNumber++;
+                    },this.MINIMUM_DELAY)
+                    
+                }
+                else{
+                    this.moveNumber++;
                 }
-                this.moveNumber++;
             }
 
             //send an undo message
             else {
+                /*
                 this.socketManager.sendToSocket(
                     id,
                     new SetChessMessage(this.chess.fen),
+                );*/
+                this.socketManager.sendToAll(
+                    new SetChessMessage(this.chess.fen),
                 );
             }
 
@@ -286,10 +316,11 @@ export class PuzzleGameManager extends GameManager {
             if (this.isGameEnded()) {
                 const gameEnd = this.getGameEndReason();
                 if (gameEnd) {
-                    this.socketManager.sendToSocket(
+                    /*this.socketManager.sendToSocket(
                         id,
                         new GameEndMessage(gameEnd),
-                    );
+                    );*/
+                    this.socketManager.sendToAll(new GameEndMessage(gameEnd));
                 }
             }
         } else if (
@@ -297,7 +328,8 @@ export class PuzzleGameManager extends GameManager {
         ) {
             this.gameInterruptedReason = message.reason;
             // Reflect end game reason back to client
-            this.socketManager.sendToSocket(id, message);
+            //this.socketManager.sendToSocket(id, message);
+            this.socketManager.sendToAll(message);
         }
     }
 

From 5f286a8798382d522c99205ae7b570b6ca67ad34 Mon Sep 17 00:00:00 2001
From: ymmot239 <77180103+ymmot239@users.noreply.github.com>
Date: Mon, 11 Nov 2024 18:13:49 -0600
Subject: [PATCH 14/27] Update game-manager.ts

prettier
---
 src/server/api/game-manager.ts | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/src/server/api/game-manager.ts b/src/server/api/game-manager.ts
index b53a51d6..8c7e6d22 100644
--- a/src/server/api/game-manager.ts
+++ b/src/server/api/game-manager.ts
@@ -281,21 +281,19 @@ export class PuzzleGameManager extends GameManager {
                 //if there is another move, make it
                 if (this.moves[this.moveNumber]) {
                     this.chess.makeMove(this.moves[this.moveNumber]);
-                    
+
                     /*
                     this.socketManager.sendToSocket(
                         id,
                         new MoveMessage(this.moves[this.moveNumber]),
                     );*/
-                    setTimeout(()=>{
+                    setTimeout(() => {
                         this.socketManager.sendToAll(
                             new MoveMessage(this.moves[this.moveNumber]),
                         );
                         this.moveNumber++;
-                    },this.MINIMUM_DELAY)
-                    
-                }
-                else{
+                    }, this.MINIMUM_DELAY);
+                } else {
                     this.moveNumber++;
                 }
             }

From 92614b44d09d0ae9e8ecf216de3c7dd1b621c7ad Mon Sep 17 00:00:00 2001
From: ymmot239 <pacman239sa@gmail.com>
Date: Mon, 24 Mar 2025 17:13:28 -0500
Subject: [PATCH 15/27] Added new puzzle

Added another 1000ish elo puzzle to puzzles.json
---
 src/server/api/puzzles.json | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/src/server/api/puzzles.json b/src/server/api/puzzles.json
index d35463e1..52c430a8 100644
--- a/src/server/api/puzzles.json
+++ b/src/server/api/puzzles.json
@@ -10,6 +10,15 @@
         "rating": 514
     },
     "Puzzle 3": {
+        "fen": "8/8/8/8/2Prk1p1/2K5/8/5R2 w - - 0 1",
+        "moves": [
+            { "from": "f1", "to": "e1" },
+            { "from": "e4", "to": "f3" },
+            { "from": "c3", "to": "d4" }
+        ],
+        "rating": 1000
+    },
+    "Puzzle 4": {
         "fen": "1r3k2/R4p2/5Kp1/1p1Pp3/2p1PbP1/2P2P2/4B3/8 b - - 0 1",
         "moves": [
             { "from": "b8", "to": "b6" },
@@ -18,7 +27,7 @@
         ],
         "rating": 1000
     },
-    "Puzzle 4": {
+    "Puzzle 5": {
         "fen": "r1b3k1/1pq1b1r1/p2p3Q/3Pp3/3p1P2/P2B3P/1PP3P1/1R3RK1 w - - 0 1",
         "moves": [
             { "from": "f4", "to": "e5" },

From dcc13e3c5e4505482753577df5a5e980b1115f63 Mon Sep 17 00:00:00 2001
From: ymmot239 <pacman239sa@gmail.com>
Date: Mon, 24 Mar 2025 17:35:19 -0500
Subject: [PATCH 16/27] Update game-manager.ts

changed handle message to match new Arduino changes
---
 src/server/api/game-manager.ts | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/server/api/game-manager.ts b/src/server/api/game-manager.ts
index bfadcdab..c2b5635d 100644
--- a/src/server/api/game-manager.ts
+++ b/src/server/api/game-manager.ts
@@ -313,7 +313,8 @@ export class PuzzleGameManager extends GameManager {
         return this.difficulty;
     }
 
-    public handleMessage(message: Message): void {
+    public async handleMessage(message: Message, id: string): Promise<void> {
+        id;
         if (message instanceof MoveMessage) {
             //if the move is correct
             if (

From 67155cad376b321d9027d4917af446eb8a60a124 Mon Sep 17 00:00:00 2001
From: ymmot239 <pacman239sa@gmail.com>
Date: Mon, 24 Mar 2025 17:52:45 -0500
Subject: [PATCH 17/27] Load Fen

Changed leading in chess enginer to loadFen
---
 src/client/game/game.tsx       | 2 +-
 src/common/chess-engine.ts     | 2 +-
 src/server/api/game-manager.ts | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/client/game/game.tsx b/src/client/game/game.tsx
index 6b44dfff..bd23a6e1 100644
--- a/src/client/game/game.tsx
+++ b/src/client/game/game.tsx
@@ -49,7 +49,7 @@ function getMessageHandler(
             const fen = message.chess;
             if (fen) {
                 setTimeout(() => {
-                    chess.load(fen);
+                    chess.loadFen(fen);
                     setChess(chess.copy());
                 }, 500);
             }
diff --git a/src/common/chess-engine.ts b/src/common/chess-engine.ts
index 2f677b5e..5349b142 100644
--- a/src/common/chess-engine.ts
+++ b/src/common/chess-engine.ts
@@ -52,7 +52,7 @@ export class ChessEngine {
         return { from: undo?.from, to: undo?.to } as Move;
     }
 
-    load(fen: string) {
+    loadFen(fen: string) {
         this.chess.load(fen);
     }
 
diff --git a/src/server/api/game-manager.ts b/src/server/api/game-manager.ts
index c2b5635d..5d236851 100644
--- a/src/server/api/game-manager.ts
+++ b/src/server/api/game-manager.ts
@@ -306,7 +306,7 @@ export class PuzzleGameManager extends GameManager {
             fen.split(" ")[1] === "w" ? Side.WHITE : Side.BLACK,
             false,
         );
-        chess.load(fen);
+        chess.loadFen(fen);
     }
 
     public getDifficulty(): number {

From 641eb83292d2d8221f599e19188aa615bae5168f Mon Sep 17 00:00:00 2001
From: Colin Wong <cwongmath@gmail.com>
Date: Wed, 9 Apr 2025 03:06:41 -0500
Subject: [PATCH 18/27] Re-add removed comments

---
 src/common/chess-engine.ts | 3 +++
 src/server/api/api.ts      | 3 +++
 2 files changed, 6 insertions(+)

diff --git a/src/common/chess-engine.ts b/src/common/chess-engine.ts
index 5349b142..3045a8c8 100644
--- a/src/common/chess-engine.ts
+++ b/src/common/chess-engine.ts
@@ -47,15 +47,18 @@ export class ChessEngine {
         return this.chess.pgn();
     }
 
+    /** undo a move */
     undo(): Move {
         const undo = this.chess.undo();
         return { from: undo?.from, to: undo?.to } as Move;
     }
 
+    /** load a board from history (FEN) */
     loadFen(fen: string) {
         this.chess.load(fen);
     }
 
+    /** load a board from history (PGN) */
     loadPgn(pgn: string) {
         this.chess.loadPgn(pgn);
     }
diff --git a/src/server/api/api.ts b/src/server/api/api.ts
index 5e5798ba..9b52062d 100644
--- a/src/server/api/api.ts
+++ b/src/server/api/api.ts
@@ -201,6 +201,9 @@ apiRouter.post("/start-puzzle-game", (req, res) => {
     return res.send({ message: "success" });
 });
 
+/**
+ * Returns all registered robot ids
+ */
 apiRouter.get("/get-ids", (_, res) => {
     let ids: string[];
     if (!tcpServer) {

From aa97663e69c3c59ff56e724f94ca36d609f9fdfb Mon Sep 17 00:00:00 2001
From: Jason Antwi-Appah <hey@jasonaa.me>
Date: Mon, 12 May 2025 21:45:31 -0500
Subject: [PATCH 19/27] Rename AI props

---
 src/client/game/game.tsx        |  2 +-
 src/client/game/navbar-menu.tsx | 12 ++++++------
 src/server/api/game-manager.ts  | 16 ++++++++++++----
 3 files changed, 19 insertions(+), 11 deletions(-)

diff --git a/src/client/game/game.tsx b/src/client/game/game.tsx
index a84751a2..c76c51ee 100644
--- a/src/client/game/game.tsx
+++ b/src/client/game/game.tsx
@@ -162,7 +162,7 @@ export function Game(): JSX.Element {
                 sendMessage={sendMessage}
                 side={side}
                 difficulty={data.difficulty}
-                AiDifficulty={data.AiDifficulty}
+                aiDifficulty={data.aiDifficulty}
                 setRotation={setRotation}
             />
             <div id="body-container" className={bgColor()}>
diff --git a/src/client/game/navbar-menu.tsx b/src/client/game/navbar-menu.tsx
index 3c573108..4c5cc545 100644
--- a/src/client/game/navbar-menu.tsx
+++ b/src/client/game/navbar-menu.tsx
@@ -29,7 +29,7 @@ interface NavbarMenuProps {
     sendMessage: SendMessage;
     side: Side;
     difficulty?: string;
-    AiDifficulty?: number;
+    aiDifficulty?: number;
     setRotation: Dispatch<React.SetStateAction<number>>; //set state type
 }
 
@@ -47,13 +47,13 @@ export function NavbarMenu(props: NavbarMenuProps): JSX.Element {
             <Button minimal disabled text={"rating: " + props.difficulty} />
         :   null;
 
-    const AiArray = ["Baby", "Beginner", "Intermediate", "Advances"];
-    const AiDifficultyButton =
-        props.AiDifficulty ?
+    const aiArray = ["Baby", "Beginner", "Intermediate", "Advances"];
+    const aiDifficultyButton =
+        props.aiDifficulty ?
             <Button
                 minimal
                 disabled
-                text={"AI Difficulty: " + AiArray[props.AiDifficulty]}
+                text={"AI Difficulty: " + aiArray[props.aiDifficulty]}
             />
         :   null;
 
@@ -116,7 +116,7 @@ export function NavbarMenu(props: NavbarMenuProps): JSX.Element {
             </NavbarGroup>
             <NavbarGroup align="right">
                 {difficultyButton}
-                {AiDifficultyButton}
+                {aiDifficultyButton}
                 {rotateButton}
                 <Button
                     icon={darkModeIcon()}
diff --git a/src/server/api/game-manager.ts b/src/server/api/game-manager.ts
index 1085e447..3b6615d8 100644
--- a/src/server/api/game-manager.ts
+++ b/src/server/api/game-manager.ts
@@ -24,6 +24,14 @@ import { materializePath } from "../robot/path-materializer";
 import { executor } from "./api";
 import { DO_SAVES } from "../utils/env";
 
+type GameState = {
+    side: Side;
+    position: string;
+    gameEndReason: GameEndReason | undefined;
+    aiDifficulty?: number;
+    difficulty?: number;
+};
+
 /**
  * The manager for game communication
  */
@@ -61,7 +69,7 @@ export abstract class GameManager {
      * A method which is invoked whenever a game first connects.
      * Should respond with the game's side, position, and whether the game is finished.
      */
-    public getGameState(clientType: ClientType): object {
+    public getGameState(clientType: ClientType): GameState {
         let side: Side;
         if (clientType === ClientType.HOST) {
             side = this.reverse ? oppositeSide(this.hostSide) : this.hostSide;
@@ -280,10 +288,10 @@ export class ComputerGameManager extends GameManager {
         }
     }
 
-    public getGameState(clientType: ClientType): object {
+    public getGameState(clientType: ClientType): GameState {
         return {
             ...super.getGameState(clientType),
-            AiDifficulty: this.difficulty,
+            aiDifficulty: this.difficulty,
         };
     }
 }
@@ -387,7 +395,7 @@ export class PuzzleGameManager extends GameManager {
         return super.getGameEndReason();
     }
 
-    public getGameState(clientType: ClientType): object {
+    public getGameState(clientType: ClientType): GameState {
         return {
             ...super.getGameState(clientType),
             difficulty: this.difficulty,

From 4878053b815e5f924ccb7b95ec3fc0a9778e213b Mon Sep 17 00:00:00 2001
From: Jason Antwi-Appah <hey@jasonaa.me>
Date: Mon, 12 May 2025 21:48:47 -0500
Subject: [PATCH 20/27] Remove unused branch

---
 src/server/robot/path-materializer.ts | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/src/server/robot/path-materializer.ts b/src/server/robot/path-materializer.ts
index e9c17fcb..4fe2a7b0 100644
--- a/src/server/robot/path-materializer.ts
+++ b/src/server/robot/path-materializer.ts
@@ -719,7 +719,3 @@ export function materializePath(move: Move): Command {
         return moveMainPiece(moveToGridMove(move));
     }
 }
-
-export function debugPath(move: Move) {
-    return moveMainPiece(moveToGridMove(move));
-}

From 8c9abc69f7b1b07310e17bcc1ae54918ef91adee Mon Sep 17 00:00:00 2001
From: Jason Antwi-Appah <hey@jasonaa.me>
Date: Mon, 12 May 2025 22:11:18 -0500
Subject: [PATCH 21/27] address nits

---
 src/client/api.ts                   |  4 ++--
 src/client/puzzle/select-puzzle.tsx |  6 +++---
 src/client/puzzle/setup-puzzle.tsx  | 31 +++++++++++------------------
 src/server/api/api.ts               |  2 +-
 src/server/api/game-manager.ts      | 23 ---------------------
 5 files changed, 18 insertions(+), 48 deletions(-)

diff --git a/src/client/api.ts b/src/client/api.ts
index 7f3443c4..322764bb 100644
--- a/src/client/api.ts
+++ b/src/client/api.ts
@@ -9,10 +9,10 @@ import { useQuery } from "@tanstack/react-query";
 /**
  * A wrapper around `useQuery` which causes the wrapped query to be trigged once each time the page renders.
  */
-export function useEffectQuery(
+export function useEffectQuery<T>(
     queryKey: string,
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    queryFn: () => Promise<any>,
+    queryFn: () => Promise<T>,
     retry?: boolean | number,
 ) {
     // id guarantees query is the same every time
diff --git a/src/client/puzzle/select-puzzle.tsx b/src/client/puzzle/select-puzzle.tsx
index b4e922b3..5353a268 100644
--- a/src/client/puzzle/select-puzzle.tsx
+++ b/src/client/puzzle/select-puzzle.tsx
@@ -21,7 +21,7 @@ const renderPuzzleOptions: ItemRenderer<string> = (
 };
 
 interface SelectPuzzleProps {
-    puzzles: Map<string, PuzzleComponents>;
+    puzzles: Record<string, PuzzleComponents>;
     selectedPuzzle: string | undefined;
     onPuzzleSelected: (puzzle: string) => void;
 }
@@ -38,7 +38,7 @@ export function SelectPuzzle(props: SelectPuzzleProps) {
             onClick={async () => {
                 if (props.selectedPuzzle && props.puzzles) {
                     //convert puzzle to map and send to start puzzles
-                    const puzzle = props.puzzles as Map<string, object>;
+                    const puzzle = props.puzzles as Record<string, PuzzleComponents>;
                     const promise = post("/start-puzzle-game", {
                         puzzle: JSON.stringify(puzzle[props.selectedPuzzle]),
                     });
@@ -64,7 +64,7 @@ export function SelectPuzzle(props: SelectPuzzleProps) {
                             props.selectedPuzzle
                         :   "Select a puzzle..."
                     }
-                    rightIcon="double-caret-vertical"
+                    endIcon="double-caret-vertical"
                 />
             </Select>
             {submit}
diff --git a/src/client/puzzle/setup-puzzle.tsx b/src/client/puzzle/setup-puzzle.tsx
index d4b5f72a..2f77d143 100644
--- a/src/client/puzzle/setup-puzzle.tsx
+++ b/src/client/puzzle/setup-puzzle.tsx
@@ -4,6 +4,7 @@ import { SelectPuzzle } from "./select-puzzle";
 import { NonIdealState, Spinner } from "@blueprintjs/core";
 import { get, useEffectQuery } from "../api";
 import { Navigate } from "react-router-dom";
+import { PuzzleComponents } from "../../server/api/api";
 
 export function SetupPuzzle() {
     const [selectedPuzzle, setSelectedPuzzle] = useState<string | undefined>();
@@ -11,11 +12,7 @@ export function SetupPuzzle() {
     //get puzzles from api
     const { isPending, data, isError } = useEffectQuery(
         "get-puzzles",
-        async () => {
-            return get("/get-puzzles").then((puzzles) => {
-                return puzzles;
-            });
-        },
+        async () => (await get("/get-puzzles")) as Record<string, PuzzleComponents>,
         false,
     );
 
@@ -26,21 +23,17 @@ export function SetupPuzzle() {
                 title="Loading..."
             />
         );
-    } else if (isError) {
+    } else if (isError || data === undefined) {
         return <Navigate to="/home" />;
     }
 
-    if (data === undefined) {
-        return <Spinner intent="primary" />;
-    } else {
-        return (
-            <SetupBase>
-                <SelectPuzzle
-                    puzzles={data}
-                    selectedPuzzle={selectedPuzzle}
-                    onPuzzleSelected={setSelectedPuzzle}
-                />
-            </SetupBase>
-        );
-    }
+    return (
+        <SetupBase>
+            <SelectPuzzle
+                puzzles={data}
+                selectedPuzzle={selectedPuzzle}
+                onPuzzleSelected={setSelectedPuzzle}
+            />
+        </SetupBase>
+    );
 }
diff --git a/src/server/api/api.ts b/src/server/api/api.ts
index 9b52062d..f59e9478 100644
--- a/src/server/api/api.ts
+++ b/src/server/api/api.ts
@@ -270,7 +270,7 @@ export interface PuzzleComponents {
  * Returns a list of available puzzles to play from puzzles.json.
  */
 apiRouter.get("/get-puzzles", (_, res) => {
-    const puzzles: Map<string, PuzzleComponents> = JSON.parse(
+    const puzzles: Record<string, PuzzleComponents> = JSON.parse(
         readFileSync("./src/server/api/puzzles.json", "utf-8"),
     );
     const out: string = JSON.stringify(puzzles);
diff --git a/src/server/api/game-manager.ts b/src/server/api/game-manager.ts
index 3b6615d8..67e20960 100644
--- a/src/server/api/game-manager.ts
+++ b/src/server/api/game-manager.ts
@@ -100,9 +100,6 @@ export class HumanGameManager extends GameManager {
         protected reverse: boolean,
     ) {
         super(chess, socketManager, hostSide, reverse);
-        // Notify other client the game has started
-        //clientManager.sendToClient(new GameStartedMessage());
-        //clientManager.sendToSpectators(new GameStartedMessage());
     }
 
     /**
@@ -189,8 +186,6 @@ export class HumanGameManager extends GameManager {
             }
         } else if (message instanceof GameFinishedMessage) {
             // propagate back to both sockets
-            //sendToPlayer(message);
-            //sendToOpponent(message);
             if (ids) {
                 if (currentSave?.host === ids[0])
                     SaveManager.endGame(ids[0], ids[1]);
@@ -271,9 +266,7 @@ export class ComputerGameManager extends GameManager {
             const move = this.chess.makeAiMove(this.difficulty);
             const elapsedTime = Date.now() - startTime;
             // If elapsed time is less than minimum delay, timeout is set to 1ms
-            new MoveMessage(move);
             setTimeout(() => {
-                //this.socketManager.sendToSocket(id, new MoveMessage(move));
                 this.socketManager.sendToAll(new MoveMessage(move));
             }, this.MINIMUM_DELAY - elapsedTime);
             if (this.isGameEnded()) {
@@ -283,7 +276,6 @@ export class ComputerGameManager extends GameManager {
             this.gameInterruptedReason = message.reason;
             SaveManager.endGame(id, "ai");
             // Reflect end game reason back to client
-            //this.socketManager.sendToSocket(id, message);
             this.socketManager.sendToAll(message);
         }
     }
@@ -335,11 +327,6 @@ export class PuzzleGameManager extends GameManager {
                 if (this.moves[this.moveNumber]) {
                     this.chess.makeMove(this.moves[this.moveNumber]);
 
-                    /*
-                    this.socketManager.sendToSocket(
-                        id,
-                        new MoveMessage(this.moves[this.moveNumber]),
-                    );*/
                     setTimeout(() => {
                         this.socketManager.sendToAll(
                             new MoveMessage(this.moves[this.moveNumber]),
@@ -353,11 +340,6 @@ export class PuzzleGameManager extends GameManager {
 
             //send an undo message
             else {
-                /*
-                this.socketManager.sendToSocket(
-                    id,
-                    new SetChessMessage(this.chess.fen),
-                );*/
                 this.socketManager.sendToAll(
                     new SetChessMessage(this.chess.fen),
                 );
@@ -367,10 +349,6 @@ export class PuzzleGameManager extends GameManager {
             if (this.isGameEnded()) {
                 const gameEnd = this.getGameEndReason();
                 if (gameEnd) {
-                    /*this.socketManager.sendToSocket(
-                        id,
-                        new GameEndMessage(gameEnd),
-                    );*/
                     this.socketManager.sendToAll(new GameEndMessage(gameEnd));
                 }
             }
@@ -379,7 +357,6 @@ export class PuzzleGameManager extends GameManager {
         ) {
             this.gameInterruptedReason = message.reason;
             // Reflect end game reason back to client
-            //this.socketManager.sendToSocket(id, message);
             this.socketManager.sendToAll(message);
         }
     }

From 5e416bc4168409fa62a769442b3916ca78a3738b Mon Sep 17 00:00:00 2001
From: Jason Antwi-Appah <hey@jasonaa.me>
Date: Mon, 12 May 2025 22:12:33 -0500
Subject: [PATCH 22/27] Lint/Format

---
 src/client/api.ts                   | 1 -
 src/client/puzzle/select-puzzle.tsx | 5 ++++-
 src/client/puzzle/setup-puzzle.tsx  | 3 ++-
 3 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/src/client/api.ts b/src/client/api.ts
index 322764bb..d458c158 100644
--- a/src/client/api.ts
+++ b/src/client/api.ts
@@ -11,7 +11,6 @@ import { useQuery } from "@tanstack/react-query";
  */
 export function useEffectQuery<T>(
     queryKey: string,
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     queryFn: () => Promise<T>,
     retry?: boolean | number,
 ) {
diff --git a/src/client/puzzle/select-puzzle.tsx b/src/client/puzzle/select-puzzle.tsx
index 5353a268..228c9af5 100644
--- a/src/client/puzzle/select-puzzle.tsx
+++ b/src/client/puzzle/select-puzzle.tsx
@@ -38,7 +38,10 @@ export function SelectPuzzle(props: SelectPuzzleProps) {
             onClick={async () => {
                 if (props.selectedPuzzle && props.puzzles) {
                     //convert puzzle to map and send to start puzzles
-                    const puzzle = props.puzzles as Record<string, PuzzleComponents>;
+                    const puzzle = props.puzzles as Record<
+                        string,
+                        PuzzleComponents
+                    >;
                     const promise = post("/start-puzzle-game", {
                         puzzle: JSON.stringify(puzzle[props.selectedPuzzle]),
                     });
diff --git a/src/client/puzzle/setup-puzzle.tsx b/src/client/puzzle/setup-puzzle.tsx
index 2f77d143..031b05d9 100644
--- a/src/client/puzzle/setup-puzzle.tsx
+++ b/src/client/puzzle/setup-puzzle.tsx
@@ -12,7 +12,8 @@ export function SetupPuzzle() {
     //get puzzles from api
     const { isPending, data, isError } = useEffectQuery(
         "get-puzzles",
-        async () => (await get("/get-puzzles")) as Record<string, PuzzleComponents>,
+        async () =>
+            (await get("/get-puzzles")) as Record<string, PuzzleComponents>,
         false,
     );
 

From f6bf22124eee3a3bbb1da9e591e0f8f9769bcb94 Mon Sep 17 00:00:00 2001
From: ymmot239 <pacman239sa@gmail.com>
Date: Mon, 12 May 2025 22:07:34 -0500
Subject: [PATCH 23/27] added functionality

updated the create robot functions to work with indices and made puzzles materialize and execute the paths it makes
---
 src/server/api/game-manager.ts    | 15 +++++++++++++++
 src/server/robot/robot-manager.ts | 23 +++++++++++++++++++++++
 2 files changed, 38 insertions(+)

diff --git a/src/server/api/game-manager.ts b/src/server/api/game-manager.ts
index 67e20960..0127b903 100644
--- a/src/server/api/game-manager.ts
+++ b/src/server/api/game-manager.ts
@@ -320,13 +320,28 @@ export class PuzzleGameManager extends GameManager {
                 this.moves[this.moveNumber].from === message.move.from &&
                 this.moves[this.moveNumber].to === message.move.to
             ) {
+                const command = materializePath(message.move);
+
                 this.socketManager.sendToAll(new MoveMessage(message.move));
                 this.chess.makeMove(message.move);
                 this.moveNumber++;
+
+                console.log("running executor");
+                console.dir(command, { depth: null });
+                await executor.execute(command);
+                console.log("executor done");
+
                 //if there is another move, make it
                 if (this.moves[this.moveNumber]) {
+                    const command = materializePath(message.move);
+
                     this.chess.makeMove(this.moves[this.moveNumber]);
 
+                    console.log("running executor");
+                    console.dir(command, { depth: null });
+                    await executor.execute(command);
+                    console.log("executor done");
+                   
                     setTimeout(() => {
                         this.socketManager.sendToAll(
                             new MoveMessage(this.moves[this.moveNumber]),
diff --git a/src/server/robot/robot-manager.ts b/src/server/robot/robot-manager.ts
index daabf1f4..865988cd 100644
--- a/src/server/robot/robot-manager.ts
+++ b/src/server/robot/robot-manager.ts
@@ -1,5 +1,8 @@
+import { DEGREE } from "../../common/units";
 import { GridIndices } from "./grid-indices";
+import { Position } from "./position";
 import { Robot } from "./robot";
+import config from "../api/bot-server-config.json";
 
 /**
  * Stores robots. Provides utilities for finding them by position.
@@ -36,6 +39,26 @@ export class RobotManager {
         return robot;
     }
 
+    createRobotFromId(robotId: string) {
+        const robot = new Robot(
+            robotId,
+            new GridIndices(
+                config[robotId].homePosition.x,
+                config[robotId].homePosition.y,
+            ),
+            new GridIndices(
+                config[robotId].defaultPosition.x,
+                config[robotId].defaultPosition.y,
+            ),
+            config[robotId].startHeading * DEGREE,
+            new Position(
+                config[robotId].defaultPosition.x,
+                config[robotId].defaultPosition.y,
+            ),
+        );
+        this.addRobot(robot);
+    }
+
     /**
      * Returns `true` if a Robot is at the specified position, and `false` otherwise.
      */

From 752b2a13e1b2a540fa9fe57e559265331803132f Mon Sep 17 00:00:00 2001
From: Jason Antwi-Appah <hey@jasonaa.me>
Date: Mon, 12 May 2025 22:31:44 -0500
Subject: [PATCH 24/27] colin said i should get it done

---
 src/common/chess-engine.ts | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/common/chess-engine.ts b/src/common/chess-engine.ts
index 3045a8c8..8f56c845 100644
--- a/src/common/chess-engine.ts
+++ b/src/common/chess-engine.ts
@@ -238,8 +238,6 @@ export class ChessEngine {
      * @returns the move that was made.
      */
     makeMove(move: Move): Move {
-        //const yay = this.chess.history[this.chess.history.length-1];
-        //if(yay!==undefined && !(move.from === yay.from || move.to === yay.to))
         this.chess.move(move);
         return move;
     }

From 99014cc8d38c62ebb3c15745ae9d5d0b17bb20eb Mon Sep 17 00:00:00 2001
From: Jason Antwi-Appah <hey@jasonaa.me>
Date: Mon, 12 May 2025 22:32:27 -0500
Subject: [PATCH 25/27] bye

---
 src/common/chess-engine.ts | 9 ---------
 1 file changed, 9 deletions(-)

diff --git a/src/common/chess-engine.ts b/src/common/chess-engine.ts
index 8f56c845..3422596a 100644
--- a/src/common/chess-engine.ts
+++ b/src/common/chess-engine.ts
@@ -242,15 +242,6 @@ export class ChessEngine {
         return move;
     }
 
-    /**
-     * Makes a move on the chessboard.
-     * @returns the move that was made.
-     */
-    move(move: string): string {
-        this.chess.move(move);
-        return move;
-    }
-
     /**
      * Returns true if a move is a promotion, and false otherwise.
      * Assumes that chess hasn't been updated yet

From cb0a9130541575dd8d59258776767ecfd22c23b0 Mon Sep 17 00:00:00 2001
From: Jason Antwi-Appah <hey@jasonaa.me>
Date: Mon, 12 May 2025 22:35:06 -0500
Subject: [PATCH 26/27] Add comment to set chess message

---
 src/common/message/game-message.ts | 6 ++++++
 src/server/api/game-manager.ts     | 1 -
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/src/common/message/game-message.ts b/src/common/message/game-message.ts
index e20d471b..f3d9cb7f 100644
--- a/src/common/message/game-message.ts
+++ b/src/common/message/game-message.ts
@@ -39,6 +39,12 @@ export class MoveMessage extends Message {
         };
     }
 }
+
+/**
+ * A message used to broadcast the state of the virtual chessboard 
+ * to other connected clients. `chess` is a Forsyth-Edwards 
+ * Notation (FEN) string used to represent the state of the chessboard.
+ */
 export class SetChessMessage extends Message {
     constructor(public readonly chess: string) {
         super();
diff --git a/src/server/api/game-manager.ts b/src/server/api/game-manager.ts
index 0127b903..2d7555b6 100644
--- a/src/server/api/game-manager.ts
+++ b/src/server/api/game-manager.ts
@@ -341,7 +341,6 @@ export class PuzzleGameManager extends GameManager {
                     console.dir(command, { depth: null });
                     await executor.execute(command);
                     console.log("executor done");
-                   
                     setTimeout(() => {
                         this.socketManager.sendToAll(
                             new MoveMessage(this.moves[this.moveNumber]),

From 7b4f97d9565d9f58b518d25f637f26a3c94be2a4 Mon Sep 17 00:00:00 2001
From: Jason Antwi-Appah <hey@jasonaa.me>
Date: Mon, 12 May 2025 22:40:15 -0500
Subject: [PATCH 27/27] format.

---
 src/common/message/game-message.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/common/message/game-message.ts b/src/common/message/game-message.ts
index f3d9cb7f..52ce0da4 100644
--- a/src/common/message/game-message.ts
+++ b/src/common/message/game-message.ts
@@ -41,8 +41,8 @@ export class MoveMessage extends Message {
 }
 
 /**
- * A message used to broadcast the state of the virtual chessboard 
- * to other connected clients. `chess` is a Forsyth-Edwards 
+ * A message used to broadcast the state of the virtual chessboard
+ * to other connected clients. `chess` is a Forsyth-Edwards
  * Notation (FEN) string used to represent the state of the chessboard.
  */
 export class SetChessMessage extends Message {