powergrid-engine 1.11.0 → 1.12.0

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

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

package/dist/src/available-moves.js

@@ -66,6 +66,15 @@ function availableMoves(G, player) {
                                 canBid = canBid.filter((p) => p.type != gamestate_1.PowerPlantType.Uranium);
                             }
                         }
+                        // No nuclear plants for Republic of Ireland (Green region) on UK&I.
+                        // The restriction lifts as soon as the player has any non-Green city
+                        // (Scotland/Wales/England/Northern Ireland = Brown/Yellow/Red/Pink/Orange).
+                        if (G.map.name == 'UK & Ireland') {
+                            const playerCities = player.cities.map((c) => G.map.cities.find((c_) => c_.name == c.name));
+                            if (playerCities.every((c) => c.region == 'green')) {
+                                canBid = canBid.filter((p) => p.type != gamestate_1.PowerPlantType.Uranium);
+                            }
+                        }
                         if (canBid.length > 0) {
                             moves[move_1.MoveName.ChoosePowerPlant] = canBid.map((p) => p.number);
                         }
@@ -107,6 +116,14 @@ function availableMoves(G, player) {
                                 moves[move_1.MoveName.Bid] = undefined;
                             }
                         }
+                        // No nuclear plants for Republic of Ireland (Green region) on UK&I.
+                        if (G.map.name == 'UK & Ireland') {
+                            const playerCities = player.cities.map((c) => G.map.cities.find((c_) => c_.name == c.name));
+                            if (playerCities.every((c) => c.region == 'green') &&
+                                G.chosenPowerPlant.type == gamestate_1.PowerPlantType.Uranium) {
+                                moves[move_1.MoveName.Bid] = undefined;
+                            }
+                        }
                         if (G.options.fastBid) {
                             if (player.id != G.auctioningPlayer) {
                                 moves[move_1.MoveName.Pass] = [true];
@@ -159,6 +176,17 @@ function availableMoves(G, player) {
                     }
                 }
             }
+            // South Africa: $8 flat coal from the storage pool below the market.
+            // Always available alongside the regular market option (not gated on
+            // market being empty), as long as there are cubes in storage.
+            if (allowSouth && G.coalStorage !== undefined && G.coalStorage > 0) {
+                const hybridCapacityUsed = player.hybridCapacity > 0 ? Math.max(0, player.oilLeft - player.oilCapacity) : 0;
+                if (player.money >= 8 &&
+                    player.coalCapacity + player.hybridCapacity > hybridCapacityUsed + player.coalLeft &&
+                    8 <= maxPriceAvailable) {
+                    toBuy.push({ resource: gamestate_1.ResourceType.Coal, fromStorage: true });
+                }
+            }
             if (allowNorth && G.coalMarketNorth > 0) {
                 const hybridCapacityUsed = player.hybridCapacity > 0 ? Math.max(0, player.oilLeft - player.oilCapacity) : 0;
                 const coalPrices = G.coalPricesNorth;
@@ -256,6 +284,44 @@ function availableMoves(G, player) {
                         }
                         return;
                     }
