powergrid-engine 1.12.0 → 1.13.0

package/dist/src/available-moves.js

@@ -9,7 +9,7 @@ const gamestate_1 = require("./gamestate");
 const move_1 = require("./move");
 const prices_1 = __importDefault(require("./prices"));
 function availableMoves(G, player) {
-    var _a, _b, _c, _d, _e, _f;
+    var _a, _b, _c, _d, _e, _f, _g;
     const moves = {};
     const lastLog = G.log[G.log.length - 1];
     if (lastLog.type == 'move' && G.currentPlayers.includes(player.id)) {
@@ -260,9 +260,36 @@ function availableMoves(G, player) {
         }
         case gamestate_1.Phase.Building: {
             if (player.cities.length < 21) {
-                let toBuild = player.cities.length == 0
-                    ? G.map.cities.map((c) => ({ name: c.name, price: 0 }))
-                    : dijkstra(G, player).map((c) => ({ name: c.name, price: c.price }));
+                const isJapan = G.map.name === 'Japan';
+                const japanStartingCities = isJapan ? new Set((_g = G.map.startingCities) !== null && _g !== void 0 ? _g : []) : new Set();
+                let toBuild;
+                if (player.cities.length == 0) {
+                    // Japan: first house must go in one of the 6 designated starting cities.
+                    const candidates = isJapan
+                        ? G.map.cities.filter((c) => japanStartingCities.has(c.name))
+                        : G.map.cities;
+                    toBuild = candidates.map((c) => ({ name: c.name, price: 0 }));
+                }
+                else if (isJapan && G.round === 1) {
+                    // Japan round 1: any additional house must also be a starting city.
+                    // Players cannot extend to adjacent non-starting cities until round 2.
+                    toBuild = G.map.cities
+                        .filter((c) => japanStartingCities.has(c.name))
+                        .map((c) => ({ name: c.name, price: 0 }));
+                }
+                else {
+                    toBuild = dijkstra(G, player).map((c) => ({ name: c.name, price: c.price }));
+                    // Japan: a player may start a second disconnected network at any available
+                    // starting city, paying only the slot cost (no connection fee).
+                    if (isJapan &&
+                        countNetworks(G.map.connections, player.cities.map((c) => c.name)) < 2) {
+                        toBuild.forEach((city) => {
+                            if (japanStartingCities.has(city.name)) {
+                                city.price = 0;
+                            }
+                        });
+                    }
+                }
                 toBuild.forEach((city) => {
                     const cityData = G.map.cities.find((c) => c.name == city.name);
                     const othersCount = G.players.filter((p) => p.cities.find((c) => city.name == c.name)).length;
@@ -322,10 +349,15 @@ function availableMoves(G, player) {
                         }
                         return;
                     }
-                    city.price += 10 + othersCount * 5;
-                    if (othersCount == G.step) {
+                    const slotCosts = cityData.slotCosts;
+                    const maxSlotsThisStep = cityData.stepSlots ? cityData.stepSlots[G.step - 1] : G.step;
+                    const totalSlots = slotCosts ? slotCosts.length : 3;
+                    if (othersCount >= maxSlotsThisStep || othersCount >= totalSlots) {
                         city.price = 9999;
                     }
+                    else {
+                        city.price += slotCosts ? slotCosts[othersCount] : 10 + othersCount * 5;
+                    }
                     if (player.cities.find((c) => c.name == city.name)) {
                         city.price = 9999;
                     }
@@ -441,6 +473,32 @@ function availableMoves(G, player) {
     return moves;
 }
 exports.availableMoves = availableMoves;
+function countNetworks(connections, cityNames) {
+    const citySet = new Set(cityNames);
+    const visited = new Set();
+    let count = 0;
+    for (const city of cityNames) {
+        if (visited.has(city))
+            continue;
+        count++;
+        const stack = [city];
+        while (stack.length > 0) {
+            const current = stack.pop();
+            if (visited.has(current))
+                continue;
+            visited.add(current);
+            for (const conn of connections) {
+                if (conn.nodes.includes(current)) {
+                    const neighbor = conn.nodes.find((n) => n !== current);
+                    if (citySet.has(neighbor) && !visited.has(neighbor)) {
+                        stack.push(neighbor);
+                    }
+                }
+            }
+        }
+    }
+    return count;
+}
 function dijkstra(G, player) {
     const nodes = G.map.cities.map((c) => ({
         name: c.name,

package/dist/src/engine.js

@@ -74,7 +74,11 @@ function setup(numPlayers, { fastBid = false, map = 'USA', variant = 'original',
     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));
+    const chosenMapRaw = variant == 'original' ? maps_1.maps.find((m) => m.name == map) : maps_1.mapsRecharged.find((m) => m.name == map);
+    if (!chosenMapRaw) {
+        throw new Error(`Map "${map}" not found for variant "${variant}"`);
+    }
+    const chosenMap = lodash_1.cloneDeep(chosenMapRaw);
     let actualMarket;
     let futureMarket;
     let powerPlantsDeck;
@@ -532,7 +536,7 @@ function move(G, move, playerNumber, isUndo = false) {
                                 G.map.name != 'China' &&
                                 G.map.name != 'Russia') {
                                 if (G.map.name == 'Baden-Württemberg') {
-                                    // Baden-Württemberg: remove the two lowest plants
+                                    // Baden-Württemberg: remove the two lowest plants when no one buys.
                                     const removed = [];
                                     for (let i = 0; i < 2 && G.actualMarket.length > 0; i++) {
                                         removed.push(G.actualMarket[0].number);

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' | 'Europe' | 'North America' | 'South Africa' | 'UK & Ireland';
+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' | 'Japan';
 export declare type Variant = 'original' | 'recharged';
 export interface GameOptions {
     fastBid?: boolean;

package/dist/src/maps/badenwurttemberg.js

@@ -56,8 +56,24 @@ exports.map = {
         { name: Cities.Sigmarincen, region: Regions.Purple, x: 1111, y: 1803 },
         { name: Cities.Konstanz, region: Regions.Purple, x: 1088, y: 2163 },
         { name: Cities.Ulm, region: Regions.Purple, x: 1541, y: 1499 },
-        { name: Cities.Augsburg, region: Regions.Purple, x: 1830, y: 1505, transregional: true },
-        { name: Cities.Basel, region: Regions.Green, x: 103, y: 2271, transregional: true },
+        {
+            name: Cities.Augsburg,
+            region: Regions.Purple,
+            x: 1830,
+            y: 1505,
+            transregional: true,
+            slotCosts: [15, 20],
+            stepSlots: [0, 1, 2],
+        },
+        {
+            name: Cities.Basel,
+            region: Regions.Green,
+            x: 103,
+            y: 2271,
+            transregional: true,
+            slotCosts: [15, 20],
+            stepSlots: [0, 1, 2],
+        },
         { name: Cities.Waldshuttiencen, region: Regions.Green, x: 502, y: 2166 },
         { name: Cities.Singen, region: Regions.Green, x: 874, y: 2084 },
         { name: Cities.Tuttlincen, region: Regions.Green, x: 870, y: 1854 },
@@ -70,8 +86,24 @@ exports.map = {
         { name: Cities.Sinsheim, region: Regions.Red, x: 920, y: 785 },
         { name: Cities.Heidelber, region: Regions.Red, x: 817, y: 660 },
         { name: Cities.Mannheim, region: Regions.Red, x: 710, y: 540 },
-        { name: Cities.Luowigshafen, region: Regions.Red, x: 579, y: 588, transregional: true },
-        { name: Cities.Nurnberg, region: Regions.Blue, x: 1837, y: 771, transregional: true },
+        {
+            name: Cities.Luowigshafen,
+            region: Regions.Red,
+            x: 579,
+            y: 588,
+            transregional: true,
+            slotCosts: [15, 20],
+            stepSlots: [0, 1, 2],
+        },
+        {
+            name: Cities.Nurnberg,
+            region: Regions.Blue,
+            x: 1837,
+            y: 771,
+            transregional: true,
+            slotCosts: [15, 20],
+            stepSlots: [0, 1, 2],
+        },
         { name: Cities.Ellwangen, region: Regions.Blue, x: 1637, y: 1030 },
         { name: Cities.Coppingen, region: Regions.Blue, x: 1387, y: 1233 },
         { name: Cities.Reutlincen, region: Regions.Blue, x: 1107, y: 1443 },
@@ -81,7 +113,15 @@ exports.map = {
         { name: Cities.Laha, region: Regions.Yellow, x: 296, y: 1575 },
         { name: Cities.Badenbaden, region: Regions.Yellow, x: 554, y: 1259 },
         { name: Cities.Offenburg, region: Regions.Yellow, x: 395, y: 1422 },
-        { name: Cities.Strasbourg, region: Regions.Yellow, x: 211, y: 1330, transregional: true },
+        {
+            name: Cities.Strasbourg,
+            region: Regions.Yellow,
+            x: 211,
+            y: 1330,
+            transregional: true,
+            slotCosts: [15, 20],
+            stepSlots: [0, 1, 2],
+        },
         { name: Cities.Pforzheim, region: Regions.Yellow, x: 794, y: 1095 },
         { name: Cities.Rastatt, region: Regions.Yellow, x: 509, y: 1109 },
         { name: Cities.Karlsruhf, region: Regions.Yellow, x: 638, y: 974 },

package/dist/src/maps/japan.js

@@ -50,42 +50,94 @@ var Cities;
 exports.map = {
     name: 'Japan',
     cities: [
-        { name: Cities.Asahikawa, region: Regions.Brown, x: 3384, y: 414 },
-        { name: Cities.Sapporo, region: Regions.Brown, x: 3028, y: 382 },
-        { name: Cities.Hakodate, region: Regions.Brown, x: 2622, y: 512 },
+        { name: Cities.Asahikawa, region: Regions.Brown, x: 3384, y: 1014 },
+        { name: Cities.Sapporo, region: Regions.Brown, x: 3028, y: 982, slotCosts: [10, 10, 20], stepSlots: [2, 2, 3] },
+        { name: Cities.Hakodate, region: Regions.Brown, x: 2622, y: 1112 },
         { name: Cities.Admori, region: Regions.Brown, x: 3818, y: 1336 },
-        { name: Cities.Morioka, region: Regions.Brown, x: 3636, y: 1646 },
+        { name: Cities.Morioka, region: Regions.Brown, x: 3636, y: 1646, slotCosts: [15, 20], stepSlots: [0, 2, 2] },
         { name: Cities.Akita, region: Regions.Brown, x: 3472, y: 1480 },
         { name: Cities.Sendai, region: Regions.Brown, x: 3408, y: 1886 },
         { name: Cities.Niigata, region: Regions.Green, x: 2874, y: 1628 },
-        { name: Cities.Koriyama, region: Regions.Green, x: 3086, y: 1932 },
+        { name: Cities.Koriyama, region: Regions.Green, x: 3086, y: 1932, slotCosts: [10, 15] },
         { name: Cities.Nagano, region: Regions.Green, x: 2486, y: 1722 },
-        { name: Cities.Saitama, region: Regions.Green, x: 2450, y: 1986 },
-        { name: Cities.Tokyo, region: Regions.Green, x: 2524, y: 2122 },
+        { name: Cities.Saitama, region: Regions.Green, x: 2450, y: 1986, slotCosts: [15, 20], stepSlots: [0, 2, 2] },
+        { name: Cities.Tokyo, region: Regions.Green, x: 2524, y: 2122, slotCosts: [10, 10, 20], stepSlots: [2, 2, 3] },
         { name: Cities.Chiba, region: Regions.Green, x: 2650, y: 2316 },
-        { name: Cities.Yokohama, region: Regions.Green, x: 2306, y: 2244 },
+        {
+            name: Cities.Yokohama,
+            region: Regions.Green,
+            x: 2306,
+            y: 2244,
+            slotCosts: [10, 10, 20],
+            stepSlots: [2, 2, 3],
+        },
         { name: Cities.Kanazawa, region: Regions.Purple, x: 2207, y: 1385 },
-        { name: Cities.Toyama, region: Regions.Purple, x: 2257, y: 1595 },
+        { name: Cities.Toyama, region: Regions.Purple, x: 2257, y: 1595, slotCosts: [15, 20], stepSlots: [0, 2, 2] },
         { name: Cities.Kyoto, region: Regions.Purple, x: 1765, y: 1595 },
-        { name: Cities.Osaka, region: Regions.Purple, x: 1517, y: 1631 },
+        { name: Cities.Osaka, region: Regions.Purple, x: 1517, y: 1631, slotCosts: [10, 10, 20], stepSlots: [2, 2, 3] },
         { name: Cities.Nagoya, region: Regions.Purple, x: 1942, y: 1751 },
         { name: Cities.Kofu, region: Regions.Purple, x: 2179, y: 1897 },
-        { name: Cities.Hamamatsu, region: Regions.Purple, x: 1958, y: 2024 },
-        { name: Cities.Kobe, region: Regions.Yellow, x: 1555, y: 1451 },
-        { name: Cities.Matsue, region: Regions.Yellow, x: 1457, y: 1006 },
+        { name: Cities.Hamamatsu, region: Regions.Purple, x: 1958, y: 2024, slotCosts: [10, 15] },
+        { name: Cities.Kobe, region: Regions.Yellow, x: 1555, y: 1451, slotCosts: [10, 10, 20], stepSlots: [2, 2, 3] },
+        { name: Cities.Matsue, region: Regions.Yellow, x: 1457, y: 1006, slotCosts: [15, 20], stepSlots: [0, 2, 2] },
         { name: Cities.Okayama, region: Regions.Yellow, x: 1390, y: 1286 },
         { name: Cities.Takamatsu, region: Regions.Yellow, x: 1268, y: 1507 },
-        { name: Cities.Kochi, region: Regions.Yellow, x: 974, y: 1472 },
+        { name: Cities.Kochi, region: Regions.Yellow, x: 974, y: 1472, slotCosts: [10, 15] },
         { name: Cities.Matsuyama, region: Regions.Yellow, x: 1036, y: 1268 },
         { name: Cities.Hiroshima, region: Regions.Yellow, x: 1103, y: 1078 },
         { name: Cities.Shimonoseki, region: Regions.Red, x: 856, y: 962 },
-        { name: Cities.Oita, region: Regions.Red, x: 731, y: 1166 },
-        { name: Cities.Miyazaki, region: Regions.Red, x: 469, y: 1318 },
+        { name: Cities.Oita, region: Regions.Red, x: 731, y: 1166, slotCosts: [10, 15] },
+        { name: Cities.Miyazaki, region: Regions.Red, x: 469, y: 1318, slotCosts: [15, 20], stepSlots: [0, 2, 2] },
         { name: Cities.Kagoshima, region: Regions.Red, x: 157, y: 1255 },
         { name: Cities.Kumamoto, region: Regions.Red, x: 457, y: 1045 },
-        { name: Cities.Fukuoka, region: Regions.Red, x: 644, y: 823 },
+        { name: Cities.Fukuoka, region: Regions.Red, x: 644, y: 823, slotCosts: [10, 10, 20], stepSlots: [2, 2, 3] },
         { name: Cities.Nagasaki, region: Regions.Red, x: 313, y: 875 },
     ],
+    layout: 'Portrait',
+    adjustRatio: [0.28, 0.28],
+    mapPosition: [0, 120],
+    resupply: [
+        // Coal
+        [
+            [3, 4, 3],
+            [4, 5, 3],
+            [5, 6, 4],
+            [5, 7, 5],
+            [7, 9, 6], // 6P
+        ],
+        // Oil
+        [
+            [2, 2, 4],
+            [2, 3, 4],
+            [3, 4, 5],
+            [4, 5, 6],
+            [5, 6, 7],
+        ],
+        // Garbage
+        [
+            [1, 2, 3],
+            [1, 2, 3],
+            [2, 3, 4],
+            [3, 3, 5],
+            [3, 5, 6],
+        ],
+        // Uranium
+        [
+            [1, 1, 1],
+            [1, 1, 1],
+            [1, 2, 2],
+            [2, 3, 2],
+            [2, 3, 3],
+        ],
+    ],
+    startingResources: [21, 15, 9, 3],
+    startingCities: ['Fukuoka', 'Kobe', 'Osaka', 'Sapporo', 'Tokyo', 'Yokohama'],
+    mapSpecificRules: 'Each player can have two separate networks.\n' +
+        'First houses must be placed in one of six starting cities: Fukuoka, Kobe, Osaka, Sapporo, Tokyo, or Yokohama.\n' +
+        'Starting cities have two first-connection spots (cost 10 Elektro each); two players can build there in Step 1.\n' +
+        'In Step 3, a third connection spot opens in starting cities (cost 20 Elektro).\n' +
+        'Some smaller cities have only two building spots (costs 10 and 15, or 15 and 20 from Step 2).\n' +
+        'If all spots in every starting city are taken, a player is forced to play with a single network.',
     connections: [
         { nodes: [Cities.Nagasaki, Cities.Fukuoka], cost: 10 },
         { nodes: [Cities.Fukuoka, Cities.Shimonoseki], cost: 10 },

package/dist/src/maps.d.ts

@@ -6,6 +6,8 @@ export interface City {
     x: number;
     y: number;
     transregional?: boolean;
+    slotCosts?: number[];
+    stepSlots?: number[];
     singleOccupancy?: boolean;
     island?: string;
 }
@@ -56,6 +58,7 @@ export interface GameMap {
     regionalPowerPlants?: Record<string, PowerPlant[]>;
     crossIslandSurcharge?: number;
     mapSpecificRules?: string;
+    startingCities?: string[];
     devBackdrop?: {
         src: string;
         width: number;

package/dist/src/maps.js

@@ -13,7 +13,7 @@ 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 japan_1 = require("./maps/japan");
 const korea_1 = require("./maps/korea");
 const middleeast_1 = require("./maps/middleeast");
 const northamerica_1 = require("./maps/northamerica");
@@ -45,7 +45,7 @@ exports.maps = [
     southafrica_1.map,
     ukireland_1.map,
     // australia,
-    // japan,
+    japan_1.map,
 ];
 exports.mapsRecharged = [
     america_1.mapRecharged,

package/package.json

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

package/src/available-moves.ts

@@ -354,10 +354,41 @@ export function availableMoves(G: GameState, player: Player): AvailableMoves {
 
         case Phase.Building: {
             if (player.cities.length < 21) {
-                let toBuild =
-                    player.cities.length == 0
-                        ? G.map.cities.map((c) => ({ name: c.name, price: 0 }))
-                        : dijkstra(G, player).map((c) => ({ name: c.name, price: c.price }));
+                const isJapan = G.map.name === 'Japan';
+                const japanStartingCities = isJapan ? new Set(G.map.startingCities ?? []) : new Set<string>();
+
+                let toBuild: { name: string; price: number }[];
+                if (player.cities.length == 0) {
+                    // Japan: first house must go in one of the 6 designated starting cities.
+                    const candidates = isJapan
+                        ? G.map.cities.filter((c) => japanStartingCities.has(c.name))
+                        : G.map.cities;
+                    toBuild = candidates.map((c) => ({ name: c.name, price: 0 }));
+                } else if (isJapan && G.round === 1) {
+                    // Japan round 1: any additional house must also be a starting city.
+                    // Players cannot extend to adjacent non-starting cities until round 2.
+                    toBuild = G.map.cities
+                        .filter((c) => japanStartingCities.has(c.name))
+                        .map((c) => ({ name: c.name, price: 0 }));
+                } else {
+                    toBuild = dijkstra(G, player).map((c) => ({ name: c.name, price: c.price }));
+
+                    // Japan: a player may start a second disconnected network at any available
+                    // starting city, paying only the slot cost (no connection fee).
+                    if (
+                        isJapan &&
+                        countNetworks(
+                            G.map.connections,
+                            player.cities.map((c) => c.name)
+                        ) < 2
+                    ) {
+                        toBuild.forEach((city) => {
+                            if (japanStartingCities.has(city.name)) {
+                                city.price = 0;
+                            }
+                        });
+                    }
+                }
 
                 toBuild.forEach((city) => {
                     const cityData = G.map.cities.find((c) => c.name == city.name)!;
@@ -428,10 +459,14 @@ export function availableMoves(G: GameState, player: Player): AvailableMoves {
                         return;
                     }
 
-                    city.price += 10 + othersCount * 5;
+                    const slotCosts = cityData.slotCosts;
+                    const maxSlotsThisStep = cityData.stepSlots ? cityData.stepSlots[G.step - 1] : G.step;
+                    const totalSlots = slotCosts ? slotCosts.length : 3;
 
-                    if (othersCount == G.step) {
+                    if (othersCount >= maxSlotsThisStep || othersCount >= totalSlots) {
                         city.price = 9999;
+                    } else {
+                        city.price += slotCosts ? slotCosts[othersCount] : 10 + othersCount * 5;
                     }
 
                     if (player.cities.find((c) => c.name == city.name)) {
@@ -569,6 +604,31 @@ export function availableMoves(G: GameState, player: Player): AvailableMoves {
     return moves;
 }
 
+function countNetworks(connections: { nodes: string[] }[], cityNames: string[]): number {
+    const citySet = new Set(cityNames);
+    const visited = new Set<string>();
+    let count = 0;
+    for (const city of cityNames) {
+        if (visited.has(city)) continue;
+        count++;
+        const stack = [city];
+        while (stack.length > 0) {
+            const current = stack.pop()!;
+            if (visited.has(current)) continue;
+            visited.add(current);
+            for (const conn of connections) {
+                if (conn.nodes.includes(current)) {
+                    const neighbor = conn.nodes.find((n) => n !== current)!;
+                    if (citySet.has(neighbor) && !visited.has(neighbor)) {
+                        stack.push(neighbor);
+                    }
+                }
+            }
+        }
+    }
+    return count;
+}
+
 function dijkstra(G: GameState, player: Player): { name: string; price: number }[] {
     const nodes = G.map.cities.map((c) => ({
         name: c.name,

package/src/engine.spec.ts

@@ -141,6 +141,50 @@ describe('Engine', () => {
         expect(ended(G)).to.be.false;
     });
 
+    it('should setup Korea with dual-market populated and players ready to move', () => {
+        // Smoke test for the Korea map (PR #74). If a deployed lobby fails to
+        // auto-start, setup() is the most likely culprit — this catches that
+        // class of bug without needing a recorded game fixture.
+        const G = setup(
+            2,
+            { map: 'Korea', variant: 'recharged', randomizeMap: false, fastBid: false },
+            'korea-test-seed'
+        );
+
+        expect(ended(G)).to.be.false;
+        expect(G.map.name).to.equal('Korea');
+
+        // South-side markets (standard fields, uranium only here)
+        expect(G.coalMarket).to.be.greaterThan(0);
+        expect(G.oilMarket).to.be.greaterThan(0);
+        expect(G.uraniumMarket).to.be.greaterThan(0);
+
+        // North-side markets (Korea-specific, no uranium row)
+        expect(G.coalMarketNorth).to.be.greaterThan(0);
+        expect(G.oilMarketNorth).to.be.greaterThan(0);
+        expect(G.garbageMarketNorth).to.exist;
+
+        // Korea uses parallel per-side price tables
+        expect(G.coalPricesNorth).to.be.an('array').that.is.not.empty;
+        expect(G.oilPricesNorth).to.be.an('array').that.is.not.empty;
+
+        // At least one player should have available moves (auction phase is live)
+        expect(G.players.some((p) => p.availableMoves && Object.keys(p.availableMoves).length > 0)).to.be.true;
+    });
+
+    it('should setup Northern Europe and have players ready to move', () => {
+        // Smoke test for Northern Europe (PR #74) — parity with Korea test.
+        const G = setup(
+            2,
+            { map: 'Northern Europe', variant: 'recharged', randomizeMap: false, fastBid: false },
+            'ne-test-seed'
+        );
+
+        expect(ended(G)).to.be.false;
+        expect(G.map.name).to.equal('Northern Europe');
+        expect(G.players.some((p) => p.availableMoves && Object.keys(p.availableMoves).length > 0)).to.be.true;
+    });
+
     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

package/src/engine.ts

@@ -95,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[];
@@ -625,7 +628,7 @@ export function move(G: GameState, move: Move, playerNumber: number, isUndo = fa
                                 G.map.name != 'Russia'
                             ) {
                                 if (G.map.name == 'Baden-Württemberg') {
-                                    // Baden-Württemberg: remove the two lowest plants
+                                    // Baden-Württemberg: remove the two lowest plants when no one buys.
                                     const removed: number[] = [];
                                     for (let i = 0; i < 2 && G.actualMarket.length > 0; i++) {
                                         removed.push(G.actualMarket[0].number);

package/src/gamestate.ts

@@ -23,9 +23,9 @@ export type MapName =
     | 'Europe'
     | 'North America'
     | 'South Africa'
-    | 'UK & Ireland';
+    | 'UK & Ireland'
+    | 'Japan';
 // | 'Australia'
-// | 'Japan'
 export type Variant = 'original' | 'recharged';
 
 export interface GameOptions {

package/src/maps/badenwurttemberg.ts

@@ -55,8 +55,24 @@ export const map: GameMap = {
         { name: Cities.Sigmarincen, region: Regions.Purple, x: 1111, y: 1803 },
         { name: Cities.Konstanz, region: Regions.Purple, x: 1088, y: 2163 },
         { name: Cities.Ulm, region: Regions.Purple, x: 1541, y: 1499 },
-        { name: Cities.Augsburg, region: Regions.Purple, x: 1830, y: 1505, transregional: true },
-        { name: Cities.Basel, region: Regions.Green, x: 103, y: 2271, transregional: true },
+        {
+            name: Cities.Augsburg,
+            region: Regions.Purple,
+            x: 1830,
+            y: 1505,
+            transregional: true,
+            slotCosts: [15, 20],
+            stepSlots: [0, 1, 2],
+        },
+        {
+            name: Cities.Basel,
+            region: Regions.Green,
+            x: 103,
+            y: 2271,
+            transregional: true,
+            slotCosts: [15, 20],
+            stepSlots: [0, 1, 2],
+        },
         { name: Cities.Waldshuttiencen, region: Regions.Green, x: 502, y: 2166 },
         { name: Cities.Singen, region: Regions.Green, x: 874, y: 2084 },
         { name: Cities.Tuttlincen, region: Regions.Green, x: 870, y: 1854 },
@@ -69,8 +85,24 @@ export const map: GameMap = {
         { name: Cities.Sinsheim, region: Regions.Red, x: 920, y: 785 },
         { name: Cities.Heidelber, region: Regions.Red, x: 817, y: 660 },
         { name: Cities.Mannheim, region: Regions.Red, x: 710, y: 540 },
-        { name: Cities.Luowigshafen, region: Regions.Red, x: 579, y: 588, transregional: true },
-        { name: Cities.Nurnberg, region: Regions.Blue, x: 1837, y: 771, transregional: true },
+        {
+            name: Cities.Luowigshafen,
+            region: Regions.Red,
+            x: 579,
+            y: 588,
+            transregional: true,
+            slotCosts: [15, 20],
+            stepSlots: [0, 1, 2],
+        },
+        {
+            name: Cities.Nurnberg,
+            region: Regions.Blue,
+            x: 1837,
+            y: 771,
+            transregional: true,
+            slotCosts: [15, 20],
+            stepSlots: [0, 1, 2],
+        },
         { name: Cities.Ellwangen, region: Regions.Blue, x: 1637, y: 1030 },
         { name: Cities.Coppingen, region: Regions.Blue, x: 1387, y: 1233 },
         { name: Cities.Reutlincen, region: Regions.Blue, x: 1107, y: 1443 },
@@ -80,7 +112,15 @@ export const map: GameMap = {
         { name: Cities.Laha, region: Regions.Yellow, x: 296, y: 1575 },
         { name: Cities.Badenbaden, region: Regions.Yellow, x: 554, y: 1259 },
         { name: Cities.Offenburg, region: Regions.Yellow, x: 395, y: 1422 },
-        { name: Cities.Strasbourg, region: Regions.Yellow, x: 211, y: 1330, transregional: true },
+        {
+            name: Cities.Strasbourg,
+            region: Regions.Yellow,
+            x: 211,
+            y: 1330,
+            transregional: true,
+            slotCosts: [15, 20],
+            stepSlots: [0, 1, 2],
+        },
         { name: Cities.Pforzheim, region: Regions.Yellow, x: 794, y: 1095 },
         { name: Cities.Rastatt, region: Regions.Yellow, x: 509, y: 1109 },
         { name: Cities.Karlsruhf, region: Regions.Yellow, x: 638, y: 974 },

package/src/maps/japan.ts

@@ -49,42 +49,95 @@ export enum Cities {
 export const map: GameMap = {
     name: 'Japan',
     cities: [
-        { name: Cities.Asahikawa, region: Regions.Brown, x: 3384, y: 414 },
-        { name: Cities.Sapporo, region: Regions.Brown, x: 3028, y: 382 },
-        { name: Cities.Hakodate, region: Regions.Brown, x: 2622, y: 512 },
+        { name: Cities.Asahikawa, region: Regions.Brown, x: 3384, y: 1014 },
+        { name: Cities.Sapporo, region: Regions.Brown, x: 3028, y: 982, slotCosts: [10, 10, 20], stepSlots: [2, 2, 3] },
+        { name: Cities.Hakodate, region: Regions.Brown, x: 2622, y: 1112 },
         { name: Cities.Admori, region: Regions.Brown, x: 3818, y: 1336 },
-        { name: Cities.Morioka, region: Regions.Brown, x: 3636, y: 1646 },
+        { name: Cities.Morioka, region: Regions.Brown, x: 3636, y: 1646, slotCosts: [15, 20], stepSlots: [0, 2, 2] },
         { name: Cities.Akita, region: Regions.Brown, x: 3472, y: 1480 },
         { name: Cities.Sendai, region: Regions.Brown, x: 3408, y: 1886 },
         { name: Cities.Niigata, region: Regions.Green, x: 2874, y: 1628 },
-        { name: Cities.Koriyama, region: Regions.Green, x: 3086, y: 1932 },
+        { name: Cities.Koriyama, region: Regions.Green, x: 3086, y: 1932, slotCosts: [10, 15] },
         { name: Cities.Nagano, region: Regions.Green, x: 2486, y: 1722 },
-        { name: Cities.Saitama, region: Regions.Green, x: 2450, y: 1986 },
-        { name: Cities.Tokyo, region: Regions.Green, x: 2524, y: 2122 },
+        { name: Cities.Saitama, region: Regions.Green, x: 2450, y: 1986, slotCosts: [15, 20], stepSlots: [0, 2, 2] },
+        { name: Cities.Tokyo, region: Regions.Green, x: 2524, y: 2122, slotCosts: [10, 10, 20], stepSlots: [2, 2, 3] },
         { name: Cities.Chiba, region: Regions.Green, x: 2650, y: 2316 },
-        { name: Cities.Yokohama, region: Regions.Green, x: 2306, y: 2244 },
+        {
+            name: Cities.Yokohama,
+            region: Regions.Green,
+            x: 2306,
+            y: 2244,
+            slotCosts: [10, 10, 20],
+            stepSlots: [2, 2, 3],
+        },
         { name: Cities.Kanazawa, region: Regions.Purple, x: 2207, y: 1385 },
-        { name: Cities.Toyama, region: Regions.Purple, x: 2257, y: 1595 },
+        { name: Cities.Toyama, region: Regions.Purple, x: 2257, y: 1595, slotCosts: [15, 20], stepSlots: [0, 2, 2] },
         { name: Cities.Kyoto, region: Regions.Purple, x: 1765, y: 1595 },
-        { name: Cities.Osaka, region: Regions.Purple, x: 1517, y: 1631 },
+        { name: Cities.Osaka, region: Regions.Purple, x: 1517, y: 1631, slotCosts: [10, 10, 20], stepSlots: [2, 2, 3] },
         { name: Cities.Nagoya, region: Regions.Purple, x: 1942, y: 1751 },
         { name: Cities.Kofu, region: Regions.Purple, x: 2179, y: 1897 },
-        { name: Cities.Hamamatsu, region: Regions.Purple, x: 1958, y: 2024 },
-        { name: Cities.Kobe, region: Regions.Yellow, x: 1555, y: 1451 },
-        { name: Cities.Matsue, region: Regions.Yellow, x: 1457, y: 1006 },
+        { name: Cities.Hamamatsu, region: Regions.Purple, x: 1958, y: 2024, slotCosts: [10, 15] },
+        { name: Cities.Kobe, region: Regions.Yellow, x: 1555, y: 1451, slotCosts: [10, 10, 20], stepSlots: [2, 2, 3] },
+        { name: Cities.Matsue, region: Regions.Yellow, x: 1457, y: 1006, slotCosts: [15, 20], stepSlots: [0, 2, 2] },
         { name: Cities.Okayama, region: Regions.Yellow, x: 1390, y: 1286 },
         { name: Cities.Takamatsu, region: Regions.Yellow, x: 1268, y: 1507 },
-        { name: Cities.Kochi, region: Regions.Yellow, x: 974, y: 1472 },
+        { name: Cities.Kochi, region: Regions.Yellow, x: 974, y: 1472, slotCosts: [10, 15] },
         { name: Cities.Matsuyama, region: Regions.Yellow, x: 1036, y: 1268 },
         { name: Cities.Hiroshima, region: Regions.Yellow, x: 1103, y: 1078 },
         { name: Cities.Shimonoseki, region: Regions.Red, x: 856, y: 962 },
-        { name: Cities.Oita, region: Regions.Red, x: 731, y: 1166 },
-        { name: Cities.Miyazaki, region: Regions.Red, x: 469, y: 1318 },
+        { name: Cities.Oita, region: Regions.Red, x: 731, y: 1166, slotCosts: [10, 15] },
+        { name: Cities.Miyazaki, region: Regions.Red, x: 469, y: 1318, slotCosts: [15, 20], stepSlots: [0, 2, 2] },
         { name: Cities.Kagoshima, region: Regions.Red, x: 157, y: 1255 },
         { name: Cities.Kumamoto, region: Regions.Red, x: 457, y: 1045 },
-        { name: Cities.Fukuoka, region: Regions.Red, x: 644, y: 823 },
+        { name: Cities.Fukuoka, region: Regions.Red, x: 644, y: 823, slotCosts: [10, 10, 20], stepSlots: [2, 2, 3] },
         { name: Cities.Nagasaki, region: Regions.Red, x: 313, y: 875 },
     ],
+    layout: 'Portrait',
+    adjustRatio: [0.28, 0.28],
+    mapPosition: [0, 120],
+    resupply: [
+        // Coal
+        [
+            [3, 4, 3], // 2P
+            [4, 5, 3], // 3P
+            [5, 6, 4], // 4P
+            [5, 7, 5], // 5P
+            [7, 9, 6], // 6P
+        ],
+        // Oil
+        [
+            [2, 2, 4],
+            [2, 3, 4],
+            [3, 4, 5],
+            [4, 5, 6],
+            [5, 6, 7],
+        ],
+        // Garbage
+        [
+            [1, 2, 3],
+            [1, 2, 3],
+            [2, 3, 4],
+            [3, 3, 5],
+            [3, 5, 6],
+        ],
+        // Uranium
+        [
+            [1, 1, 1],
+            [1, 1, 1],
+            [1, 2, 2],
+            [2, 3, 2],
+            [2, 3, 3],
+        ],
+    ],
+    startingResources: [21, 15, 9, 3],
+    startingCities: ['Fukuoka', 'Kobe', 'Osaka', 'Sapporo', 'Tokyo', 'Yokohama'],
+    mapSpecificRules:
+        'Each player can have two separate networks.\n' +
+        'First houses must be placed in one of six starting cities: Fukuoka, Kobe, Osaka, Sapporo, Tokyo, or Yokohama.\n' +
+        'Starting cities have two first-connection spots (cost 10 Elektro each); two players can build there in Step 1.\n' +
+        'In Step 3, a third connection spot opens in starting cities (cost 20 Elektro).\n' +
+        'Some smaller cities have only two building spots (costs 10 and 15, or 15 and 20 from Step 2).\n' +
+        'If all spots in every starting city are taken, a player is forced to play with a single network.',
     connections: [
         { nodes: [Cities.Nagasaki, Cities.Fukuoka], cost: 10 },
         { nodes: [Cities.Fukuoka, Cities.Shimonoseki], cost: 10 },

package/src/maps.ts

@@ -12,7 +12,7 @@ import { map as france } from './maps/france';
 import { map as germany, mapRecharged as germanyRecharged } from './maps/germany';
 import { map as indian } from './maps/indian';
 import { map as italy } from './maps/italy';
-// import { map as japan } from './maps/japan';
+import { map as japan } from './maps/japan';
 import { map as korea } from './maps/korea';
 import { map as middleeast } from './maps/middleeast';
 import { map as northamerica } from './maps/northamerica';
@@ -32,6 +32,12 @@ export interface City {
     // and connecting to them costs a fixed price (transregionalConnectionCost on the GameMap)
     // instead of the normal dijkstra path cost.
     transregional?: boolean;
+    // Custom per-slot building costs (e.g. Japan). Length also determines total slots.
+    // Defaults to [10, 15, 20] if omitted.
+    slotCosts?: number[];
+    // Max slots open per step [step1, step2, step3].
+    // Defaults to [1, 2, 3] (standard Power Grid rules) if omitted.
+    stepSlots?: number[];
     // South Africa's six cross-border foreign-country spaces: only one player ever
     // builds here (cap 1 instead of the standard 3), and the build skips the
     // 10+position*5 house-base cost — the dijkstra path cost (the 30-Elektro edge)
@@ -106,6 +112,10 @@ export interface GameMap {
     // cost (there is no sea edge) and pay 10+position*5 + this surcharge.
     crossIslandSurcharge?: number;
     mapSpecificRules?: string;
+    // Cities where a player's first house (or second network) must be placed.
+    // Used by Japan: only the 6 designated starting cities are valid first builds,
+    // and a second disconnected network can only begin in one of these cities.
+    startingCities?: string[];
     // Dev-only: when set, the viewer renders an `<image>` backdrop behind the
     // map and logs click positions (in local SVG coords) to the console as
     // ready-to-paste `{ name, region, x, y }` lines. Intended for authoring
@@ -137,7 +147,7 @@ export const maps: GameMap[] = [
     southafrica,
     ukireland,
     // australia,
-    // japan,
+    japan,
 ];
 
 export const mapsRecharged: GameMap[] = [