powergrid-engine 1.10.0 → 1.12.0

package/src/engine.ts

@@ -15,6 +15,7 @@ export const playerColors = ['limegreen', 'mediumorchid', 'red', 'dodgerblue', '
 
 const citiesToStep2 = [10, 7, 7, 7, 6];
 const citiesToStep2BadenWurttemberg = [9, 6, 6, 6, 5];
+const citiesToStep2UKIreland = [7, 7, 7, 7, 6];
 const citiesToEndGame = [21, 17, 17, 15, 14];
 const cityIncome = [10, 22, 33, 44, 54, 64, 73, 82, 90, 98, 105, 112, 118, 124, 129, 134, 138, 142, 145, 148, 150, 150];
 const regionsInPlay = [3, 3, 4, 5, 5];
@@ -161,6 +162,15 @@ export function setup(
     let oilResupply: number[][];
     let garbageResupply: number[][];
     let uraniumResupply: number[][];
+    // Korea: parallel North-side resupply tables (no uranium row).
+    let coalResupplyNorth: number[][] | undefined;
+    let oilResupplyNorth: number[][] | undefined;
+    let garbageResupplyNorth: number[][] | undefined;
+    if (chosenMap.resupplyNorth) {
+        coalResupplyNorth = chosenMap.resupplyNorth[0];
+        oilResupplyNorth = chosenMap.resupplyNorth[1];
+        garbageResupplyNorth = chosenMap.resupplyNorth[2];
+    }
     if (chosenMap.resupply) {
         coalResupply = chosenMap.resupply[0];
         oilResupply = chosenMap.resupply[1];
@@ -251,7 +261,14 @@ export function setup(
             const region = regions[Math.floor(rng() * regions.length)];
             if (
                 playRegions.size == 0 ||
-                regionConnections[regions.indexOf(region)].some((con) => playRegions.has(con))
+                regionConnections[regions.indexOf(region)].some((con) => playRegions.has(con)) ||
+                // UK & Ireland: regions on the two islands have no edges between
+                // them (no sea connection). Skipping the connectivity check lets
+                // the random selection span both islands; the cross-island
+                // surcharge handles the disconnect at build time. Without this,
+                // requiring 5-of-6 regions for 5p would loop forever (GB has 4
+                // regions, IE has 2).
+                chosenMap.name === 'UK & Ireland'
             ) {
                 playRegions.add(region);
 
@@ -273,6 +290,23 @@ export function setup(
         );
 
         finalMap = filteredMap;
+
+        if (chosenMap.regionalPowerPlants) {
+            for (const region of playRegions) {
+                const replacements = chosenMap.regionalPowerPlants[region];
+                if (replacements) {
+                    for (const newPlant of replacements) {
+                        const swapIn = (arr: PowerPlant[]) => {
+                            const idx = arr.findIndex((p) => p.number === newPlant.number);
+                            if (idx !== -1) arr[idx] = { ...newPlant };
+                        };
+                        swapIn(actualMarket);
+                        swapIn(futureMarket);
+                        swapIn(powerPlantsDeck);
+                    }
+                }
+            }
+        }
     }
 
     const coalMarket = chosenMap.startingResources ? chosenMap.startingResources[0] : 24;
@@ -285,9 +319,17 @@ export function setup(
     const totalGarbage = chosenMap.startingSupply ? chosenMap.startingSupply[2] : 24;
     const totalUranium = chosenMap.startingSupply ? chosenMap.startingSupply[3] : 12;
 
-    const coalSupply = totalCoal - coalMarket;
-    const oilSupply = totalOil - oilMarket;
-    const garbageSupply = totalGarbage - garbageMarket;
+    // Korea: parallel North-side market and prices. Supply is shared — see below.
+    const coalMarketNorth = chosenMap.startingResourcesNorth?.[0];
+    const oilMarketNorth = chosenMap.startingResourcesNorth?.[1];
+    const garbageMarketNorth = chosenMap.startingResourcesNorth?.[2];
+
+    // Supply pools are shared between both sides for Korea. `startingSupply`
+    // represents the TOTAL cubes in the game; the supply pool is whatever is
+    // left after both markets are filled.
+    const coalSupply = totalCoal - coalMarket - (coalMarketNorth ?? 0);
+    const oilSupply = totalOil - oilMarket - (oilMarketNorth ?? 0);
+    const garbageSupply = totalGarbage - garbageMarket - (garbageMarketNorth ?? 0);
     const uraniumSupply = totalUranium - uraniumMarket;
 
     const coalPrices = cloneDeep(chosenMap.coalPrices ?? prices.coal);
@@ -295,6 +337,12 @@ export function setup(
     const garbagePrices = cloneDeep(chosenMap.garbagePrices ?? prices.garbage);
     const uraniumPrices = cloneDeep(chosenMap.uraniumPrices ?? prices.uranium);
 
+    const coalPricesNorth = chosenMap.coalPricesNorth ? cloneDeep(chosenMap.coalPricesNorth) : undefined;
+    const oilPricesNorth = chosenMap.oilPricesNorth ? cloneDeep(chosenMap.oilPricesNorth) : undefined;
+    const garbagePricesNorth = chosenMap.garbagePricesNorth ? cloneDeep(chosenMap.garbagePricesNorth) : undefined;
+
+    const isSouthAfrica = (forceMap || finalMap).name == 'South Africa';
+
     const G: GameState = {
         map: forceMap || finalMap,
         players,
@@ -305,6 +353,9 @@ export function setup(
         oilSupply,
         garbageSupply,
         uraniumSupply,
+        // South Africa: separate coal pool below the market. Starts empty;
+        // used coal returns here; refill draws from here first.
+        coalStorage: isSouthAfrica ? 0 : undefined,
         coalResupply,
         oilResupply,
         garbageResupply,
@@ -317,6 +368,17 @@ export function setup(
         oilPrices,
         garbagePrices,
         uraniumPrices,
+        // Korea: parallel North-side fields. Undefined for non-Korea maps.
+        // Supply is shared with the primary `*Supply` fields above.
+        coalMarketNorth,
+        oilMarketNorth,
+        garbageMarketNorth,
+        coalResupplyNorth,
+        oilResupplyNorth,
+        garbageResupplyNorth,
+        coalPricesNorth,
+        oilPricesNorth,
+        garbagePricesNorth,
         actualMarket,
         futureMarket,
         chosenPowerPlant: undefined,
@@ -334,6 +396,8 @@ export function setup(
         citiesToStep2:
             (forceMap || finalMap).name == 'Baden-Württemberg'
                 ? citiesToStep2BadenWurttemberg[numPlayers - 2]
+                : (forceMap || finalMap).name == 'UK & Ireland'
+                ? citiesToStep2UKIreland[numPlayers - 2]
                 : citiesToStep2[numPlayers - 2],
         citiesToEndGame: citiesToEndGame[numPlayers - 2],
         resourceResupply: [
@@ -341,6 +405,14 @@ export function setup(
             `[${coalResupply[p][1]}, ${oilResupply[p][1]}, ${garbageResupply[p][1]}, ${uraniumResupply[p][1]}]`,
             `[${coalResupply[p][2]}, ${oilResupply[p][2]}, ${garbageResupply[p][2]}, ${uraniumResupply[p][2]}]`,
         ],
+        resourceResupplyNorth:
+            coalResupplyNorth && oilResupplyNorth && garbageResupplyNorth
+                ? [
+                      `[${coalResupplyNorth[p][0]}, ${oilResupplyNorth[p][0]}, ${garbageResupplyNorth[p][0]}]`,
+                      `[${coalResupplyNorth[p][1]}, ${oilResupplyNorth[p][1]}, ${garbageResupplyNorth[p][1]}]`,
+                      `[${coalResupplyNorth[p][2]}, ${oilResupplyNorth[p][2]}, ${garbageResupplyNorth[p][2]}]`,
+                  ]
+                : undefined,
         paymentTable: cityIncome,
         variant,
         minimunBid: 0,
@@ -640,6 +712,12 @@ export function move(G: GameState, move: Move, playerNumber: number, isUndo = fa
                         player.passed = true;
                     }
 
+                    // Korea: end of this player's buying turn — clear the side lock
+                    // so the next player can pick freely.
+                    if (G.map.name == 'Korea') {
+                        G.chosenSide = undefined;
+                    }
+
                     if (G.players.filter((p) => !p.passed && !p.isDropped).length == 0) {
                         G.players.forEach((p) => {
                             p.passed = p.isDropped;
@@ -692,7 +770,17 @@ export function move(G: GameState, move: Move, playerNumber: number, isUndo = fa
                                     }
                                 }
 
-                                addPowerPlant(G);
+                                if (G.map.name == 'Europe') {
+                                    // Europe: do NOT draw a replacement from the deck.
+                                    // The future market shrinks from 5 to 4; reorganize
+                                    // the remaining 8 plants so actual stays at 4.
+                                    const market = [...G.actualMarket, ...G.futureMarket];
+                                    market.sort((a, b) => a.number - b.number);
+                                    G.actualMarket = market.slice(0, 4);
+                                    G.futureMarket = market.slice(4);
+                                } else {
+                                    addPowerPlant(G);
+                                }
                             }
                         }
 
@@ -774,12 +862,72 @@ export function move(G: GameState, move: Move, playerNumber: number, isUndo = fa
                     }
 
                     if (G.players.filter((p) => !p.passed && !p.isDropped).length == 0) {
-                        const coalResupplyValue = Math.min(
-                            G.coalSupply,
-                            G.coalResupply![G.players.length - 2][G.step - 1]
-                        );
-                        G.coalMarket += coalResupplyValue;
-                        G.coalSupply -= coalResupplyValue;
+                        // Resupply is also capped by remaining market capacity (the
+                        // prices array length minus current market size). Without
+                        // this, smaller markets like Korea's can overflow past the
+                        // number of slots and break price lookups.
+                        const coalCapSouth = (G.coalPrices?.length ?? prices[ResourceType.Coal].length) - G.coalMarket;
+                        const oilCapSouth = (G.oilPrices?.length ?? prices[ResourceType.Oil].length) - G.oilMarket;
+                        const garbageCapSouth =
+                            (G.garbagePrices?.length ?? prices[ResourceType.Garbage].length) - G.garbageMarket;
+                        const uraniumCapSouth =
+                            (G.uraniumPrices?.length ?? prices[ResourceType.Uranium].length) - G.uraniumMarket;
+
+                        // Korea: North restocks FIRST from the shared supply pool, then
+                        // South takes whatever remains. If supply runs short, South gets less.
+                        let coalResupplyNorthValue = 0;
+                        let oilResupplyNorthValue = 0;
+                        let garbageResupplyNorthValue = 0;
+                        if (G.coalResupplyNorth) {
+                            const coalCapNorth = G.coalPricesNorth!.length - G.coalMarketNorth!;
+                            const oilCapNorth = G.oilPricesNorth!.length - G.oilMarketNorth!;
+                            const garbageCapNorth = G.garbagePricesNorth!.length - G.garbageMarketNorth!;
+
+                            coalResupplyNorthValue = Math.min(
+                                G.coalSupply,
+                                G.coalResupplyNorth[G.players.length - 2][G.step - 1],
+                                coalCapNorth
+                            );
+                            G.coalMarketNorth! += coalResupplyNorthValue;
+                            G.coalSupply -= coalResupplyNorthValue;
+
+                            oilResupplyNorthValue = Math.min(
+                                G.oilSupply,
+                                G.oilResupplyNorth![G.players.length - 2][G.step - 1],
+                                oilCapNorth
+                            );
+                            G.oilMarketNorth! += oilResupplyNorthValue;
+                            G.oilSupply -= oilResupplyNorthValue;
+
+                            garbageResupplyNorthValue = Math.min(
+                                G.garbageSupply,
+                                G.garbageResupplyNorth![G.players.length - 2][G.step - 1],
+                                garbageCapNorth
+                            );
+                            G.garbageMarketNorth! += garbageResupplyNorthValue;
+                            G.garbageSupply -= garbageResupplyNorthValue;
+                        }
+
+                        // South Africa pulls from coalStorage first, then coalSupply.
+                        // Other maps just pull from coalSupply.
+                        let coalResupplyValue: number;
+                        if (G.coalStorage !== undefined) {
+                            const wantCoal = Math.min(G.coalResupply![G.players.length - 2][G.step - 1], coalCapSouth);
+                            const fromStorage = Math.min(G.coalStorage, wantCoal);
+                            const fromSupply = Math.min(G.coalSupply, wantCoal - fromStorage);
+                            coalResupplyValue = fromStorage + fromSupply;
+                            G.coalMarket += coalResupplyValue;
+                            G.coalStorage -= fromStorage;
+                            G.coalSupply -= fromSupply;
+                        } else {
+                            coalResupplyValue = Math.min(
+                                G.coalSupply,
+                                G.coalResupply![G.players.length - 2][G.step - 1],
+                                coalCapSouth
+                            );
+                            G.coalMarket += coalResupplyValue;
+                            G.coalSupply -= coalResupplyValue;
+                        }
 
                         let oilResupplyValue: number;
                         if (G.map.name == 'Middle East') {
@@ -799,14 +947,19 @@ export function move(G: GameState, move: Move, playerNumber: number, isUndo = fa
                                 }
                             }
                         } else {
-                            oilResupplyValue = Math.min(G.oilSupply, G.oilResupply![G.players.length - 2][G.step - 1]);
+                            oilResupplyValue = Math.min(
+                                G.oilSupply,
+                                G.oilResupply![G.players.length - 2][G.step - 1],
+                                oilCapSouth
+                            );
                             G.oilMarket += oilResupplyValue;
                             G.oilSupply -= oilResupplyValue;
                         }
 
                         const garbageResupplyValue = Math.min(
                             G.garbageSupply,
-                            G.garbageResupply![G.players.length - 2][G.step - 1]
+                            G.garbageResupply![G.players.length - 2][G.step - 1],
+                            garbageCapSouth
                         );
                         G.garbageMarket += garbageResupplyValue;
                         G.garbageSupply -= garbageResupplyValue;
@@ -819,16 +972,24 @@ export function move(G: GameState, move: Move, playerNumber: number, isUndo = fa
                         ) {
                             uraniumResupplyValue = Math.min(
                                 G.uraniumSupply,
-                                G.uraniumResupply![G.players.length - 2][G.step - 1]
+                                G.uraniumResupply![G.players.length - 2][G.step - 1],
+                                uraniumCapSouth
                             );
                             G.uraniumMarket += uraniumResupplyValue;
                             G.uraniumSupply -= uraniumResupplyValue;
                         }
 
-                        G.log.push({
-                            type: 'event',
-                            event: `Resupplying resources: [${coalResupplyValue}, ${oilResupplyValue}, ${garbageResupplyValue}, ${uraniumResupplyValue}].`,
-                        });
+                        if (G.coalResupplyNorth) {
+                            G.log.push({
+                                type: 'event',
+                                event: `Resupplying resources — North: [${coalResupplyNorthValue}, ${oilResupplyNorthValue}, ${garbageResupplyNorthValue}], South: [${coalResupplyValue}, ${oilResupplyValue}, ${garbageResupplyValue}, ${uraniumResupplyValue}].`,
+                            });
+                        } else {
+                            G.log.push({
+                                type: 'event',
+                                event: `Resupplying resources: [${coalResupplyValue}, ${oilResupplyValue}, ${garbageResupplyValue}, ${uraniumResupplyValue}].`,
+                            });
+                        }
 
                         if (G.map.name == 'Middle East' && G.step == 2 && G.futureMarket.length > 0) {
                             // If we aren't about to enter step 3, discard top two plants instead of one.
@@ -1145,10 +1306,28 @@ export function move(G: GameState, move: Move, playerNumber: number, isUndo = fa
             asserts<Moves.MoveBuyResource>(move);
             G.chosenResource = move.data.resource;
 
+            // Korea: lock the player to the side of their first buy this turn.
+            // Subsequent buys must come from the same side until they pass.
+            if (move.data.side) {
+                G.chosenSide = move.data.side;
+            }
+
+            const isNorth = move.data.side === 'north';
+
             let price: number;
             switch (move.data.resource) {
                 case ResourceType.Coal: {
-                    if (G.coalMarket == 0) {
+                    if (isNorth) {
+                        const coalPrices = G.coalPricesNorth!;
+                        price = coalPrices[coalPrices.length - G.coalMarketNorth!];
+                        player.coalLeft++;
+                        G.coalMarketNorth!--;
+                    } else if (move.data.fromStorage) {
+                        // South Africa: $8 flat from the storage pool below the market.
+                        price = 8;
+                        player.coalLeft++;
+                        G.coalStorage!--;
+                    } else if (G.coalMarket == 0) {
                         price = 8;
                         player.coalLeft++;
                         G.coalSupply--;
@@ -1164,31 +1343,46 @@ export function move(G: GameState, move: Move, playerNumber: number, isUndo = fa
                 }
 
                 case ResourceType.Oil: {
-                    const oilPrices = G.oilPrices ?? prices[ResourceType.Oil];
-                    price = oilPrices[oilPrices.length - G.oilMarket];
-                    player.oilLeft++;
-                    G.oilMarket--;
+                    if (isNorth) {
+                        const oilPrices = G.oilPricesNorth!;
+                        price = oilPrices[oilPrices.length - G.oilMarketNorth!];
+                        player.oilLeft++;
+                        G.oilMarketNorth!--;
+                    } else {
+                        const oilPrices = G.oilPrices ?? prices[ResourceType.Oil];
+                        price = oilPrices[oilPrices.length - G.oilMarket];
+                        player.oilLeft++;
+                        G.oilMarket--;
+                    }
                     break;
                 }
 
                 case ResourceType.Garbage: {
-                    const garbagePrices = G.garbagePrices ?? prices[ResourceType.Garbage];
-                    price = garbagePrices[garbagePrices.length - G.garbageMarket];
-
-                    // $1 cheaper for players in Wien in Central Europe
-                    if (G.map.name == 'Central Europe') {
-                        const wienCity = player.cities.filter((c) => c.name == 'Wien');
-                        if (wienCity?.length > 0) {
-                            price--;
+                    if (isNorth) {
+                        const garbagePrices = G.garbagePricesNorth!;
+                        price = garbagePrices[garbagePrices.length - G.garbageMarketNorth!];
+                        player.garbageLeft++;
+                        G.garbageMarketNorth!--;
+                    } else {
+                        const garbagePrices = G.garbagePrices ?? prices[ResourceType.Garbage];
+                        price = garbagePrices[garbagePrices.length - G.garbageMarket];
+
+                        // $1 cheaper for players in Wien in Central Europe
+                        if (G.map.name == 'Central Europe') {
+                            const wienCity = player.cities.filter((c) => c.name == 'Wien');
+                            if (wienCity?.length > 0) {
+                                price--;
+                            }
                         }
-                    }
 
-                    player.garbageLeft++;
-                    G.garbageMarket--;
+                        player.garbageLeft++;
+                        G.garbageMarket--;
+                    }
                     break;
                 }
 
                 case ResourceType.Uranium: {
+                    // Uranium is only available from the South market (or non-Korea maps).
                     const uraniumPrices = G.uraniumPrices ?? prices[ResourceType.Uranium];
                     price = uraniumPrices[uraniumPrices.length - G.uraniumMarket];
                     player.uraniumLeft++;
@@ -1224,8 +1418,14 @@ export function move(G: GameState, move: Move, playerNumber: number, isUndo = fa
             player.money -= move.data.price;
 
             if (G.options.trackTotalSpent) {
-                player.totalSpentCities += 10 + position * 5;
-                player.totalSpentConnections += move.data.price - (10 + position * 5);
+                const cityData = G.map.cities.find((c) => c.name == move.data.name)!;
+                if (cityData.singleOccupancy) {
+                    // SA cross-border: no house base — full price is "connection".
+                    player.totalSpentConnections += move.data.price;
+                } else {
+                    player.totalSpentCities += 10 + position * 5;
+                    player.totalSpentConnections += move.data.price - (10 + position * 5);
+                }
             }
 
             G.log.push({
@@ -1266,7 +1466,12 @@ export function move(G: GameState, move: Move, playerNumber: number, isUndo = fa
                 switch (resourceType) {
                     case ResourceType.Coal:
                         player.coalLeft--;
-                        G.coalSupply++;
+                        // SA: used coal returns to the separate storage pool below the market.
+                        if (G.coalStorage !== undefined) {
+                            G.coalStorage++;
+                        } else {
+                            G.coalSupply++;
+                        }
                         break;
 
                     case ResourceType.Oil:
@@ -1324,10 +1529,20 @@ export function move(G: GameState, move: Move, playerNumber: number, isUndo = fa
                 }
 
                 case MoveName.BuyResource: {
+                    const undoIsNorth = lastMove.data.side === 'north';
                     let price: number;
                     switch (lastMove.data.resource) {
                         case ResourceType.Coal:
-                            if (lastMove.fromSupply) {
+                            if (undoIsNorth) {
+                                player.coalLeft--;
+                                G.coalMarketNorth!++;
+                                const coalPrices = G.coalPricesNorth!;
+                                price = coalPrices[coalPrices.length - G.coalMarketNorth!];
+                            } else if (lastMove.data.fromStorage) {
+                                price = 8;
+                                player.coalLeft--;
+                                G.coalStorage!++;
+                            } else if (lastMove.fromSupply) {
                                 price = 8;
                                 player.coalLeft--;
                                 G.coalSupply++;
@@ -1341,24 +1556,38 @@ export function move(G: GameState, move: Move, playerNumber: number, isUndo = fa
                             break;
 
                         case ResourceType.Oil: {
-                            player.oilLeft--;
-                            G.oilMarket++;
-                            const oilPrices = G.oilPrices ?? prices[ResourceType.Oil];
-                            price = oilPrices[oilPrices.length - G.oilMarket];
+                            if (undoIsNorth) {
+                                player.oilLeft--;
+                                G.oilMarketNorth!++;
+                                const oilPrices = G.oilPricesNorth!;
+                                price = oilPrices[oilPrices.length - G.oilMarketNorth!];
+                            } else {
+                                player.oilLeft--;
+                                G.oilMarket++;
+                                const oilPrices = G.oilPrices ?? prices[ResourceType.Oil];
+                                price = oilPrices[oilPrices.length - G.oilMarket];
+                            }
                             break;
                         }
 
                         case ResourceType.Garbage: {
-                            player.garbageLeft--;
-                            G.garbageMarket++;
-                            const garbagePrices = G.garbagePrices ?? prices[ResourceType.Garbage];
-                            price = garbagePrices[garbagePrices.length - G.garbageMarket];
-
-                            // $1 cheaper for players in Wien in Central Europe
-                            if (G.map.name == 'Central Europe') {
-                                const wienCity = player.cities.filter((c) => c.name == 'Wien');
-                                if (wienCity?.length > 0) {
-                                    price--;
+                            if (undoIsNorth) {
+                                player.garbageLeft--;
+                                G.garbageMarketNorth!++;
+                                const garbagePrices = G.garbagePricesNorth!;
+                                price = garbagePrices[garbagePrices.length - G.garbageMarketNorth!];
+                            } else {
+                                player.garbageLeft--;
+                                G.garbageMarket++;
+                                const garbagePrices = G.garbagePrices ?? prices[ResourceType.Garbage];
+                                price = garbagePrices[garbagePrices.length - G.garbageMarket];
+
+                                // $1 cheaper for players in Wien in Central Europe
+                                if (G.map.name == 'Central Europe') {
+                                    const wienCity = player.cities.filter((c) => c.name == 'Wien');
+                                    if (wienCity?.length > 0) {
+                                        price--;
+                                    }
                                 }
                             }
 
@@ -1366,6 +1595,7 @@ export function move(G: GameState, move: Move, playerNumber: number, isUndo = fa
                         }
 
                         case ResourceType.Uranium: {
+                            // Uranium is only available from the South market (or non-Korea maps).
                             player.uraniumLeft--;
                             G.uraniumMarket++;
                             const uraniumPrices = G.uraniumPrices ?? prices[ResourceType.Uranium];
@@ -1385,6 +1615,22 @@ export function move(G: GameState, move: Move, playerNumber: number, isUndo = fa
                     }
 
                     G.log.pop();
+
+                    // Korea: keep chosenSide locked while the player still has
+                    // outstanding BuyResource moves this phase, but clear it once
+                    // the last one is undone so they can switch sides again.
+                    if (G.map.name == 'Korea' && G.chosenSide) {
+                        let stillCommitted = false;
+                        for (let i = G.log.length - 1; i >= 0; i--) {
+                            const entry = G.log[i];
+                            if (entry.type !== 'move') continue;
+                            stillCommitted = entry.player === playerNumber && entry.move.name === MoveName.BuyResource;
+                            break;
+                        }
+                        if (!stillCommitted) {
+                            G.chosenSide = undefined;
+                        }
+                    }
                     break;
                 }
 
@@ -2229,6 +2475,13 @@ function updateGameState(G: GameState) {
             `[${G.coalResupply[p][1]}, ${G.oilResupply[p][1]}, ${G.garbageResupply[p][1]}, ${G.uraniumResupply[p][1]}]`,
             `[${G.coalResupply[p][2]}, ${G.oilResupply[p][2]}, ${G.garbageResupply[p][2]}, ${G.uraniumResupply[p][2]}]`,
         ];
+        if (G.coalResupplyNorth && G.oilResupplyNorth && G.garbageResupplyNorth) {
+            G.resourceResupplyNorth = [
+                `[${G.coalResupplyNorth[p][0]}, ${G.oilResupplyNorth[p][0]}, ${G.garbageResupplyNorth[p][0]}]`,
+                `[${G.coalResupplyNorth[p][1]}, ${G.oilResupplyNorth[p][1]}, ${G.garbageResupplyNorth[p][1]}]`,
+                `[${G.coalResupplyNorth[p][2]}, ${G.oilResupplyNorth[p][2]}, ${G.garbageResupplyNorth[p][2]}]`,
+            ];
+        }
     }
 }
 

package/src/gamestate.ts

@@ -16,14 +16,16 @@ export type MapName =
     | 'China'
     | 'Benelux'
     | 'Russia'
-    | 'Central Europe';
+    | 'Central Europe'
+    | 'Baden-Württemberg'
+    | 'Northern Europe'
+    | 'Korea'
+    | 'Europe'
+    | 'North America'
+    | 'South Africa'
+    | 'UK & Ireland';
 // | 'Australia'
-// | 'Baden-Württemberg'
 // | 'Japan'
-// | 'Korea'
-// | 'Northern Europe'
-// | 'South Africa'
-// | 'UK & Ireland'
 export type Variant = 'original' | 'recharged';
 
 export interface GameOptions {
@@ -121,6 +123,11 @@ export interface GameState {
     oilSupply: number;
     garbageSupply: number;
     uraniumSupply: number;
+    // South Africa: coal used to power plants returns here instead of coalSupply.
+    // Market refills draw from this pool first, then fall back to coalSupply.
+    // Players can always buy a coal cube from here for $8 (on top of the normal
+    // market). Undefined on non-SA maps.
+    coalStorage?: number;
     coalMarket: number;
     oilMarket: number;
     garbageMarket: number;
@@ -129,6 +136,22 @@ export interface GameState {
     oilResupply?: number[][];
     garbageResupply?: number[][];
     uraniumResupply?: number[][];
+    // Korea: parallel North-side markets and resupply tables. The primary
+    // `*Market`/`*Resupply` fields above act as the South side. The supply pools
+    // (`coalSupply` etc.) are SHARED — used cubes return there and both sides
+    // restock from the same pool, with North restocking first.
+    // North has no uranium track (nuclear plants are banned on the North side).
+    coalMarketNorth?: number;
+    oilMarketNorth?: number;
+    garbageMarketNorth?: number;
+    coalResupplyNorth?: number[][];
+    oilResupplyNorth?: number[][];
+    garbageResupplyNorth?: number[][];
+    // Korea: per-side price arrays. Each side's market has different slot counts
+    // per price space, so the price arrays differ. (No uranium on the North side.)
+    coalPricesNorth?: number[];
+    oilPricesNorth?: number[];
+    garbagePricesNorth?: number[];
     coalPrices?: number[];
     oilPrices?: number[];
     garbagePrices?: number[];
@@ -137,6 +160,9 @@ export interface GameState {
     futureMarket: PowerPlant[];
     chosenPowerPlant: PowerPlant | undefined;
     chosenResource?: ResourceType | undefined; // Used for India map, where only one resource can be bought at a time.
+    // Korea: locked to the side a player bought their first resource from this turn.
+    // All subsequent buys this turn must be from the same side. Cleared when the player passes.
+    chosenSide?: 'north' | 'south';
     currentBid: number | undefined;
     auctioningPlayer: number | undefined;
     step: number;
@@ -151,6 +177,7 @@ export interface GameState {
     citiesToEndGame: number;
     citiesBuiltInCurrentRound?: number; // In India, if the players build too many cities in a single round, a power outage will occur.
     resourceResupply: string[];
+    resourceResupplyNorth?: string[]; // Korea: per-step North resupply, parallel to resourceResupply (no uranium).
     paymentTable: number[];
     minimunBid: number;
     plantDiscountActive: boolean;