powergrid-engine 1.10.0 → 1.12.0

package/dist/src/engine.js

@@ -18,6 +18,7 @@ const utils_1 = require("./utils");
 exports.playerColors = ['limegreen', 'mediumorchid', 'red', 'dodgerblue', 'yellow', 'brown'];
 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];
@@ -70,7 +71,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 +130,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];
@@ -211,7 +221,14 @@ function setup(numPlayers, { fastBid = false, map = 'USA', variant = 'original',
         while (playRegions.size != Math.min(regionsInPlay[p], regions.length)) {
             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);
                 // Avoid italy Red Green Blue
                 if (chosenMap.name === 'Italy') {
@@ -227,6 +244,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 +270,25 @@ 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 isSouthAfrica = (forceMap || finalMap).name == 'South Africa';
     const G = {
         map: forceMap || finalMap,
         players,
@@ -254,6 +299,9 @@ function setup(numPlayers, { fastBid = false, map = 'USA', variant = 'original',
         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,
@@ -266,6 +314,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,
@@ -282,13 +341,22 @@ function setup(numPlayers, { fastBid = false, map = 'USA', variant = 'original',
         auctionSkips: 0,
         citiesToStep2: (forceMap || finalMap).name == 'Baden-Württemberg'
             ? citiesToStep2BadenWurttemberg[numPlayers - 2]
-            : citiesToStep2[numPlayers - 2],
+            : (forceMap || finalMap).name == 'UK & Ireland'
+                ? citiesToStep2UKIreland[numPlayers - 2]
+                : citiesToStep2[numPlayers - 2],
         citiesToEndGame: citiesToEndGame[numPlayers - 2],
         resourceResupply: [
             `[${coalResupply[p][0]}, ${oilResupply[p][0]}, ${garbageResupply[p][0]}, ${uraniumResupply[p][0]}]`,
             `[${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 +408,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 +613,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;
@@ -589,7 +662,18 @@ function move(G, move, playerNumber, isUndo = false) {
                                         G.powerPlantsDeck.unshift(getPowerPlant(18));
                                     }
                                 }
-                                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);
+                                }
                             }
                         }
                         if (maxCities >= G.citiesToEndGame) {
@@ -656,9 +740,50 @@ 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]);
-                        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 = ((_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;
+                        }
+                        // South Africa pulls from coalStorage first, then coalSupply.
+                        // Other maps just pull from coalSupply.
+                        let coalResupplyValue;
+                        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;
                         if (G.map.name == 'Middle East') {
                             if (G.oilMarket == 0) {
@@ -678,25 +803,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 +1101,35 @@ 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 (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--;
                         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 +1137,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--;
@@ -1033,8 +1201,15 @@ function move(G, move, playerNumber, isUndo = false) {
             player.cities.push({ name: move.data.name, position });
             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({
                 type: 'move',
@@ -1065,7 +1240,13 @@ function move(G, move, playerNumber, isUndo = false) {
                 switch (resourceType) {
                     case gamestate_1.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 gamestate_1.ResourceType.Oil:
                         player.oilLeft--;
@@ -1109,10 +1290,22 @@ 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.data.fromStorage) {
+                                price = 8;
+                                player.coalLeft--;
+                                G.coalStorage++;
+                            }
+                            else if (lastMove.fromSupply) {
                                 price = 8;
                                 player.coalLeft--;
                                 G.coalSupply++;
@@ -1120,35 +1313,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 +1371,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 +2131,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' | 'Europe' | 'North America' | 'South Africa' | 'UK & Ireland';
 export declare type Variant = 'original' | 'recharged';
 export interface GameOptions {
     fastBid?: boolean;
@@ -92,6 +92,7 @@ export interface GameState {
     oilSupply: number;
     garbageSupply: number;
     uraniumSupply: number;
+    coalStorage?: number;
     coalMarket: number;
     oilMarket: number;
     garbageMarket: number;
@@ -100,6 +101,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 +118,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 +133,7 @@ export interface GameState {
     citiesToEndGame: number;
     citiesBuiltInCurrentRound?: number;
     resourceResupply: string[];
+    resourceResupplyNorth?: string[];
     paymentTable: number[];
     minimunBid: number;
     plantDiscountActive: boolean;