in progress: debugging buy card action

src/components/Player/ActionMethods/buyCardActions.ts

@@ -4,27 +4,37 @@ import { turnOrderUtil } from "../../../util/turnOrderUtil";
 import { AppState, CardData, PlayerData, ResourceCost, setStateType } from "../../../util/types";
 import { useCurrentPlayer } from "../../../util/useCurrentPlayer";
 
+const getTotalBuyingPower = (state: AppState) => {
+    const currentPlayer = useCurrentPlayer(state);
+    
+    let totalBuyingPower = {
+        ruby: 0,
+        sapphire: 0,
+        emerald: 0,
+        diamond: 0,
+        onyx: 0,
+        gold: 0,
+    }
+
+    if (!currentPlayer) return totalBuyingPower;
+    
+    for (let [key,quantity] of Object.entries(currentPlayer.inventory)) {
+        totalBuyingPower[key as keyof ResourceCost] += quantity;
+    }
+
+    for (let each of currentPlayer.cards) {
+        totalBuyingPower[each.gemValue as keyof ResourceCost] += 1;
+    }
+
+    return totalBuyingPower;
+}
+
 export const tooExpensive = (card: CardData, state: AppState): boolean => {
     const currentPlayer = useCurrentPlayer(state);
     if (!currentPlayer) return true;
+
     for (let [gemType, cost] of Object.entries(card.resourceCost)) {
-        let totalBuyingPower = {
-            ruby: 0,
-            sapphire: 0,
-            emerald: 0,
-            diamond: 0,
-            onyx: 0,
-            gold: 0,
-        }
-
-        for (let [key,quantity] of Object.entries(currentPlayer.inventory)) {
-            totalBuyingPower[key as keyof ResourceCost] += quantity;
-        }
-
-        for (let each of currentPlayer.cards) {
-            totalBuyingPower[each.gemValue as keyof ResourceCost] += 1;
-        }
-        
+        let totalBuyingPower = getTotalBuyingPower(state);
         for (let [heldResource, quantity] of Object.entries(totalBuyingPower)) {
             if (gemType === heldResource && quantity < cost) {
                 return true;
@@ -52,23 +62,33 @@ export const buyCard = (card: CardData, state: AppState, setState: setStateType)
         const { newPlayers, roundIncrement } = turnOrderUtil(prev, currentPlayer);
         let newPlayerInventory = currentPlayer.inventory;
         let newResourcePool = prev.gameboard.tradingResources;
+        const totalBuyingPower = getTotalBuyingPower(state);
 
+        // iterate through cost values of card to purchase
         for (let [gem, cost] of Object.entries(card.resourceCost)) {
             if (cost < 1) continue;
+            let inventoryValue = newPlayerInventory[gem as keyof ResourceCost];
+            let globalResource = newResourcePool[gem as keyof ResourceCost];
             
-            let resourceToReplenish = newResourcePool[gem as keyof ResourceCost];
-            let newInventoryValue = newPlayerInventory[gem as keyof ResourceCost];
-            if (!newInventoryValue || !resourceToReplenish) continue;
-            
-            let i = cost;
-            while (i > 0) {
-                newInventoryValue--;
-                i--;
-            }
+            if (!inventoryValue || !globalResource) {
+                continue;
+            } else {
+                let i = cost;
 
-            resourceToReplenish += cost;
-            newPlayerInventory[gem as keyof ResourceCost] = newInventoryValue;
-            newResourcePool[gem as keyof ResourceCost] = resourceToReplenish;
+                // prevents duplication of resources when purchasing a card using permanent resources from cards
+                if (totalBuyingPower[gem as keyof ResourceCost] !== inventoryValue) {
+                    console.log('caught');
+                }
+
+                while (i > 0) {
+                    inventoryValue -= 1;
+                    globalResource += 1;
+                    i--;
+                }
+    
+                newResourcePool[gem as keyof ResourceCost] = globalResource;
+                newPlayerInventory[gem as keyof ResourceCost] = inventoryValue;
+            }
         }
 
         let updatedPlayer: PlayerData = {
@@ -77,7 +97,7 @@ export const buyCard = (card: CardData, state: AppState, setState: setStateType)
             inventory: newPlayerInventory
         }
 
-        let newScore = updatedPlayer.points;
+        let newScore = 0;
         for (let each of updatedPlayer.cards) {
             newScore += each.points || 0;
         }

src/main.tsx

@@ -3,8 +3,4 @@ import ReactDOM from 'react-dom/client'
 import App from './App'
 import './index.css'
 
-ReactDOM.createRoot(document.getElementById('root') as HTMLElement).render(
-  <React.StrictMode>
-    <App />
-  </React.StrictMode>
-)
+ReactDOM.createRoot(document.getElementById('root') as HTMLElement).render(<App />)

src/util/initializeBoard.ts

@@ -1,4 +1,4 @@
-import { AppState, FullDeck, NobleData, setStateType } from "./types";
+import { AppState, FullDeck, NobleData, ResourceCost, setStateType } from "./types";
 import NobleStore from '../data/nobles.json';
 
 const shuffleDeck = (state: AppState, setState: setStateType) => {
@@ -30,6 +30,29 @@ const setNobles = (state: AppState, setState: setStateType) => {
     setState({ ...state, gameboard: { ...state.gameboard, nobles: shuffledNobles }})
 }
 
+const setResources = (state: AppState) => {
+    let newResources = state.gameboard.tradingResources;
+
+    console.log(state.players.length);
+    switch (state.players.length) {
+        case 2:
+            for (let [key, value] of Object.entries(newResources)) {
+                newResources[key as keyof ResourceCost] = value - 3;
+            }
+            break;
+        case 3:
+            for (let [key, value] of Object.entries(newResources)) {
+                newResources[key as keyof ResourceCost] = value - 2;
+            }
+            break;
+        default:
+            break;
+    }
+
+    console.log(newResources);
+    return newResources;
+}
+
 export const setCardRows = (state: AppState) => {
     let newDeck = state.gameboard.cardRows;
     for (const [key, value] of Object.entries(state.gameboard.deck)) {
@@ -43,7 +66,18 @@ export const setCardRows = (state: AppState) => {
 
 export default function initializeBoard(state: AppState, setState: setStateType) {
     shuffleDeck(state, setState);
+    
     const newDeck = setCardRows(state);
-    setState({ ...state, gameboard: { ...state.gameboard, cardRows: newDeck } })
+    const newResources = setResources(state);
+    
+    setState({
+        ...state,
+        gameboard: {
+            ...state.gameboard,
+            tradingResources: newResources,
+            cardRows: newDeck
+        }
+    });
+
     setNobles(state, setState);
 }