wip

src/__fixtures__/dominion-lib-fixtures.ts

@@ -15,6 +15,8 @@ import { IMatsEnabled } from '@/game/interfaces/mats-enabled';
 import { IExpansionsEnabled } from '@/game/interfaces/expansions-enabled';
 import { CurrentStep } from '@/game/enumerations/current-step';
 import { ILogEntry } from '@/game/interfaces/log-entry';
+import { deepClone } from '@/game/utils';
+import { IVictoryDetails } from '@/game/interfaces/victory-details';
 
 export function createMockGame(playerCount: number, overrides?: Partial<IGame>): IGame {
   const options: IGameOptions = {
@@ -67,12 +69,12 @@ export function createMockPlayer(victory?: Partial<IPlayer['victory']>, index?:
       DefaultPlayerColors[
         index ?? faker.number.int({ min: 0, max: DefaultPlayerColors.length - 1 })
       ],
-    mats: { ...EmptyMatDetails },
-    turn: { ...DefaultTurnDetails },
-    newTurn: { ...DefaultTurnDetails },
+    mats: EmptyMatDetails(),
+    turn: DefaultTurnDetails(),
+    newTurn: DefaultTurnDetails(),
     victory: {
-      ...EmptyVictoryDetails,
-      ...victory,
+      ...EmptyVictoryDetails(),
+      ...(victory ? deepClone<Partial<IVictoryDetails>>(victory) : {}),
     },
   } as IPlayer;
 }
@@ -89,6 +91,6 @@ export function createMockLog(log?: Partial<ILogEntry>): ILogEntry {
     correction: false,
     linkedActionId: faker.string.uuid(),
     prevPlayerIndex: faker.number.int({ min: 0, max: 3 }),
-    ...log,
+    ...(log ? deepClone<Partial<ILogEntry>>(log) : {}),
   };
 }

src/components/AddPlayerNames.tsx

@@ -21,6 +21,7 @@ import SuperCapsText from '@/components/SuperCapsText';
 import CenteredContainer from '@/components/CenteredContainer';
 import TabTitle from '@/components/TabTitle';
 import { IGame } from '@/game/interfaces/game';
