powergrid-engine 1.9.7

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 donkeytech
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,31 @@
+# powergrid-engine
+
+Typescript engine for Power Grid.
+
+## Setup
+
+### Requirements
+
+Recent version of node / pnpm.
+
+### Dependencies
+
+In the project's folder:
+
+```
+pnpm
+```
+
+### Build
+
+To compile Typescript into javascript:
+
+```
+pnpm build
+```
+
+### Test
+
+```
+pnpm test
+```

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { availableMoves, AvailableMoves } from './src/available-moves';
+export { currentPlayers, ended, move, playersSortedByScore, reconstructState, setup, stripSecret } from './src/engine';
+export { Phase } from './src/gamestate';
+export type { GameState, Player } from './src/gamestate';
+export { LogItem } from './src/log';
+export { Move, MoveName, Moves } from './src/move';

package/dist/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MoveName = exports.Phase = exports.stripSecret = exports.setup = exports.reconstructState = exports.playersSortedByScore = exports.move = exports.ended = exports.currentPlayers = exports.availableMoves = void 0;
+var available_moves_1 = require("./src/available-moves");
+Object.defineProperty(exports, "availableMoves", { enumerable: true, get: function () { return available_moves_1.availableMoves; } });
+var engine_1 = require("./src/engine");
+Object.defineProperty(exports, "currentPlayers", { enumerable: true, get: function () { return engine_1.currentPlayers; } });
+Object.defineProperty(exports, "ended", { enumerable: true, get: function () { return engine_1.ended; } });
+Object.defineProperty(exports, "move", { enumerable: true, get: function () { return engine_1.move; } });
+Object.defineProperty(exports, "playersSortedByScore", { enumerable: true, get: function () { return engine_1.playersSortedByScore; } });
+Object.defineProperty(exports, "reconstructState", { enumerable: true, get: function () { return engine_1.reconstructState; } });
+Object.defineProperty(exports, "setup", { enumerable: true, get: function () { return engine_1.setup; } });
+Object.defineProperty(exports, "stripSecret", { enumerable: true, get: function () { return engine_1.stripSecret; } });
+var gamestate_1 = require("./src/gamestate");
+Object.defineProperty(exports, "Phase", { enumerable: true, get: function () { return gamestate_1.Phase; } });
+var move_1 = require("./src/move");
+Object.defineProperty(exports, "MoveName", { enumerable: true, get: function () { return move_1.MoveName; } });

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

@@ -0,0 +1,24 @@
+import { GameState, Player, ResourceType } from './gamestate';
+import { MoveName } from './move';
+export interface AvailableMoves {
+    [MoveName.ChoosePowerPlant]?: number[];
+    [MoveName.Bid]?: number[];
+    [MoveName.DiscardPowerPlant]?: number[];
+    [MoveName.DiscardResources]?: ResourceType[];
+    [MoveName.BuyResource]?: {
+        resource: ResourceType;
+        price: number;
+    }[];
+    [MoveName.Build]?: {
+        name: string;
+        price: number;
+    }[];
+    [MoveName.UsePowerPlant]?: {
+        powerPlant: number;
+        resourcesSpent: ResourceType[];
+        citiesPowered: number;
+    }[];
+    [MoveName.Pass]?: boolean[];
+    [MoveName.Undo]?: boolean[];
+}
+export declare function availableMoves(G: GameState, player: Player): AvailableMoves;

package/dist/src/available-moves.js

