powergrid-engine 1.11.0 → 1.12.1

package/dist/src/maps.d.ts

@@ -6,6 +6,8 @@ export interface City {
     x: number;
     y: number;
     transregional?: boolean;
+    singleOccupancy?: boolean;
+    island?: string;
 }
 export interface Connection {
     nodes: string[];
@@ -28,6 +30,7 @@ export interface GameMap {
     powerPlantMarketPosition?: [number, number];
     actualMarketWidth?: number;
     mapPosition?: [number, number];
+    mapRotation?: number;
     buttonsPosition?: [number, number];
     playerBoardsPosition?: [number, number];
     supplyPosition?: [number, number];
@@ -51,7 +54,14 @@ export interface GameMap {
         powerPlantsDeck: PowerPlant[];
     };
     regionalPowerPlants?: Record<string, PowerPlant[]>;
+    crossIslandSurcharge?: number;
     mapSpecificRules?: string;
+    devBackdrop?: {
+        src: string;
+        width: number;
+        height: number;
+        opacity?: number;
+    };
 }
 export declare const maps: GameMap[];
 export declare const mapsRecharged: GameMap[];

package/dist/src/maps.js

@@ -8,6 +8,7 @@ const benelux_1 = require("./maps/benelux");
 const brazil_1 = require("./maps/brazil");
 const centraleurope_1 = require("./maps/centraleurope");
 const china_1 = require("./maps/china");
+const europe_1 = require("./maps/europe");
 const france_1 = require("./maps/france");
 const germany_1 = require("./maps/germany");
 const indian_1 = require("./maps/indian");
@@ -15,10 +16,13 @@ const italy_1 = require("./maps/italy");
 // import { map as japan } from './maps/japan';
 const korea_1 = require("./maps/korea");
 const middleeast_1 = require("./maps/middleeast");
+const northamerica_1 = require("./maps/northamerica");
 const northerneurope_1 = require("./maps/northerneurope");
 const quebec_1 = require("./maps/quebec");
 const russia_1 = require("./maps/russia");
+const southafrica_1 = require("./maps/southafrica");
 const spainportugal_1 = require("./maps/spainportugal");
+const ukireland_1 = require("./maps/ukireland");
 exports.maps = [
     america_1.map,
     germany_1.map,
@@ -36,10 +40,12 @@ exports.maps = [
     badenwurttemberg_1.map,
     northerneurope_1.map,
     korea_1.map,
+    europe_1.map,
+    northamerica_1.map,
+    southafrica_1.map,
+    ukireland_1.map,
     // australia,
     // japan,
-    // southafrica,
-    // ukireland,
 ];
 exports.mapsRecharged = [
     america_1.mapRecharged,
@@ -58,9 +64,11 @@ exports.mapsRecharged = [
     badenwurttemberg_1.map,
     northerneurope_1.map,
     korea_1.map,
+    europe_1.map,
+    northamerica_1.map,
+    southafrica_1.map,
+    ukireland_1.map,
     // australia,
     // china,
     // japan,
-    // southafrica,
-    // ukireland,
 ];

package/dist/src/move.d.ts

@@ -23,6 +23,7 @@ export declare namespace Moves {
         data: {
             resource: ResourceType;
             side?: 'north' | 'south';
+            fromStorage?: boolean;
         };
         fromSupply?: boolean;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "powergrid-engine",
-  "version": "1.11.0",
+  "version": "1.12.1",
   "description": "An engine for Power Grid",
   "main": "dist/index.js",
   "types": "index.ts",

package/src/available-moves.ts

@@ -14,6 +14,9 @@ export interface AvailableMoves {
         // Korea: which side's market this buy option draws from.
         // Omitted on all other maps.
         side?: 'north' | 'south';
+        // South Africa: $8 flat buy from the coal storage pool below the market.
+        // Distinct from the regular market buy (which can also be offered alongside).
+        fromStorage?: boolean;
     }[];
     [MoveName.Build]?: { name: string; price: number }[];
     [MoveName.UsePowerPlant]?: {
@@ -91,6 +94,18 @@ export function availableMoves(G: GameState, player: Player): AvailableMoves {
                             }
                         }
 
+                        // 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 != PowerPlantType.Uranium);
+                            }
+                        }
+
                         if (canBid.length > 0) {
                             moves[MoveName.ChoosePowerPlant] = canBid.map((p) => p.number);
                         }
@@ -138,6 +153,19 @@ export function availableMoves(G: GameState, player: Player): AvailableMoves {
                             }
                         }
 
+                        // 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 == PowerPlantType.Uranium
+                            ) {
+                                moves[MoveName.Bid] = undefined;
+                            }
+                        }
+
                         if (G.options.fastBid) {
                             if (player.id != G.auctioningPlayer) {
                                 moves[MoveName.Pass] = [true];
@@ -160,7 +188,7 @@ export function availableMoves(G: GameState, player: Player): AvailableMoves {
                 break;
             }
 
-            const toBuy: { resource: ResourceType; side?: 'north' | 'south' }[] = [];
+            const toBuy: { resource: ResourceType; side?: 'north' | 'south'; fromStorage?: boolean }[] = [];
             let maxPriceAvailable: number;
             if (G.map.maxPriceAvailable) {
                 maxPriceAvailable = G.map.maxPriceAvailable[G.step - 1];
@@ -202,6 +230,21 @@ export function availableMoves(G: GameState, player: Player): AvailableMoves {
                 }
             }
 
+            // 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: ResourceType.Coal, fromStorage: true });
+                }
+            }
+
             if (allowNorth && G.coalMarketNorth! > 0) {
                 const hybridCapacityUsed =
                     player.hybridCapacity > 0 ? Math.max(0, player.oilLeft - player.oilCapacity) : 0;
@@ -341,6 +384,50 @@ export function availableMoves(G: GameState, player: Player): AvailableMoves {
                         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) => G.map.cities.find((mc) => mc.name == c.name)?.island)