+import { deepClone } from '@/game/utils';
 
 interface AddPlayerNamesProps {
   nextStep: () => void;
@@ -37,28 +38,31 @@ const AddPlayerNames: React.FC<AddPlayerNamesProps> = ({ nextStep }) => {
   const [currentPlayerIndex, setCurrentPlayerIndex] = useState<number>(-1);
 
   useEffect(() => {
-    setGameState((prevState: IGame) => ({
-      ...prevState,
-      numSets: prevState.players.length > 4 ? 2 : 1,
-    }));
+    setGameState((prevState: IGame) => {
+      const newGame = deepClone<IGame>(prevState);
+      newGame.setsRequired = prevState.players.length > 4 ? 2 : 1;
+      return newGame;
+    });
   }, [setGameState, gameState.players.length]);
 
   const addPlayer = () => {
     if (playerName.trim()) {
       const nextPlayerIndex = gameState.players.length; // +1, -1
-      setGameState((prevState: IGame) => ({
-        ...prevState,
-        players: [...prevState.players, newPlayer(playerName, nextPlayerIndex)],
-      }));
+      setGameState((prevState: IGame) => {
+        const newGame = deepClone<IGame>(prevState);
+        newGame.players = [...newGame.players, newPlayer(playerName, nextPlayerIndex)];
+        return newGame;
+      });
       setPlayerName('');
     }
   };
 
   const removePlayer = (index: number) => {
-    setGameState((prevState: IGame) => ({
-      ...prevState,
-      players: prevState.players.filter((_, i) => i !== index),
-    }));
+    setGameState((prevState: IGame) => {
+      const newGame = deepClone<IGame>(prevState);
+      newGame.players = newGame.players.filter((_, i) => i !== index);
+      return newGame;
+    });
   };
 
   const handleColorClick = (event: React.MouseEvent<HTMLElement>, playerIndex: number) => {
@@ -69,9 +73,9 @@ const AddPlayerNames: React.FC<AddPlayerNamesProps> = ({ nextStep }) => {
   const handleColorChange = (color: ColorResult) => {
     if (currentPlayerIndex !== -1) {
       setGameState((prevState: IGame) => {
-        const players = [...prevState.players];
-        players[currentPlayerIndex].color = color.hex;
-        return { ...prevState, players };
+        const newGame = deepClone<IGame>(prevState);
+        newGame.players[currentPlayerIndex].color = color.hex;
+        return newGame;
       });
     }
   };

src/components/DominionAssistant.tsx

@@ -19,6 +19,7 @@ import { addLogEntry } from '@/game/dominion-lib-log';
 import { useAlert } from '@/components/AlertContext';
 import { Location, NavigateFunction } from 'react-router-dom';
 import { IGame } from '@/game/interfaces/game';
+import { deepClone } from '@/game/utils';
 
 interface DominionAssistantProps {
   route: Location;
@@ -48,55 +49,55 @@ const DominionAssistant: React.FC<DominionAssistantProps> = ({ route, navigation
   };
 
   const nextStep = () => {
-    setGameState((prevState: IGame) => ({
-      ...prevState,
-      currentStep: StepTransitions[prevState.currentStep] || prevState.currentStep,
-    }));
+    setGameState((prevState: IGame) => {
+      const newGame = deepClone<IGame>(prevState);
+      newGame.currentStep = StepTransitions[prevState.currentStep] || prevState.currentStep;
+      return newGame;
+    });
   };
 
   /**
    * Start the game with the selected players and options.
    */
   const startGame = () => {
     // The game initialization is now handled in SetGameOptions
-    setGameState((prevState: IGame) => ({
-      ...prevState,
-      currentStep: CurrentStep.GameScreen,
-    }));
+    setGameState((prevState: IGame) => {
+      const newGame = deepClone<IGame>(prevState);
+      newGame.currentStep = CurrentStep.GameScreen;
+      return newGame;
+    });
   };
 
   const nextTurn = () => {
     setGameState((prevGame: IGame) => {
-      const nextPlayerIndex = getNextPlayerIndex(prevGame);
-      addLogEntry(prevGame, nextPlayerIndex, GameLogAction.NEXT_TURN, {
+      const newGame = deepClone(prevGame);
+      const nextPlayerIndex = getNextPlayerIndex(newGame);
+      addLogEntry(newGame, nextPlayerIndex, GameLogAction.NEXT_TURN, {
         currentPlayerIndex: nextPlayerIndex,
         playerTurnDetails: gameState.players.map((player) => player.turn),
         prevPlayerIndex: gameState.currentPlayerIndex,
         turn: prevGame.currentTurn + 1,
       });
-      const updatedGame = incrementTurnCountersAndPlayerIndices(prevGame);
-      return resetPlayerTurnCounters(updatedGame);
+      return resetPlayerTurnCounters(incrementTurnCountersAndPlayerIndices(newGame));
     });
   };
 
   const endGame = () => {
     setGameState((prevState: IGame) => {
-      addLogEntry(prevState, NO_PLAYER, GameLogAction.END_GAME, {
+      const newGame = deepClone<IGame>(prevState);
+      addLogEntry(newGame, NO_PLAYER, GameLogAction.END_GAME, {
         prevPlayerIndex: gameState.currentPlayerIndex,
       });
-
-      return {
-        ...prevState,
-        currentStep: CurrentStep.EndGame,
-        currentPlayerIndex: NO_PLAYER,
-        selectedPlayerIndex: NO_PLAYER,
-      };
+      newGame.currentStep = CurrentStep.EndGame;
+      newGame.currentPlayerIndex = NO_PLAYER;
+      newGame.selectedPlayerIndex = NO_PLAYER;
+      return newGame;
     });
   };
 
   const resetGame = () => {
     setGameState({
-      ...EmptyGameState,
+      ...EmptyGameState(),
       currentStep: CurrentStep.AddPlayerNames,
     });
   };

src/components/GameContext.tsx

@@ -3,6 +3,7 @@ import { saveGame } from '@/game/dominion-lib-load-save';
 import { IGame } from '@/game/interfaces/game';
 import React, { createContext, useContext, useState, ReactNode, useMemo, useEffect } from 'react';
 import { LocalStorageService } from '@/game/local-storage-service';
+import { deepClone } from '@/game/utils';
 
 // Define the shape of the context
 interface GameContextProps {
@@ -33,7 +34,8 @@ export const GameProvider: React.FC<{ children: ReactNode }> = ({ children }) =>
     const storageService = new LocalStorageService();
     const saveId = 'autosave';
     // the saved game branches from the active game and has the save game entry at the top of the log
-    const newState = { ...gameState };
+    // saveGame adds a new entry to the log
+    const newState = deepClone<IGame>(gameState);
     saveGame(newState, 'AutoSave', storageService, saveId);
   }, [gameState]);
 

src/components/GameScreen.tsx

@@ -27,6 +27,8 @@ import { CurrentStep } from '@/game/enumerations/current-step';
 import { addLogEntry } from '@/game/dominion-lib-log';
 import { NO_PLAYER } from '@/game/constants';
 import { GameLogAction } from '@/game/enumerations/game-log-action';
+import { IGame } from '@/game/interfaces/game';
+import { deepClone } from '@/game/utils';
 
 interface GameScreenProps {
   nextTurn: () => void;
@@ -110,14 +112,14 @@ const GameScreen: React.FC<GameScreenProps> = ({ nextTurn, endGame, undoLastActi
     if (lastActionIsPause) {
       // Unpause the game
       setGameState((prevState) => {
-        const newState = { ...prevState };
+        const newState = deepClone<IGame>(prevState);
         addLogEntry(newState, NO_PLAYER, GameLogAction.UNPAUSE);
         return newState;
       });
     } else {
       // Pause the game
       setGameState((prevState) => {
-        const newState = { ...prevState };
+        const newState = deepClone<IGame>(prevState);
         addLogEntry(newState, NO_PLAYER, GameLogAction.PAUSE);
         return newState;
       });

src/components/Player.tsx

@@ -21,6 +21,7 @@ import { PlayerFieldMap } from '@/game/types';
 import { useAlert } from '@/components/AlertContext';
 import '@/styles.scss';
 import { IGame } from '@/game/interfaces/game';
+import { deepClone } from '@/game/utils';
 
 const StyledPaper = styled(Paper)(({ theme }) => ({
   padding: theme.spacing(2),
@@ -88,7 +89,7 @@ const Player: React.FC = () => {
     linkedActionId?: string,
     victoryTrash?: boolean
   ): void => {
-    const prevGame = { ...gameState };
+    const prevGame = deepClone<IGame>(gameState);
     try {
       const updatedGame = updatePlayerField(
         prevGame,
@@ -124,7 +125,7 @@ const Player: React.FC = () => {
     incrementSubfield: PlayerFieldMap[T],
     increment: number
   ): void => {
-    const prevGame = { ...gameState };
+    const prevGame = deepClone<IGame>(gameState);
     try {
       // Perform the decrement action
       const tempGame = updatePlayerField(
@@ -195,7 +196,7 @@ const Player: React.FC = () => {
   const handleProphecyIncrease = () => {
     setGameState((prevState: IGame) => {
       if (prevState.risingSun && prevState.options.expansions.risingSun) {
-        const newGameState = { ...prevState };
+        const newGameState = deepClone<IGame>(prevState);
         // prophecy is always triggered by the selected player, not the current player in case there is an off-turn action triggered by a defense, etc
         addLogEntry(newGameState, newGameState.selectedPlayerIndex, GameLogAction.ADD_PROPHECY, {
           count: 1,
@@ -213,7 +214,7 @@ const Player: React.FC = () => {
         if (prevState.risingSun.prophecy.suns - 1 < 0) {
           return prevState;
         }
-        const newGameState = { ...prevState };
+        const newGameState = deepClone<IGame>(prevState);
         addLogEntry(newGameState, newGameState.selectedPlayerIndex, GameLogAction.REMOVE_PROPHECY, {
           count: 1,
         });

src/components/Scoreboard.tsx

@@ -19,6 +19,7 @@ import { useGameContext } from '@/components/GameContext';
 import { addLogEntry } from '@/game/dominion-lib-log';
 import { GameLogAction } from '@/game/enumerations/game-log-action';
 import { IGame } from '@/game/interfaces/game';
+import { deepClone } from '@/game/utils';
 
 const TableText = styled(Typography)(() => ({
   fontFamily: 'TrajanProBold',
@@ -45,10 +46,12 @@ const Scoreboard: React.FC = () => {
       if (prevState.selectedPlayerIndex === index) {
         return prevState;
       }
-      addLogEntry(prevState, index, GameLogAction.SELECT_PLAYER, {
+      const newGame = deepClone<IGame>(prevState);
+      addLogEntry(newGame, index, GameLogAction.SELECT_PLAYER, {
         prevPlayerIndex: prevState.selectedPlayerIndex,
       });
-      return { ...prevState, selectedPlayerIndex: index };
+      newGame.selectedPlayerIndex = index;
+      return newGame;
     });
   };
 

src/components/SelectFirstPlayer.tsx

@@ -17,6 +17,7 @@ import CenteredContainer from '@/components/CenteredContainer';
 import TabTitle from '@/components/TabTitle';
 import SuperCapsText from '@/components/SuperCapsText';
 import { IGame } from '@/game/interfaces/game';
+import { deepClone } from '@/game/utils';
 
 interface SelectFirstPlayerProps {
   nextStep: () => void;
@@ -28,12 +29,13 @@ const SelectFirstPlayer: React.FC<SelectFirstPlayerProps> = ({ nextStep }) => {
   const selectRandomFirstPlayer = useCallback(() => {
     if (gameState.players.length > 0) {
       const randomIndex = Math.floor(Math.random() * gameState.players.length);
-      setGameState((prevState: IGame) => ({
-        ...prevState,
-        currentPlayerIndex: randomIndex,
-        firstPlayerIndex: randomIndex,
-        selectedPlayerIndex: randomIndex,
-      }));
+      setGameState((prevState: IGame) => {
+        const newGame = deepClone<IGame>(prevState);
+        newGame.currentPlayerIndex = randomIndex;
+        newGame.firstPlayerIndex = randomIndex;
+        newGame.selectedPlayerIndex = randomIndex;
+        return newGame;
+      });
     }
   }, [gameState.players.length, setGameState]);
 
@@ -51,12 +53,13 @@ const SelectFirstPlayer: React.FC<SelectFirstPlayerProps> = ({ nextStep }) => {
               key={player.name}
               selected={gameState.selectedPlayerIndex === index}
               onClick={() => {
-                setGameState((prevState: IGame) => ({
-                  ...prevState,
-                  selectedPlayerIndex: index,
-                  currentPlayerIndex: index,
-                  firstPlayerIndex: index,
-                }));
+                setGameState((prevState: IGame) => {
+                  const newGame = deepClone<IGame>(prevState);
+                  newGame.selectedPlayerIndex = index;
+                  newGame.currentPlayerIndex = index;
+                  newGame.firstPlayerIndex = index;
+                  return newGame;
+                });
               }}
             >
               <ListItemIcon>