+                    // UK & Ireland: starting a network on an island where the player has
+                    // no city yet pays the first-house base + crossIslandSurcharge. There
+                    // is no sea edge so dijkstra reports the target city as unreachable
+                    // (price=9999); we override here. The first build ever (player.cities
+                    // empty) goes through the normal first-build path and pays no surcharge.
+                    if (cityData.island && G.map.crossIslandSurcharge !== undefined && player.cities.length > 0) {
+                        const playerIslands = new Set(player.cities
+                            .map((c) => { var _a; return (_a = G.map.cities.find((mc) => mc.name == c.name)) === null || _a === void 0 ? void 0 : _a.island; })
+                            .filter((i) => !!i));
+                        if (!playerIslands.has(cityData.island)) {
+                            city.price = 10 + othersCount * 5 + G.map.crossIslandSurcharge;
+                            if (othersCount == G.step) {
+                                city.price = 9999;
+                            }
+                            if (player.cities.find((c) => c.name == city.name)) {
+                                city.price = 9999;
+                            }
+                            return;
+                        }
+                    }
+                    // South Africa's cross-border foreign-country spaces: cap at 1 occupant
+                    // ever, and the dijkstra path cost (30 via the cross-border edge) is the
+                    // complete cost — no 10+position*5 house base is added. Players cannot
+                    // start in one of these (you have to build INTO South Africa first).
+                    if (cityData.singleOccupancy) {
+                        if (player.cities.length == 0) {
+                            city.price = 9999;
+                            return;
+                        }
+                        if (othersCount >= 1) {
+                            city.price = 9999;
+                            return;
+                        }
+                        if (player.cities.find((c) => c.name == city.name)) {
+                            city.price = 9999;
+                        }
+                        return;
+                    }
                     city.price += 10 + othersCount * 5;
                     if (othersCount == G.step) {
                         city.price = 9999;

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];
@@ -220,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') {
@@ -280,6 +288,7 @@ function setup(numPlayers, { fastBid = false, map = 'USA', variant = 'original',
     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,
@@ -290,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,
@@ -329,7 +341,9 @@ 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]}]`,
@@ -648,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) {
@@ -742,9 +767,23 @@ function move(G, move, playerNumber, isUndo = false) {
                             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;
+                        // 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) {
@@ -1077,6 +1116,12 @@ function move(G, move, playerNumber, isUndo = false) {
                         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++;
@@ -1156,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',
@@ -1188,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--;
@@ -1242,6 +1300,11 @@ function move(G, move, playerNumber, isUndo = false) {
                                 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--;

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' | 'Baden-Württemberg' | 'Northern Europe' | 'Korea';
+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;

package/dist/src/maps/europe.d.ts

@@ -0,0 +1,62 @@
+import { GameMap } from './../maps';
+export declare enum Regions {
+    Pink = "pink",
+    Red = "red",
+    Brown = "brown",
+    Yellow = "yellow",
+    Orange = "orange",
+    Blue = "blue",
+    Green = "green"
+}
+export declare enum Cities {
+    Glasgow = "Glasgow",
+    Dublin = "Dublin",
+    Birmingham = "Birmingham",
+    London = "London",
+    Randstad = "Randstad",
+    Vlaanderen = "Vlaanderen",
+    RheinRuhr = "Rhein-Ruhr",
+    Paris = "Paris",
+    Bordeaux = "Bordeaux",
+    Lyon = "Lyon",
+    Marseille = "Marseille",
+    Lisboa = "Lisboa",
+    Madrid = "Madrid",
+    Barcelona = "Barcelona",
+    Bremen = "Bremen",
+    Berlin = "Berlin",
+    RheinMain = "Rhein-Main",
+    Stuttgart = "Stuttgart",
+    Praha = "Praha",
+    Katowice = "Katowice",
+    München = "M\u00FCnchen",
+    Zürich = "Z\u00FCrich",
+    Milano = "Milano",
+    Roma = "Roma",
+    Napoli = "Napoli",
+    Wien = "Wien",
+    Budapest = "Budapest",
+    Zagreb = "Zagreb",
+    Oslo = "Oslo",
+    Stockholm = "Stockholm",
+    Helsinki = "Helsinki",
+    Tallinn = "Tallinn",
+    Kobenhavn = "K\u00F8benhavn",
+    Riga = "Riga",
+    StPetersburg = "St. Petersburg",
+    Minsk = "Minsk",
+    Moskwa = "Moskwa",
+    Warszawa = "Warszawa",
+    Kyjiv = "Kyjiv",
+    Kharkiv = "Kharkiv",
+    Odessa = "Odessa",
+    Bucuresti = "Bucure\u015Fti",
+    Beograd = "Beograd",
+    Sofia = "Sofia",
+    Tirana = "Tirana",
+    Athina = "Athina",
+    Istanbul = "Istanbul",
+    Izmir = "Izmir",
+    Ankara = "Ankara"
+}
+export declare const map: GameMap;