@@ -0,0 +1,363 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.availableMoves = void 0;
+const lodash_1 = require("lodash");
+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;
+    const moves = {};
+    const lastLog = G.log[G.log.length - 1];
+    if (lastLog.type == 'move' && G.currentPlayers.includes(player.id)) {
+        if (lastLog.player == player.id && ((_a = player.lastMove) === null || _a === void 0 ? void 0 : _a.name) != move_1.MoveName.Pass) {
+            moves[move_1.MoveName.Undo] = [true, false];
+        }
+        else if (G.phase == gamestate_1.Phase.Bureaucracy && ((_b = player.lastMove) === null || _b === void 0 ? void 0 : _b.name) == move_1.MoveName.UsePowerPlant) {
+            moves[move_1.MoveName.Undo] = [true, false];
+        }
+    }
+    switch (G.phase) {
+        case gamestate_1.Phase.Auction: {
+            if (player.powerPlants.length > 4 || (G.players.length > 2 && player.powerPlants.length > 3)) {
+                moves[move_1.MoveName.DiscardPowerPlant] = player.powerPlants
+                    .filter((_, i) => i != player.powerPlants.length - 1)
+                    .map((pp) => pp.number);
+            }
+            else {
+                const toDiscard = [];
+                let hybridCapacityUsed = Math.max(0, player.oilLeft - player.oilCapacity);
+                if (player.coalCapacity + player.hybridCapacity < player.coalLeft + hybridCapacityUsed) {
+                    toDiscard.push(gamestate_1.ResourceType.Coal);
+                }
+                hybridCapacityUsed = Math.max(0, player.coalLeft - player.coalCapacity);
+                if (player.oilCapacity + player.hybridCapacity < player.oilLeft + hybridCapacityUsed) {
+                    toDiscard.push(gamestate_1.ResourceType.Oil);
+                }
+                if (player.garbageCapacity < player.garbageLeft) {
+                    toDiscard.push(gamestate_1.ResourceType.Garbage);
+                }
+                if (player.uraniumCapacity < player.uraniumLeft) {
+                    toDiscard.push(gamestate_1.ResourceType.Uranium);
+                }
+                if (toDiscard.length > 0) {
+                    moves[move_1.MoveName.DiscardResources] = toDiscard;
+                }
+                else {
+                    if (G.chosenPowerPlant == undefined) {
+                        let canBid = G.actualMarket.filter((p) => player.money >= p.number);
+                        // No nuclear plants for Portugal
+                        if (G.map.name == 'Spain & Portugal') {
+                            const playerCities = player.cities.map((c) => G.map.cities.find((c_) => c_.name == c.name));
+                            if (playerCities.every((c) => c.region == 'yellow')) {
+                                canBid = canBid.filter((p) => p.type != gamestate_1.PowerPlantType.Uranium);
+                            }
+                        }
+                        // Nuclear plants for Central Europe are only allowed for players with cities in:
+                        // Czechia (green), Slovakia (brown), Hungary (purple)
+                        if (G.map.name == 'Central Europe') {
+                            const validCities = player.cities
+                                .map((c) => G.map.cities.find((c_) => c_.name == c.name))
+                                .filter((c) => c.region == 'green' || c.region == 'brown' || c.region == 'purple');
+                            if (validCities.length == 0) {
+                                canBid = canBid.filter((p) => p.type != gamestate_1.PowerPlantType.Uranium);
+                            }
+                        }
+                        if (canBid.length > 0) {
+                            moves[move_1.MoveName.ChoosePowerPlant] = canBid.map((p) => p.number);
+                        }
+                        if (G.round > 1) {
+                            moves[move_1.MoveName.Pass] = [true];
+                        }
+                    }
+                    else {
+                        if (G.options.fastBid) {
+                            if (G.minimunBid <= player.money) {
+                                moves[move_1.MoveName.Bid] = lodash_1.range(G.minimunBid, player.money + 1);
+                            }
+                        }
+                        else {
+                            if (G.currentBid) {
+                                if (G.currentBid < player.money) {
+                                    moves[move_1.MoveName.Bid] = lodash_1.range(G.currentBid + 1, player.money + 1);
+                                }
+                            }
+                            else {
+                                moves[move_1.MoveName.Bid] = lodash_1.range(G.minimunBid, player.money + 1);
+                            }
+                        }
+                        // No nuclear plants for Portugal
+                        if (G.map.name == 'Spain & Portugal') {
+                            const playerCities = player.cities.map((c) => G.map.cities.find((c_) => c_.name == c.name));
+                            if (playerCities.every((c) => c.region == 'yellow') &&
+                                G.chosenPowerPlant.type == gamestate_1.PowerPlantType.Uranium) {
+                                moves[move_1.MoveName.Bid] = undefined;
+                            }
+                        }
+                        // Nuclear plants for Central Europe are only allowed for players with cities in:
+                        // Czechia (green), Slovakia (brown), Hungary (purple)
+                        if (G.map.name == 'Central Europe') {
+                            const validCities = player.cities
+                                .map((c) => G.map.cities.find((c_) => c_.name == c.name))
+                                .filter((c) => c.region == 'green' || c.region == 'brown' || c.region == 'purple');
+                            if (validCities.length == 0 && 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];
+                            }
+                        }
+                        else {
+                            if (G.currentBid != null) {
+                                moves[move_1.MoveName.Pass] = [true];
+                            }
+                        }
+                    }
+                }
+            }
+            break;
+        }
+        case gamestate_1.Phase.Resources: {
+            if (G.map.name == 'India' && G.chosenResource !== undefined) {
+                moves[move_1.MoveName.Pass] = [true];
+                break;
+            }
+            const toBuy = [];
+            let maxPriceAvailable;
+            if (G.map.maxPriceAvailable) {
+                maxPriceAvailable = G.map.maxPriceAvailable[G.step - 1];
+            }
+            else {
+                maxPriceAvailable = 16;
+            }
+            if (G.coalMarket > 0) {
+                const hybridCapacityUsed = player.hybridCapacity > 0 ? Math.max(0, player.oilLeft - player.oilCapacity) : 0;
+                const coalPrices = (_c = G.coalPrices) !== null && _c !== void 0 ? _c : prices_1.default[gamestate_1.ResourceType.Coal];
+                const price = coalPrices[coalPrices.length - G.coalMarket];
+                if (player.money >= price &&
+                    player.coalCapacity + player.hybridCapacity > hybridCapacityUsed + player.coalLeft &&
+                    price <= maxPriceAvailable) {
+                    toBuy.push({ resource: gamestate_1.ResourceType.Coal });
+                }
+            }
+            else {
+                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;
+                    if (player.money >= 8 &&
+                        player.coalCapacity + player.hybridCapacity > hybridCapacityUsed + player.coalLeft) {
+                        toBuy.push({ resource: gamestate_1.ResourceType.Coal });
+                    }
+                }
+            }
+            if (G.oilMarket > 0) {
+                const hybridCapacityUsed = player.hybridCapacity > 0 ? Math.max(0, player.coalLeft - player.coalCapacity) : 0;
+                const oilPrices = (_d = G.oilPrices) !== null && _d !== void 0 ? _d : prices_1.default[gamestate_1.ResourceType.Oil];
+                const price = oilPrices[oilPrices.length - G.oilMarket];
+                if (player.money >= price &&
+                    player.oilCapacity + player.hybridCapacity > hybridCapacityUsed + player.oilLeft &&
+                    price <= maxPriceAvailable) {
+                    toBuy.push({ resource: gamestate_1.ResourceType.Oil });
+                }
+            }
+            if (G.garbageMarket > 0) {
+                const garbagePrices = (_e = G.garbagePrices) !== null && _e !== void 0 ? _e : prices_1.default[gamestate_1.ResourceType.Garbage];
+                let price = garbagePrices[garbagePrices.length - G.garbageMarket];
+                // $1 cheaper for players in Wien in Central Europe
+                if (G.map.name == 'Central Europe') {
+                    const wienCity = player.cities.filter((c) => c.name == 'Wien');
+                    if ((wienCity === null || wienCity === void 0 ? void 0 : wienCity.length) > 0) {
+                        price--;
+                    }
+                }
+                if (player.money >= price &&
+                    player.garbageCapacity > player.garbageLeft &&
+                    price <= maxPriceAvailable) {
+                    toBuy.push({ resource: gamestate_1.ResourceType.Garbage });
+                }
+            }
+            if (G.uraniumMarket > 0) {
+                const uraniumPrices = (_f = G.uraniumPrices) !== null && _f !== void 0 ? _f : prices_1.default[gamestate_1.ResourceType.Uranium];
+                const price = uraniumPrices[uraniumPrices.length - G.uraniumMarket];
+                if (player.money >= price &&
+                    player.uraniumCapacity > player.uraniumLeft &&
+                    price <= maxPriceAvailable) {
+                    toBuy.push({ resource: gamestate_1.ResourceType.Uranium });
+                }
+            }
+            if (toBuy.length > 0) {
+                moves[move_1.MoveName.BuyResource] = toBuy;
+            }
+            moves[move_1.MoveName.Pass] = [true];
+            break;
+        }
+        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 }));
+                toBuild.forEach((city) => {
+                    const othersCount = G.players.filter((p) => p.cities.find((c) => city.name == c.name)).length;
+                    city.price += 10 + othersCount * 5;
+                    if (othersCount == G.step) {
+                        city.price = 9999;
+                    }
+                    if (player.cities.find((c) => c.name == city.name)) {
+                        city.price = 9999;
+                    }
+                });
+                toBuild = toBuild.filter((c) => c.price <= player.money);
+                if (toBuild.length > 0) {
+                    moves[move_1.MoveName.Build] = toBuild;
+                }
+            }
+            moves[move_1.MoveName.Pass] = [true];
+            break;
+        }
+        case gamestate_1.Phase.Bureaucracy: {
+            const toUse = [];
+            player.powerPlants.forEach((powerPlant) => {
+                if (player.powerPlantsNotUsed.includes(powerPlant.number)) {
+                    switch (powerPlant.type) {
+                        case gamestate_1.PowerPlantType.Coal: {
+                            if (player.coalLeft >= powerPlant.cost) {
+                                toUse.push({
+                                    powerPlant: powerPlant.number,
+                                    resourcesSpent: new Array(powerPlant.cost).fill(gamestate_1.ResourceType.Coal),
+                                    citiesPowered: powerPlant.citiesPowered,
+                                });
+                            }
+                            break;
+                        }
+                        case gamestate_1.PowerPlantType.Oil: {
+                            if (player.oilLeft >= powerPlant.cost) {
+                                toUse.push({
+                                    powerPlant: powerPlant.number,
+                                    resourcesSpent: new Array(powerPlant.cost).fill(gamestate_1.ResourceType.Oil),
+                                    citiesPowered: powerPlant.citiesPowered,
+                                });
+                            }
+                            break;
+                        }
+                        case gamestate_1.PowerPlantType.Garbage: {
+                            if (player.garbageLeft >= powerPlant.cost) {
+                                toUse.push({
+                                    powerPlant: powerPlant.number,
+                                    resourcesSpent: new Array(powerPlant.cost).fill(gamestate_1.ResourceType.Garbage),
+                                    citiesPowered: powerPlant.citiesPowered,
+                                });
+                            }
+                            break;
+                        }
+                        case gamestate_1.PowerPlantType.Uranium: {
+                            if (player.uraniumLeft >= powerPlant.cost) {
+                                toUse.push({
+                                    powerPlant: powerPlant.number,
+                                    resourcesSpent: new Array(powerPlant.cost).fill(gamestate_1.ResourceType.Uranium),
+                                    citiesPowered: powerPlant.citiesPowered,
+                                });
+                            }
+                            break;
+                        }
+                        case gamestate_1.PowerPlantType.Wind:
+                        case gamestate_1.PowerPlantType.Nuclear:
+                            toUse.push({
+                                powerPlant: powerPlant.number,
+                                resourcesSpent: [],
+                                citiesPowered: powerPlant.citiesPowered,
+                            });
+                            break;
+                        case gamestate_1.PowerPlantType.Hybrid: {
+                            if (player.coalLeft + player.oilLeft >= powerPlant.cost) {
+                                let resourcesSpentArr;
+                                if (powerPlant.cost == 1) {
+                                    resourcesSpentArr = [[gamestate_1.ResourceType.Coal], [gamestate_1.ResourceType.Oil]];
+                                }
+                                else if (powerPlant.cost == 2) {
+                                    resourcesSpentArr = [
+                                        [gamestate_1.ResourceType.Coal, gamestate_1.ResourceType.Coal],
+                                        [gamestate_1.ResourceType.Coal, gamestate_1.ResourceType.Oil],
+                                        [gamestate_1.ResourceType.Oil, gamestate_1.ResourceType.Oil],
+                                    ];
+                                }
+                                else {
+                                    resourcesSpentArr = [
+                                        [gamestate_1.ResourceType.Coal, gamestate_1.ResourceType.Coal, gamestate_1.ResourceType.Coal],
+                                        [gamestate_1.ResourceType.Coal, gamestate_1.ResourceType.Coal, gamestate_1.ResourceType.Oil],
+                                        [gamestate_1.ResourceType.Coal, gamestate_1.ResourceType.Oil, gamestate_1.ResourceType.Oil],
+                                        [gamestate_1.ResourceType.Oil, gamestate_1.ResourceType.Oil, gamestate_1.ResourceType.Oil],
+                                    ];
+                                }
+                                resourcesSpentArr.forEach((resourcesSpent) => {
+                                    if (resourcesSpent.filter((r) => r == gamestate_1.ResourceType.Coal).length <=
+                                        player.coalLeft &&
+                                        resourcesSpent.filter((r) => r == gamestate_1.ResourceType.Oil).length <= player.oilLeft) {
+                                        toUse.push({
+                                            powerPlant: powerPlant.number,
+                                            resourcesSpent: resourcesSpent,
+                                            citiesPowered: powerPlant.citiesPowered,
+                                        });
+                                    }
+                                });
+                            }
+                        }
+                    }
+                }
+            });
+            if (toUse.length > 0) {
+                moves[move_1.MoveName.UsePowerPlant] = toUse;
+            }
+            // For India map, players must power as many cities as possible.
+            if (G.map.name != 'India' || player.citiesPowered >= player.targetCitiesPowered || player.isAI) {
+                moves[move_1.MoveName.Pass] = [true];
+            }
+            break;
+        }
+    }
+    return moves;
+}
+exports.availableMoves = availableMoves;
+function dijkstra(G, player) {
+    const nodes = G.map.cities.map((c) => ({
+        name: c.name,
+        price: player.cities.find((city) => city.name == c.name) ? 0 : 9999,
+        visited: false,
+    }));
+    let currentNode = nodes.find((n) => n.name == player.cities[0].name);
+    currentNode.price = 0;
+    while (nodes.some((n) => !n.visited)) {
+        const currentConnections = G.map.connections.filter((c) => c.nodes.includes(currentNode.name));
+        currentConnections.forEach((connection) => {
+            const otherName = connection.nodes.filter((n) => n != currentNode.name)[0];
+            const otherNode = nodes.find((n) => n.name == otherName);
+            const price = player.cities.find((c) => c.name == otherNode.name) ? 0 : currentNode.price + connection.cost;
+            if (!otherNode.visited && otherNode.price > price) {
+                otherNode.price = price;
+            }
+        });
+        currentNode.visited = true;
+        if (!nodes.some((n) => !n.visited)) {
+            break;
+        }
+        currentNode = nodes.reduce((a, b) => {
+            if (a.visited) {
+                return b;
+            }
+            if (b.visited) {
+                return a;
+            }
+            if (a.price <= b.price) {
+                return a;
+            }
+            return b;
+        });
+        if (currentNode.price > player.money) {
+            break;
+        }
+    }
+    return nodes;
+}