+                                .filter((i): i is string => !!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) {

package/src/engine.spec.ts

@@ -141,6 +141,23 @@ describe('Engine', () => {
         expect(ended(G)).to.be.false;
     });
 
+    it('should place UK & Ireland Step 3 card third from last with two plants below it', () => {
+        // UK & Ireland rules: the Step 3 card (plant 99) goes at deck.length - 3
+        // so two plants sit below it, and Step 3 fires two auctions earlier than
+        // a standard "Step 3 at the bottom" deck.
+        const G = setup(5, { map: 'UK & Ireland', variant: 'recharged', randomizeMap: false }, 'ukireland-test-seed');
+
+        const step3Idx = G.powerPlantsDeck.findIndex((p) => p.number === 99);
+        expect(step3Idx).to.equal(G.powerPlantsDeck.length - 3);
+
+        // The two plants below Step 3 are real plants (not another Step 3 card or
+        // undefined slots).
+        expect(G.powerPlantsDeck[step3Idx + 1]).to.exist;
+        expect(G.powerPlantsDeck[step3Idx + 2]).to.exist;
+        expect(G.powerPlantsDeck[step3Idx + 1].number).to.not.equal(99);
+        expect(G.powerPlantsDeck[step3Idx + 2].number).to.not.equal(99);
+    });
+
     it('should allow invalid move when isUndo is true', () => {
         const game = undo;
         const options: GameOptions = {

package/src/engine.ts

@@ -15,6 +15,7 @@ export const playerColors = ['limegreen', 'mediumorchid', 'red', 'dodgerblue', '
 
 const citiesToStep2 = [10, 7, 7, 7, 6];
 const citiesToStep2BadenWurttemberg = [9, 6, 6, 6, 5];
+const citiesToStep2UKIreland = [7, 7, 7, 7, 6];
 const citiesToEndGame = [21, 17, 17, 15, 14];
 const cityIncome = [10, 22, 33, 44, 54, 64, 73, 82, 90, 98, 105, 112, 118, 124, 129, 134, 138, 142, 145, 148, 150, 150];
 const regionsInPlay = [3, 3, 4, 5, 5];
@@ -94,9 +95,12 @@ export function setup(
     seed = seed ?? Math.random().toString();
     const rng = seedrandom(seed);
 
-    const chosenMap = cloneDeep(
-        variant == 'original' ? maps.find((m) => m.name == map)! : mapsRecharged.find((m) => m.name == map)!
-    );
+    const chosenMapRaw =
+        variant == 'original' ? maps.find((m) => m.name == map) : mapsRecharged.find((m) => m.name == map);
+    if (!chosenMapRaw) {
+        throw new Error(`Map "${map}" not found for variant "${variant}"`);
+    }
+    const chosenMap = cloneDeep(chosenMapRaw);
 
     let actualMarket: PowerPlant[];
     let futureMarket: PowerPlant[];
@@ -260,7 +264,14 @@ export function setup(
             const region = regions[Math.floor(rng() * regions.length)];
             if (
                 playRegions.size == 0 ||
-                regionConnections[regions.indexOf(region)].some((con) => playRegions.has(con))
+                regionConnections[regions.indexOf(region)].some((con) => playRegions.has(con)) ||
+                // UK & Ireland: regions on the two islands have no edges between
+                // them (no sea connection). Skipping the connectivity check lets
+                // the random selection span both islands; the cross-island
+                // surcharge handles the disconnect at build time. Without this,
+                // requiring 5-of-6 regions for 5p would loop forever (GB has 4
+                // regions, IE has 2).
+                chosenMap.name === 'UK & Ireland'
             ) {
                 playRegions.add(region);
 
@@ -333,6 +344,8 @@ export function setup(
     const oilPricesNorth = chosenMap.oilPricesNorth ? cloneDeep(chosenMap.oilPricesNorth) : undefined;
     const garbagePricesNorth = chosenMap.garbagePricesNorth ? cloneDeep(chosenMap.garbagePricesNorth) : undefined;
 
+    const isSouthAfrica = (forceMap || finalMap).name == 'South Africa';
+
     const G: GameState = {
         map: forceMap || finalMap,
         players,
@@ -343,6 +356,9 @@ export function setup(
         oilSupply,
         garbageSupply,
         uraniumSupply,
+        // South Africa: separate coal pool below the market. Starts empty;
+        // used coal returns here; refill draws from here first.
+        coalStorage: isSouthAfrica ? 0 : undefined,
         coalResupply,
         oilResupply,
         garbageResupply,
@@ -383,6 +399,8 @@ export function setup(
         citiesToStep2:
             (forceMap || finalMap).name == 'Baden-Württemberg'
                 ? citiesToStep2BadenWurttemberg[numPlayers - 2]
+                : (forceMap || finalMap).name == 'UK & Ireland'
+                ? citiesToStep2UKIreland[numPlayers - 2]
                 : citiesToStep2[numPlayers - 2],
         citiesToEndGame: citiesToEndGame[numPlayers - 2],
         resourceResupply: [
@@ -755,7 +773,17 @@ export function move(G: GameState, move: Move, playerNumber: number, isUndo = fa
                                     }
                                 }
 
-                                addPowerPlant(G);
+                                if (G.map.name == 'Europe') {
+                                    // Europe: do NOT draw a replacement from the deck.
+                                    // The future market shrinks from 5 to 4; reorganize
+                                    // the remaining 8 plants so actual stays at 4.
+                                    const market = [...G.actualMarket, ...G.futureMarket];
+                                    market.sort((a, b) => a.number - b.number);
+                                    G.actualMarket = market.slice(0, 4);
+                                    G.futureMarket = market.slice(4);
+                                } else {
+                                    addPowerPlant(G);
+                                }
                             }
                         }
 
@@ -883,13 +911,26 @@ export function move(G: GameState, move: Move, playerNumber: number, isUndo = fa
                             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: number;
+                        if (G.coalStorage !== undefined) {
+                            const wantCoal = Math.min(G.coalResupply![G.players.length - 2][G.step - 1], coalCapSouth);
+                            const fromStorage = Math.min(G.coalStorage, wantCoal);
+                            const fromSupply = Math.min(G.coalSupply, wantCoal - fromStorage);
+                            coalResupplyValue = fromStorage + fromSupply;
+                            G.coalMarket += coalResupplyValue;
+                            G.coalStorage -= fromStorage;
+                            G.coalSupply -= fromSupply;
+                        } else {
+                            coalResupplyValue = Math.min(
+                                G.coalSupply,
+                                G.coalResupply![G.players.length - 2][G.step - 1],
+                                coalCapSouth
+                            );
+                            G.coalMarket += coalResupplyValue;
+                            G.coalSupply -= coalResupplyValue;
+                        }
 
                         let oilResupplyValue: number;
                         if (G.map.name == 'Middle East') {
@@ -1284,6 +1325,11 @@ export function move(G: GameState, move: Move, playerNumber: number, isUndo = fa
                         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++;
@@ -1375,8 +1421,14 @@ export function move(G: GameState, move: Move, playerNumber: number, isUndo = fa
             player.money -= move.data.price;
 
             if (G.options.trackTotalSpent) {
-                player.totalSpentCities += 10 + position * 5;
-                player.totalSpentConnections += move.data.price - (10 + position * 5);
+                const cityData = G.map.cities.find((c) => c.name == move.data.name)!;
+                if (cityData.singleOccupancy) {
+                    // SA cross-border: no house base — full price is "connection".
+                    player.totalSpentConnections += move.data.price;
+                } else {
+                    player.totalSpentCities += 10 + position * 5;
+                    player.totalSpentConnections += move.data.price - (10 + position * 5);
+                }
             }
 
             G.log.push({
@@ -1417,7 +1469,12 @@ export function move(G: GameState, move: Move, playerNumber: number, isUndo = fa
                 switch (resourceType) {
                     case ResourceType.Coal:
                         player.coalLeft--;
-                        G.coalSupply++;
+                        // SA: used coal returns to the separate storage pool below the market.
+                        if (G.coalStorage !== undefined) {
+                            G.coalStorage++;
+                        } else {
+                            G.coalSupply++;
+                        }
                         break;
 
                     case ResourceType.Oil:
@@ -1484,6 +1541,10 @@ export function move(G: GameState, move: Move, playerNumber: number, isUndo = fa
                                 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--;

package/src/gamestate.ts

@@ -19,11 +19,13 @@ export type MapName =
     | 'Central Europe'
     | 'Baden-Württemberg'
     | 'Northern Europe'
-    | 'Korea';
+    | 'Korea'
+    | 'Europe'
+    | 'North America'
+    | 'South Africa'
+    | 'UK & Ireland';
 // | 'Australia'
 // | 'Japan'
-// | 'South Africa'
-// | 'UK & Ireland'
 export type Variant = 'original' | 'recharged';
 
 export interface GameOptions {
@@ -121,6 +123,11 @@ export interface GameState {
     oilSupply: number;
     garbageSupply: number;
     uraniumSupply: number;
+    // South Africa: coal used to power plants returns here instead of coalSupply.
+    // Market refills draw from this pool first, then fall back to coalSupply.
+    // Players can always buy a coal cube from here for $8 (on top of the normal
+    // market). Undefined on non-SA maps.
+    coalStorage?: number;
     coalMarket: number;
     oilMarket: number;
     garbageMarket: number;