powergrid-engine 1.10.0 → 1.12.0

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];
@@ -35,6 +38,11 @@ export interface GameMap {
     resupply?: number[][][];
     startingResources?: number[];
     startingSupply?: number[];
+    resupplyNorth?: number[][][];
+    startingResourcesNorth?: number[];
+    coalPricesNorth?: number[];
+    oilPricesNorth?: number[];
+    garbagePricesNorth?: number[];
     maxPriceAvailable?: number[];
     coalPrices?: number[];
     oilPrices?: number[];
@@ -45,7 +53,15 @@ export interface GameMap {
         futureMarket: PowerPlant[];
         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,14 +8,21 @@ 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");
 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,
@@ -31,12 +38,14 @@ exports.maps = [
     russia_1.map,
     centraleurope_1.map,
     badenwurttemberg_1.map,
+    northerneurope_1.map,
+    korea_1.map,
+    europe_1.map,
+    northamerica_1.map,
+    southafrica_1.map,
+    ukireland_1.map,
     // australia,
     // japan,
-    // korea,
-    // northerneurope,
-    // southafrica,
-    // ukireland,
 ];
 exports.mapsRecharged = [
     america_1.mapRecharged,
@@ -53,11 +62,13 @@ exports.mapsRecharged = [
     russia_1.map,
     centraleurope_1.map,
     badenwurttemberg_1.map,
+    northerneurope_1.map,
+    korea_1.map,
+    europe_1.map,
+    northamerica_1.map,
+    southafrica_1.map,
+    ukireland_1.map,
     // australia,
     // china,
     // japan,
-    // korea,
-    // northerneurope,
-    // southafrica,
-    // ukireland,
 ];

package/dist/src/move.d.ts

@@ -22,6 +22,8 @@ export declare namespace Moves {
         name: MoveName.BuyResource;
         data: {
             resource: ResourceType;
+            side?: 'north' | 'south';
+            fromStorage?: boolean;
         };
         fromSupply?: boolean;
     }

package/package.json

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

package/src/available-moves.ts

@@ -11,6 +11,12 @@ export interface AvailableMoves {
     [MoveName.BuyResource]?: {
         resource: ResourceType;
         price: number;
+        // 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]?: {
@@ -88,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);
                         }
@@ -135,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];
@@ -157,7 +188,7 @@ export function availableMoves(G: GameState, player: Player): AvailableMoves {
                 break;
             }
 
-            const toBuy: { resource: ResourceType }[] = [];
+            const toBuy: { resource: ResourceType; side?: 'north' | 'south'; fromStorage?: boolean }[] = [];
             let maxPriceAvailable: number;
             if (G.map.maxPriceAvailable) {
                 maxPriceAvailable = G.map.maxPriceAvailable[G.step - 1];
@@ -165,7 +196,13 @@ export function availableMoves(G: GameState, player: Player): AvailableMoves {
                 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 = G.coalPrices ?? prices[ResourceType.Coal];
@@ -176,9 +213,11 @@ export function availableMoves(G: GameState, player: Player): AvailableMoves {
                     player.coalCapacity + player.hybridCapacity > hybridCapacityUsed + player.coalLeft &&
                     price <= maxPriceAvailable
                 ) {
-                    toBuy.push({ resource: ResourceType.Coal });
+                    toBuy.push(
+                        isKorea ? { resource: ResourceType.Coal, side: 'south' } : { resource: 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;
@@ -191,7 +230,37 @@ export function availableMoves(G: GameState, player: Player): AvailableMoves {
                 }
             }
 
-            if (G.oilMarket > 0) {
+            // 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;
+                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: ResourceType.Coal, side: 'north' });
+                }
+            }
+
+            if (allowSouth && G.oilMarket > 0) {
                 const hybridCapacityUsed =
                     player.hybridCapacity > 0 ? Math.max(0, player.coalLeft - player.coalCapacity) : 0;
                 const oilPrices = G.oilPrices ?? prices[ResourceType.Oil];
@@ -202,11 +271,28 @@ export function availableMoves(G: GameState, player: Player): AvailableMoves {
                     player.oilCapacity + player.hybridCapacity > hybridCapacityUsed + player.oilLeft &&
                     price <= maxPriceAvailable
                 ) {
-                    toBuy.push({ resource: ResourceType.Oil });
+                    toBuy.push(
+                        isKorea ? { resource: ResourceType.Oil, side: 'south' } : { resource: ResourceType.Oil }
+                    );
                 }
             }
 
-            if (G.garbageMarket > 0) {
+            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: ResourceType.Oil, side: 'north' });
+                }
+            }
+
+            if (allowSouth && G.garbageMarket > 0) {
                 const garbagePrices = G.garbagePrices ?? prices[ResourceType.Garbage];
                 let price = garbagePrices[garbagePrices.length - G.garbageMarket];
 
@@ -223,11 +309,27 @@ export function availableMoves(G: GameState, player: Player): AvailableMoves {
                     player.garbageCapacity > player.garbageLeft &&
                     price <= maxPriceAvailable
                 ) {
-                    toBuy.push({ resource: ResourceType.Garbage });
+                    toBuy.push(
+                        isKorea ? { resource: ResourceType.Garbage, side: 'south' } : { resource: 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: ResourceType.Garbage, side: 'north' });
                 }
             }
 
-            if (G.uraniumMarket > 0) {
+            // Uranium is South only (or non-Korea maps).
+            if (allowSouth && G.uraniumMarket > 0) {
                 const uraniumPrices = G.uraniumPrices ?? prices[ResourceType.Uranium];
                 const price = uraniumPrices[uraniumPrices.length - G.uraniumMarket];
                 if (
@@ -235,7 +337,9 @@ export function availableMoves(G: GameState, player: Player): AvailableMoves {
                     player.uraniumCapacity > player.uraniumLeft &&
                     price <= maxPriceAvailable
                 ) {
-                    toBuy.push({ resource: ResourceType.Uranium });
+                    toBuy.push(
+                        isKorea ? { resource: ResourceType.Uranium, side: 'south' } : { resource: ResourceType.Uranium }
+                    );
                 }
             }
 
@@ -280,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 = {