package/dist/src/engine.d.ts

@@ -0,0 +1,20 @@
+import seedrandom from 'seedrandom';
+import { GameOptions, GameState, Player, PowerPlant } from './gamestate';
+import { GameMap } from './maps';
+import { Move } from './move';
+export declare const playerColors: string[];
+export declare function defaultSetupDeck(numPlayers: number, variant: string, rng: seedrandom.prng, useNewRechargedSetup: boolean): {
+    actualMarket: PowerPlant[];
+    futureMarket: PowerPlant[];
+    powerPlantsDeck: PowerPlant[];
+};
+export declare function setup(numPlayers: number, { fastBid, map, variant, showMoney, useNewRechargedSetup, trackTotalSpent, randomizeMap, }: GameOptions, seed?: string, forceDeck?: PowerPlant[], forceMap?: GameMap): GameState;
+export declare function stripSecret(G: GameState, player?: number): GameState;
+export declare function currentPlayers(G: GameState): number[];
+export declare function move(G: GameState, move: Move, playerNumber: number, isUndo?: boolean): GameState;
+export declare function moveAI(G: GameState, playerNumber: number): GameState;
+export declare function ended(G: GameState): boolean;
+export declare function scores(G: GameState): number[];
+export declare function reconstructState(gameState: GameState, to?: number): GameState;
+export declare function getPowerPlant(num: number, mapName?: string): PowerPlant;
+export declare function playersSortedByScore(G: GameState): Player[];