powergrid-engine 1.9.9 → 1.11.0

package/dist/src/available-moves.d.ts

@@ -8,6 +8,7 @@ export interface AvailableMoves {
     [MoveName.BuyResource]?: {
         resource: ResourceType;
         price: number;
+        side?: 'north' | 'south';
     }[];
     [MoveName.Build]?: {
         name: string;

package/dist/src/available-moves.js

@@ -135,17 +135,22 @@ function availableMoves(G, player) {
             else {
                 maxPriceAvailable = 16;
             }
-            if (G.coalMarket > 0) {
+            // Korea: each side is offered separately, tagged with the side. The
+            // player's chosenSide locks them to one side once they make a buy.
+            const isKorea = G.coalResupplyNorth !== undefined;
+            const allowSouth = !isKorea || G.chosenSide !== 'north';
+            const allowNorth = isKorea && G.chosenSide !== 'south';
+            if (allowSouth && G.coalMarket > 0) {
                 const hybridCapacityUsed = player.hybridCapacity > 0 ? Math.max(0, player.oilLeft - player.oilCapacity) : 0;
                 const coalPrices = (_c = G.coalPrices) !== null && _c !== void 0 ? _c : prices_1.default[gamestate_1.ResourceType.Coal];
                 const price = coalPrices[coalPrices.length - G.coalMarket];
                 if (player.money >= price &&
                     player.coalCapacity + player.hybridCapacity > hybridCapacityUsed + player.coalLeft &&
                     price <= maxPriceAvailable) {
-                    toBuy.push({ resource: gamestate_1.ResourceType.Coal });
+                    toBuy.push(isKorea ? { resource: gamestate_1.ResourceType.Coal, side: 'south' } : { resource: gamestate_1.ResourceType.Coal });
                 }
             }
-            else {
+            else if (allowSouth) {
                 if (G.options.variant == 'recharged' && G.map.name == 'USA' && G.coalSupply > 0) {
                     const hybridCapacityUsed = player.hybridCapacity > 0 ? Math.max(0, player.oilLeft - player.oilCapacity) : 0;
                     if (player.money >= 8 &&
@@ -154,17 +159,37 @@ function availableMoves(G, player) {
                     }
                 }
             }
-            if (G.oilMarket > 0) {
+            if (allowNorth && G.coalMarketNorth > 0) {
+                const hybridCapacityUsed = player.hybridCapacity > 0 ? Math.max(0, player.oilLeft - player.oilCapacity) : 0;
+                const coalPrices = G.coalPricesNorth;
+                const price = coalPrices[coalPrices.length - G.coalMarketNorth];
+                if (player.money >= price &&
+                    player.coalCapacity + player.hybridCapacity > hybridCapacityUsed + player.coalLeft &&
+                    price <= maxPriceAvailable) {
+                    toBuy.push({ resource: gamestate_1.ResourceType.Coal, side: 'north' });
+                }
+            }
+            if (allowSouth && G.oilMarket > 0) {
                 const hybridCapacityUsed = player.hybridCapacity > 0 ? Math.max(0, player.coalLeft - player.coalCapacity) : 0;
                 const oilPrices = (_d = G.oilPrices) !== null && _d !== void 0 ? _d : prices_1.default[gamestate_1.ResourceType.Oil];
                 const price = oilPrices[oilPrices.length - G.oilMarket];
                 if (player.money >= price &&
                     player.oilCapacity + player.hybridCapacity > hybridCapacityUsed + player.oilLeft &&
                     price <= maxPriceAvailable) {
-                    toBuy.push({ resource: gamestate_1.ResourceType.Oil });
+                    toBuy.push(isKorea ? { resource: gamestate_1.ResourceType.Oil, side: 'south' } : { resource: gamestate_1.ResourceType.Oil });
+                }
+            }
+            if (allowNorth && G.oilMarketNorth > 0) {
+                const hybridCapacityUsed = player.hybridCapacity > 0 ? Math.max(0, player.coalLeft - player.coalCapacity) : 0;
+                const oilPrices = G.oilPricesNorth;
+                const price = oilPrices[oilPrices.length - G.oilMarketNorth];
+                if (player.money >= price &&
+                    player.oilCapacity + player.hybridCapacity > hybridCapacityUsed + player.oilLeft &&
+                    price <= maxPriceAvailable) {
+                    toBuy.push({ resource: gamestate_1.ResourceType.Oil, side: 'north' });
                 }
             }
-            if (G.garbageMarket > 0) {
+            if (allowSouth && G.garbageMarket > 0) {
                 const garbagePrices = (_e = G.garbagePrices) !== null && _e !== void 0 ? _e : prices_1.default[gamestate_1.ResourceType.Garbage];
                 let price = garbagePrices[garbagePrices.length - G.garbageMarket];
                 // $1 cheaper for players in Wien in Central Europe
@@ -177,16 +202,26 @@ function availableMoves(G, player) {
                 if (player.money >= price &&
                     player.garbageCapacity > player.garbageLeft &&
                     price <= maxPriceAvailable) {
-                    toBuy.push({ resource: gamestate_1.ResourceType.Garbage });
+                    toBuy.push(isKorea ? { resource: gamestate_1.ResourceType.Garbage, side: 'south' } : { resource: gamestate_1.ResourceType.Garbage });
+                }
+            }
+            if (allowNorth && G.garbageMarketNorth > 0) {
+                const garbagePrices = G.garbagePricesNorth;
+                const price = garbagePrices[garbagePrices.length - G.garbageMarketNorth];
+                if (player.money >= price &&
+                    player.garbageCapacity > player.garbageLeft &&
+                    price <= maxPriceAvailable) {
+                    toBuy.push({ resource: gamestate_1.ResourceType.Garbage, side: 'north' });
                 }
             }
-            if (G.uraniumMarket > 0) {
+            // Uranium is South only (or non-Korea maps).
+            if (allowSouth && G.uraniumMarket > 0) {
                 const uraniumPrices = (_f = G.uraniumPrices) !== null && _f !== void 0 ? _f : prices_1.default[gamestate_1.ResourceType.Uranium];
                 const price = uraniumPrices[uraniumPrices.length - G.uraniumMarket];
                 if (player.money >= price &&
                     player.uraniumCapacity > player.uraniumLeft &&
                     price <= maxPriceAvailable) {
-                    toBuy.push({ resource: gamestate_1.ResourceType.Uranium });
+                    toBuy.push(isKorea ? { resource: gamestate_1.ResourceType.Uranium, side: 'south' } : { resource: gamestate_1.ResourceType.Uranium });
                 }
             }
             if (toBuy.length > 0) {

package/dist/src/engine.js

@@ -70,7 +70,7 @@ function defaultSetupDeck(numPlayers, variant, rng, useNewRechargedSetup) {
 }
 exports.defaultSetupDeck = defaultSetupDeck;
 function setup(numPlayers, { fastBid = false, map = 'USA', variant = 'original', showMoney = false, useNewRechargedSetup = true, trackTotalSpent = true, randomizeMap = false, }, seed, forceDeck, forceMap) {
-    var _a, _b, _c, _d;
+    var _a, _b, _c, _d, _e, _f, _g;
     seed = seed !== null && seed !== void 0 ? seed : Math.random().toString();
     const rng = seedrandom_1.default(seed);
     const chosenMap = lodash_1.cloneDeep(variant == 'original' ? maps_1.maps.find((m) => m.name == map) : maps_1.mapsRecharged.find((m) => m.name == map));
@@ -129,6 +129,15 @@ function setup(numPlayers, { fastBid = false, map = 'USA', variant = 'original',
     let oilResupply;
     let garbageResupply;
     let uraniumResupply;
+    // Korea: parallel North-side resupply tables (no uranium row).
+    let coalResupplyNorth;
+    let oilResupplyNorth;
+    let garbageResupplyNorth;
+    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];
@@ -227,6 +236,23 @@ function setup(numPlayers, { fastBid = false, map = 'USA', variant = 'original',
             .map((n) => chosenMap.cities.find((city) => city.name == n).region)
             .every((r) => playRegions.has(r)));
         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) => {
+                            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;
     const oilMarket = chosenMap.startingResources ? chosenMap.startingResources[1] : 18;
@@ -236,14 +262,24 @@ function setup(numPlayers, { fastBid = false, map = 'USA', variant = 'original',
     const totalOil = chosenMap.startingSupply ? chosenMap.startingSupply[1] : 24;
     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 = (_a = chosenMap.startingResourcesNorth) === null || _a === void 0 ? void 0 : _a[0];
+    const oilMarketNorth = (_b = chosenMap.startingResourcesNorth) === null || _b === void 0 ? void 0 : _b[1];
+    const garbageMarketNorth = (_c = chosenMap.startingResourcesNorth) === null || _c === void 0 ? void 0 : _c[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 !== null && coalMarketNorth !== void 0 ? coalMarketNorth : 0);
+    const oilSupply = totalOil - oilMarket - (oilMarketNorth !== null && oilMarketNorth !== void 0 ? oilMarketNorth : 0);
+    const garbageSupply = totalGarbage - garbageMarket - (garbageMarketNorth !== null && garbageMarketNorth !== void 0 ? garbageMarketNorth : 0);
     const uraniumSupply = totalUranium - uraniumMarket;
-    const coalPrices = lodash_1.cloneDeep((_a = chosenMap.coalPrices) !== null && _a !== void 0 ? _a : prices_1.default.coal);
-    const oilPrices = lodash_1.cloneDeep((_b = chosenMap.oilPrices) !== null && _b !== void 0 ? _b : prices_1.default.oil);
-    const garbagePrices = lodash_1.cloneDeep((_c = chosenMap.garbagePrices) !== null && _c !== void 0 ? _c : prices_1.default.garbage);
-    const uraniumPrices = lodash_1.cloneDeep((_d = chosenMap.uraniumPrices) !== null && _d !== void 0 ? _d : prices_1.default.uranium);
+    const coalPrices = lodash_1.cloneDeep((_d = chosenMap.coalPrices) !== null && _d !== void 0 ? _d : prices_1.default.coal);
+    const oilPrices = lodash_1.cloneDeep((_e = chosenMap.oilPrices) !== null && _e !== void 0 ? _e : prices_1.default.oil);
+    const garbagePrices = lodash_1.cloneDeep((_f = chosenMap.garbagePrices) !== null && _f !== void 0 ? _f : prices_1.default.garbage);
+    const uraniumPrices = lodash_1.cloneDeep((_g = chosenMap.uraniumPrices) !== null && _g !== void 0 ? _g : prices_1.default.uranium);
+    const coalPricesNorth = chosenMap.coalPricesNorth ? lodash_1.cloneDeep(chosenMap.coalPricesNorth) : undefined;
+    const oilPricesNorth = chosenMap.oilPricesNorth ? lodash_1.cloneDeep(chosenMap.oilPricesNorth) : undefined;
+    const garbagePricesNorth = chosenMap.garbagePricesNorth ? lodash_1.cloneDeep(chosenMap.garbagePricesNorth) : undefined;
     const G = {
         map: forceMap || finalMap,
         players,
@@ -266,6 +302,17 @@ function setup(numPlayers, { fastBid = false, map = 'USA', variant = 'original',
         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,
@@ -289,6 +336,13 @@ function setup(numPlayers, { fastBid = false, map = 'USA', variant = 'original',
             `[${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,
@@ -340,7 +394,7 @@ function currentPlayers(G) {
 }
 exports.currentPlayers = currentPlayers;
 function move(G, move, playerNumber, isUndo = false) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t;
     const player = G.players[playerNumber];
     const available = (_a = player.availableMoves) === null || _a === void 0 ? void 0 : _a[move.name];
     updateGameState(G);
@@ -545,6 +599,11 @@ function move(G, move, playerNumber, isUndo = false) {
                     else {
                         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;
@@ -656,7 +715,34 @@ function move(G, move, playerNumber, isUndo = false) {
                         player.targetCitiesPowered = 0;
                     }
                     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]);
+                        // 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 = ((_d = (_c = G.coalPrices) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : prices_1.default[gamestate_1.ResourceType.Coal].length) - G.coalMarket;
+                        const oilCapSouth = ((_f = (_e = G.oilPrices) === null || _e === void 0 ? void 0 : _e.length) !== null && _f !== void 0 ? _f : prices_1.default[gamestate_1.ResourceType.Oil].length) - G.oilMarket;
+                        const garbageCapSouth = ((_h = (_g = G.garbagePrices) === null || _g === void 0 ? void 0 : _g.length) !== null && _h !== void 0 ? _h : prices_1.default[gamestate_1.ResourceType.Garbage].length) - G.garbageMarket;
+                        const uraniumCapSouth = ((_k = (_j = G.uraniumPrices) === null || _j === void 0 ? void 0 : _j.length) !== null && _k !== void 0 ? _k : prices_1.default[gamestate_1.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;
+                        }
+                        const coalResupplyValue = Math.min(G.coalSupply, G.coalResupply[G.players.length - 2][G.step - 1], coalCapSouth);
                         G.coalMarket += coalResupplyValue;
                         G.coalSupply -= coalResupplyValue;
                         let oilResupplyValue;
@@ -678,25 +764,33 @@ function move(G, move, playerNumber, isUndo = false) {
                             }
                         }
                         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]);
+                        const garbageResupplyValue = Math.min(G.garbageSupply, G.garbageResupply[G.players.length - 2][G.step - 1], garbageCapSouth);
                         G.garbageMarket += garbageResupplyValue;
                         G.garbageSupply -= garbageResupplyValue;
                         let uraniumResupplyValue = 0;
                         if (G.options.variant != 'recharged' ||
                             (G.options.map != 'Germany' && G.options.map != 'Italy') ||
                             !G.card39Bought) {
-                            uraniumResupplyValue = Math.min(G.uraniumSupply, G.uraniumResupply[G.players.length - 2][G.step - 1]);
+                            uraniumResupplyValue = Math.min(G.uraniumSupply, 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.
                             let powerPlantToPush = G.futureMarket.pop();
@@ -968,17 +1062,29 @@ function move(G, move, playerNumber, isUndo = false) {
         case move_1.MoveName.BuyResource: {
             utils_1.asserts(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;
             switch (move.data.resource) {
                 case gamestate_1.ResourceType.Coal: {
-                    if (G.coalMarket == 0) {
+                    if (isNorth) {
+                        const coalPrices = G.coalPricesNorth;
+                        price = coalPrices[coalPrices.length - G.coalMarketNorth];
+                        player.coalLeft++;
+                        G.coalMarketNorth--;
+                    }
+                    else if (G.coalMarket == 0) {
                         price = 8;
                         player.coalLeft++;
                         G.coalSupply--;
                         move.fromSupply = true;
                     }
                     else {
-                        const coalPrices = (_c = G.coalPrices) !== null && _c !== void 0 ? _c : prices_1.default[gamestate_1.ResourceType.Coal];
+                        const coalPrices = (_l = G.coalPrices) !== null && _l !== void 0 ? _l : prices_1.default[gamestate_1.ResourceType.Coal];
                         price = coalPrices[coalPrices.length - G.coalMarket];
                         player.coalLeft++;
                         G.coalMarket--;
@@ -986,28 +1092,45 @@ function move(G, move, playerNumber, isUndo = false) {
                     break;
                 }
                 case gamestate_1.ResourceType.Oil: {
-                    const oilPrices = (_d = G.oilPrices) !== null && _d !== void 0 ? _d : prices_1.default[gamestate_1.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 = (_m = G.oilPrices) !== null && _m !== void 0 ? _m : prices_1.default[gamestate_1.ResourceType.Oil];
+                        price = oilPrices[oilPrices.length - G.oilMarket];
+                        player.oilLeft++;
+                        G.oilMarket--;
+                    }
                     break;
                 }
                 case gamestate_1.ResourceType.Garbage: {
-                    const garbagePrices = (_e = G.garbagePrices) !== null && _e !== void 0 ? _e : prices_1.default[gamestate_1.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 === null || wienCity === void 0 ? void 0 : wienCity.length) > 0) {
-                            price--;
+                    if (isNorth) {
+                        const garbagePrices = G.garbagePricesNorth;
+                        price = garbagePrices[garbagePrices.length - G.garbageMarketNorth];
+                        player.garbageLeft++;
+                        G.garbageMarketNorth--;
+                    }
+                    else {
+                        const garbagePrices = (_o = G.garbagePrices) !== null && _o !== void 0 ? _o : prices_1.default[gamestate_1.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 === null || wienCity === void 0 ? void 0 : wienCity.length) > 0) {
+                                price--;
+                            }
                         }
+                        player.garbageLeft++;
+                        G.garbageMarket--;
                     }
-                    player.garbageLeft++;
-                    G.garbageMarket--;
                     break;
                 }
                 case gamestate_1.ResourceType.Uranium: {
-                    const uraniumPrices = (_f = G.uraniumPrices) !== null && _f !== void 0 ? _f : prices_1.default[gamestate_1.ResourceType.Uranium];
+                    // Uranium is only available from the South market (or non-Korea maps).
+                    const uraniumPrices = (_p = G.uraniumPrices) !== null && _p !== void 0 ? _p : prices_1.default[gamestate_1.ResourceType.Uranium];
                     price = uraniumPrices[uraniumPrices.length - G.uraniumMarket];
                     player.uraniumLeft++;
                     G.uraniumMarket--;
@@ -1109,10 +1232,17 @@ function move(G, move, playerNumber, isUndo = false) {
                     break;
                 }
                 case move_1.MoveName.BuyResource: {
+                    const undoIsNorth = lastMove.data.side === 'north';
                     let price;
                     switch (lastMove.data.resource) {
                         case gamestate_1.ResourceType.Coal:
-                            if (lastMove.fromSupply) {
+                            if (undoIsNorth) {
+                                player.coalLeft--;
+                                G.coalMarketNorth++;
+                                const coalPrices = G.coalPricesNorth;
+                                price = coalPrices[coalPrices.length - G.coalMarketNorth];
+                            }
+                            else if (lastMove.fromSupply) {
                                 price = 8;
                                 player.coalLeft--;
                                 G.coalSupply++;
@@ -1120,35 +1250,52 @@ function move(G, move, playerNumber, isUndo = false) {
                             else {
                                 player.coalLeft--;
                                 G.coalMarket++;
-                                const coalPrices = (_g = G.coalPrices) !== null && _g !== void 0 ? _g : prices_1.default[gamestate_1.ResourceType.Coal];
+                                const coalPrices = (_q = G.coalPrices) !== null && _q !== void 0 ? _q : prices_1.default[gamestate_1.ResourceType.Coal];
                                 price = coalPrices[coalPrices.length - G.coalMarket];
                             }
                             break;
                         case gamestate_1.ResourceType.Oil: {
-                            player.oilLeft--;
-                            G.oilMarket++;
-                            const oilPrices = (_h = G.oilPrices) !== null && _h !== void 0 ? _h : prices_1.default[gamestate_1.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 = (_r = G.oilPrices) !== null && _r !== void 0 ? _r : prices_1.default[gamestate_1.ResourceType.Oil];
+                                price = oilPrices[oilPrices.length - G.oilMarket];
+                            }
                             break;
                         }
                         case gamestate_1.ResourceType.Garbage: {
-                            player.garbageLeft--;
-                            G.garbageMarket++;
-                            const garbagePrices = (_j = G.garbagePrices) !== null && _j !== void 0 ? _j : prices_1.default[gamestate_1.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 === null || wienCity === void 0 ? void 0 : 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 = (_s = G.garbagePrices) !== null && _s !== void 0 ? _s : prices_1.default[gamestate_1.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 === null || wienCity === void 0 ? void 0 : wienCity.length) > 0) {
+                                        price--;
+                                    }
                                 }
                             }
                             break;
                         }
                         case gamestate_1.ResourceType.Uranium: {
+                            // Uranium is only available from the South market (or non-Korea maps).
                             player.uraniumLeft--;
                             G.uraniumMarket++;
-                            const uraniumPrices = (_k = G.uraniumPrices) !== null && _k !== void 0 ? _k : prices_1.default[gamestate_1.ResourceType.Uranium];
+                            const uraniumPrices = (_t = G.uraniumPrices) !== null && _t !== void 0 ? _t : prices_1.default[gamestate_1.ResourceType.Uranium];
                             price = uraniumPrices[uraniumPrices.length - G.uraniumMarket];
                             break;
                         }
@@ -1161,6 +1308,22 @@ function move(G, move, playerNumber, isUndo = false) {
                         G.chosenResource = undefined;
                     }
                     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 === move_1.MoveName.BuyResource;
+                            break;
+                        }
+                        if (!stillCommitted) {
+                            G.chosenSide = undefined;
+                        }
+                    }
                     break;
                 }
                 case move_1.MoveName.Build: {
@@ -1905,6 +2068,13 @@ function updateGameState(G) {
             `[${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]}]`,
+            ];
+        }
     }
 }
 function fastAuction(G, player, bid) {

package/dist/src/gamestate.d.ts

@@ -2,7 +2,7 @@ import { AvailableMoves } from './available-moves';
 import { LogItem } from './log';
 import { GameMap } from './maps';
 import { Move } from './move';
-export declare type MapName = 'USA' | 'Germany' | 'Brazil' | 'Spain & Portugal' | 'France' | 'Italy' | 'Quebec' | 'Middle East' | 'India' | 'China' | 'Benelux' | 'Russia' | 'Central Europe';
+export declare type MapName = 'USA' | 'Germany' | 'Brazil' | 'Spain & Portugal' | 'France' | 'Italy' | 'Quebec' | 'Middle East' | 'India' | 'China' | 'Benelux' | 'Russia' | 'Central Europe' | 'Baden-Württemberg' | 'Northern Europe' | 'Korea';
 export declare type Variant = 'original' | 'recharged';
 export interface GameOptions {
     fastBid?: boolean;
@@ -100,6 +100,15 @@ export interface GameState {
     oilResupply?: number[][];
     garbageResupply?: number[][];
     uraniumResupply?: number[][];
+    coalMarketNorth?: number;
+    oilMarketNorth?: number;
+    garbageMarketNorth?: number;
+    coalResupplyNorth?: number[][];
+    oilResupplyNorth?: number[][];
+    garbageResupplyNorth?: number[][];
+    coalPricesNorth?: number[];
+    oilPricesNorth?: number[];
+    garbagePricesNorth?: number[];
     coalPrices?: number[];
     oilPrices?: number[];
     garbagePrices?: number[];
@@ -108,6 +117,7 @@ export interface GameState {
     futureMarket: PowerPlant[];
     chosenPowerPlant: PowerPlant | undefined;
     chosenResource?: ResourceType | undefined;
+    chosenSide?: 'north' | 'south';
     currentBid: number | undefined;
     auctioningPlayer: number | undefined;
     step: number;
@@ -122,6 +132,7 @@ export interface GameState {
     citiesToEndGame: number;
     citiesBuiltInCurrentRound?: number;
     resourceResupply: string[];
+    resourceResupplyNorth?: string[];
     paymentTable: number[];
     minimunBid: number;
     plantDiscountActive: boolean;