powergrid-engine 1.9.7

package/dist/src/move.d.ts

@@ -0,0 +1,63 @@
+import { ResourceType } from './gamestate';
+export declare namespace Moves {
+    interface MoveChoosePowerPlant {
+        name: MoveName.ChoosePowerPlant;
+        data: number;
+        usedPlantDiscount?: boolean;
+    }
+    interface MoveBid {
+        name: MoveName.Bid;
+        data: number;
+    }
+    interface MoveDiscardPowerPlant {
+        name: MoveName.DiscardPowerPlant;
+        data: number;
+        extra?: number[];
+    }
+    interface MoveDiscardResources {
+        name: MoveName.DiscardResources;
+        data: ResourceType;
+    }
+    interface MoveBuyResource {
+        name: MoveName.BuyResource;
+        data: {
+            resource: ResourceType;
+        };
+        fromSupply?: boolean;
+    }
+    interface MoveBuild {
+        name: MoveName.Build;
+        data: {
+            name: string;
+            price: number;
+        };
+    }
+    interface MoveUsePowerPlant {
+        name: MoveName.UsePowerPlant;
+        data: {
+            powerPlant: number;
+            resourcesSpent: ResourceType[];
+            citiesPowered: number;
+        };
+    }
+    interface MovePass {
+        name: MoveName.Pass;
+        data: true;
+    }
+    interface MoveUndo {
+        name: MoveName.Undo;
+        data: boolean;
+    }
+}
+export declare type Move = Moves.MoveChoosePowerPlant | Moves.MoveBid | Moves.MoveDiscardPowerPlant | Moves.MoveDiscardResources | Moves.MoveBuyResource | Moves.MoveBuild | Moves.MoveUsePowerPlant | Moves.MovePass | Moves.MoveUndo;
+export declare enum MoveName {
+    ChoosePowerPlant = "ChoosePowerPlant",
+    Bid = "Bid",
+    DiscardPowerPlant = "DiscardPowerPlant",
+    DiscardResources = "DiscardResources",
+    BuyResource = "BuyResource",
+    Build = "Build",
+    UsePowerPlant = "UsePowerPlant",
+    Pass = "Pass",
+    Undo = "Undo"
+}

package/dist/src/move.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MoveName = void 0;
+var MoveName;
+(function (MoveName) {
+    MoveName["ChoosePowerPlant"] = "ChoosePowerPlant";
+    MoveName["Bid"] = "Bid";
+    MoveName["DiscardPowerPlant"] = "DiscardPowerPlant";
+    MoveName["DiscardResources"] = "DiscardResources";
+    MoveName["BuyResource"] = "BuyResource";
+    MoveName["Build"] = "Build";
+    MoveName["UsePowerPlant"] = "UsePowerPlant";
+    MoveName["Pass"] = "Pass";
+    MoveName["Undo"] = "Undo";
+})(MoveName = exports.MoveName || (exports.MoveName = {}));

package/dist/src/powerPlants.d.ts

@@ -0,0 +1,4 @@
+import { PowerPlant } from './gamestate';
+declare const powerPlants: PowerPlant[];
+declare const indiaPowerPlants: PowerPlant[];
+export { powerPlants, indiaPowerPlants };

package/dist/src/powerPlants.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.indiaPowerPlants = exports.powerPlants = void 0;
+const lodash_1 = require("lodash");
+const gamestate_1 = require("./gamestate");
+const powerPlants = [
+    { number: 3, type: gamestate_1.PowerPlantType.Oil, cost: 2, citiesPowered: 1 },
+    { number: 4, type: gamestate_1.PowerPlantType.Coal, cost: 2, citiesPowered: 1 },
+    { number: 5, type: gamestate_1.PowerPlantType.Hybrid, cost: 2, citiesPowered: 1 },
+    { number: 6, type: gamestate_1.PowerPlantType.Garbage, cost: 1, citiesPowered: 1 },
+    { number: 7, type: gamestate_1.PowerPlantType.Oil, cost: 3, citiesPowered: 2 },
+    { number: 8, type: gamestate_1.PowerPlantType.Coal, cost: 3, citiesPowered: 2 },
+    { number: 9, type: gamestate_1.PowerPlantType.Oil, cost: 1, citiesPowered: 1 },
+    { number: 10, type: gamestate_1.PowerPlantType.Coal, cost: 2, citiesPowered: 2 },
+    { number: 11, type: gamestate_1.PowerPlantType.Uranium, cost: 1, citiesPowered: 2 },
+    { number: 12, type: gamestate_1.PowerPlantType.Hybrid, cost: 2, citiesPowered: 2 },
+    { number: 13, type: gamestate_1.PowerPlantType.Wind, cost: 0, citiesPowered: 1 },
+    { number: 14, type: gamestate_1.PowerPlantType.Garbage, cost: 2, citiesPowered: 2 },
+    { number: 15, type: gamestate_1.PowerPlantType.Coal, cost: 2, citiesPowered: 3 },
+    { number: 16, type: gamestate_1.PowerPlantType.Oil, cost: 2, citiesPowered: 3 },
+    { number: 17, type: gamestate_1.PowerPlantType.Uranium, cost: 1, citiesPowered: 2 },
+    { number: 18, type: gamestate_1.PowerPlantType.Wind, cost: 0, citiesPowered: 2 },
+    { number: 19, type: gamestate_1.PowerPlantType.Garbage, cost: 2, citiesPowered: 3 },
+    { number: 20, type: gamestate_1.PowerPlantType.Coal, cost: 3, citiesPowered: 5 },
+    { number: 21, type: gamestate_1.PowerPlantType.Hybrid, cost: 2, citiesPowered: 4 },
+    { number: 22, type: gamestate_1.PowerPlantType.Wind, cost: 0, citiesPowered: 2 },
+    { number: 23, type: gamestate_1.PowerPlantType.Uranium, cost: 1, citiesPowered: 3 },
+    { number: 24, type: gamestate_1.PowerPlantType.Garbage, cost: 2, citiesPowered: 4 },
+    { number: 25, type: gamestate_1.PowerPlantType.Coal, cost: 2, citiesPowered: 5 },
+    { number: 26, type: gamestate_1.PowerPlantType.Oil, cost: 2, citiesPowered: 5 },
+    { number: 27, type: gamestate_1.PowerPlantType.Wind, cost: 0, citiesPowered: 3 },
+    { number: 28, type: gamestate_1.PowerPlantType.Uranium, cost: 1, citiesPowered: 4 },
+    { number: 29, type: gamestate_1.PowerPlantType.Hybrid, cost: 1, citiesPowered: 4 },
+    { number: 30, type: gamestate_1.PowerPlantType.Garbage, cost: 3, citiesPowered: 6 },
+    { number: 31, type: gamestate_1.PowerPlantType.Coal, cost: 3, citiesPowered: 6 },
+    { number: 32, type: gamestate_1.PowerPlantType.Oil, cost: 3, citiesPowered: 6 },
+    { number: 33, type: gamestate_1.PowerPlantType.Wind, cost: 0, citiesPowered: 4 },
+    { number: 34, type: gamestate_1.PowerPlantType.Uranium, cost: 1, citiesPowered: 5 },
+    { number: 35, type: gamestate_1.PowerPlantType.Oil, cost: 1, citiesPowered: 5 },
+    { number: 36, type: gamestate_1.PowerPlantType.Coal, cost: 3, citiesPowered: 7 },
+    { number: 37, type: gamestate_1.PowerPlantType.Wind, cost: 0, citiesPowered: 4 },
+    { number: 38, type: gamestate_1.PowerPlantType.Garbage, cost: 3, citiesPowered: 7 },
+    { number: 39, type: gamestate_1.PowerPlantType.Uranium, cost: 1, citiesPowered: 6 },
+    { number: 40, type: gamestate_1.PowerPlantType.Oil, cost: 2, citiesPowered: 6 },
+    { number: 42, type: gamestate_1.PowerPlantType.Coal, cost: 2, citiesPowered: 6 },
+    { number: 44, type: gamestate_1.PowerPlantType.Wind, cost: 0, citiesPowered: 5 },
+    { number: 46, type: gamestate_1.PowerPlantType.Hybrid, cost: 3, citiesPowered: 7 },
+    { number: 50, type: gamestate_1.PowerPlantType.Nuclear, cost: 0, citiesPowered: 6 },
+    { number: 99, type: gamestate_1.PowerPlantType.Step3, cost: 0, citiesPowered: 6 },
+];
+exports.powerPlants = powerPlants;
+const indiaPowerPlants = lodash_1.cloneDeep(powerPlants).filter((pp) => pp.number != 11);
+exports.indiaPowerPlants = indiaPowerPlants;
+// Garbage plants cost one more garbage to run, but have no additional storage.
+indiaPowerPlants.forEach((pp) => {
+    if (pp.type == gamestate_1.PowerPlantType.Garbage) {
+        pp.storage = 2 * pp.cost;
+        pp.cost++;
+    }
+});

package/dist/src/prices.d.ts

@@ -0,0 +1,7 @@
+declare const prices: {
+    coal: number[];
+    oil: number[];
+    garbage: number[];
+    uranium: number[];
+};
+export default prices;

package/dist/src/prices.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const gamestate_1 = require("./gamestate");
+const prices = {
+    [gamestate_1.ResourceType.Coal]: [1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6, 7, 7, 7, 8, 8, 8],
+    [gamestate_1.ResourceType.Oil]: [1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6, 7, 7, 7, 8, 8, 8],
+    [gamestate_1.ResourceType.Garbage]: [1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6, 7, 7, 7, 8, 8, 8],
+    [gamestate_1.ResourceType.Uranium]: [1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16],
+};
+exports.default = prices;

package/dist/src/randomizeMap.d.ts

@@ -0,0 +1,3 @@
+import seedrandom from 'seedrandom';
+import { GameMap } from './maps';
+export declare function createRandomizedMap(map: GameMap, regionCount: number, rng: seedrandom.prng): GameMap;

package/dist/src/randomizeMap.js

@@ -0,0 +1,244 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRandomizedMap = void 0;
+const delaunator_1 = __importDefault(require("delaunator"));
+const lodash_1 = require("lodash");
+function createRandomizedMap(map, regionCount, rng) {
+    const regions = [...new Set(map.cities.map((c) => c.region))];
+    const cities = Array(7 * regionCount)
+        .fill(0)
+        .map((_) => ({ name: '', region: '', x: 0, y: 0 }));
+    const widthByRegions = [420, 490, 490];
+    const heightByRegions = [490, 560, 700];
+    const width = widthByRegions[regionCount - 3];
+    const height = heightByRegions[regionCount - 3];
+    const gridCellSize = 70;
+    const gridWidth = Math.ceil(width / gridCellSize);
+    const gridHeight = Math.ceil(height / gridCellSize);
+    const gridLength = gridWidth * gridHeight;
+    const grid = Array(gridLength).fill(-1);
+    map.mapPosition = [100, 200];
+    map.layout = 'Portrait';
+    let emptyGrids = Array(gridLength)
+        .fill(0)
+        .map((_, i) => i);
+    cities.forEach((city, i) => {
+        const emptyGrid = emptyGrids[Math.floor(rng() * emptyGrids.length)];
+        const emptyGridY = Math.floor(emptyGrid / gridWidth);
+        const emptyGridX = emptyGrid % gridWidth;
+        city.x = Math.floor(emptyGridX * 2 * gridCellSize);
+        city.y = Math.floor(emptyGridY * gridCellSize);
+        if (emptyGridY % 2 === 0) {
+            city.x += gridCellSize;
+        }
+        const t = rng() * 2 * Math.PI;
+        const r = (rng() * gridCellSize) / 2;
+        city.x += r * Math.cos(t);
+        city.y += r * Math.sin(t);
+        emptyGrids = emptyGrids.filter((g) => g !== emptyGrid);
+        grid[emptyGrid] = i;
+    });
+    const cityDists = Array(cities.length)
+        .fill(0)
+        .map((_) => Array(cities.length).fill(0));
+    const cityConnections = Array(cities.length)
+        .fill(0)
+        .map((_) => Array(cities.length).fill(null));
+    const d = delaunator_1.default.from(cities, (c) => c.x, (c) => c.y);
+    for (let i = 0; i < d.triangles.length; i += 3) {
+        const city1 = cities[d.triangles[i]];
+        const city2 = cities[d.triangles[i + 1]];
+        const city3 = cities[d.triangles[i + 2]];
+        let dist = cityDists[d.triangles[i]][d.triangles[i + 1]];
+        const dist12Squared = dist
+            ? Math.pow(dist, 2)
+            : Math.pow(city1.x - city2.x, 2) + Math.pow(city1.y - city2.y, 2);
+        const dist12 = dist ||
+            (cityDists[d.triangles[i + 1]][d.triangles[i]] = cityDists[d.triangles[i]][d.triangles[i + 1]] =
+                Math.sqrt(dist12Squared));
+        dist = cityDists[d.triangles[i]][d.triangles[i + 2]];
+        const dist13Squared = dist
+            ? Math.pow(dist, 2)
+            : Math.pow(city1.x - city3.x, 2) + Math.pow(city1.y - city3.y, 2);
+        const dist13 = dist ||
+            (cityDists[d.triangles[i + 2]][d.triangles[i]] = cityDists[d.triangles[i]][d.triangles[i + 2]] =
+                Math.sqrt(dist13Squared));
+        dist = cityDists[d.triangles[i + 1]][d.triangles[i + 2]];
+        const dist23Squared = dist
+            ? Math.pow(dist, 2)
+            : Math.pow(city2.x - city3.x, 2) + Math.pow(city2.y - city3.y, 2);
+        const dist23 = dist ||
+            (cityDists[d.triangles[i + 2]][d.triangles[i + 1]] = cityDists[d.triangles[i + 1]][d.triangles[i + 2]] =
+                Math.sqrt(dist23Squared));
+        // arccos((P122 + P132 - P232) / (2 * P12 * P13))
+        const angle1 = Math.acos((dist12Squared + dist13Squared - dist23Squared) / (2 * dist12 * dist13));
+        const angle2 = Math.acos((dist12Squared + dist23Squared - dist13Squared) / (2 * dist12 * dist23));
+        const angle3 = Math.PI - angle1 - angle2;
+        const maxAngle = (105 * Math.PI) / 180;
+        if (cityConnections[d.triangles[i]][d.triangles[i + 1]] !== false && angle3 < maxAngle) {
+            cityConnections[d.triangles[i]][d.triangles[i + 1]] = true;
+            cityConnections[d.triangles[i + 1]][d.triangles[i]] = true;
+        }
+        else {
+            cityConnections[d.triangles[i]][d.triangles[i + 1]] = false;
+            cityConnections[d.triangles[i + 1]][d.triangles[i]] = false;
+        }
+        if (cityConnections[d.triangles[i]][d.triangles[i + 2]] !== false && angle2 < maxAngle) {
+            cityConnections[d.triangles[i]][d.triangles[i + 2]] = true;
+            cityConnections[d.triangles[i + 2]][d.triangles[i]] = true;
+        }
+        else {
+            cityConnections[d.triangles[i]][d.triangles[i + 2]] = false;
+            cityConnections[d.triangles[i + 2]][d.triangles[i]] = false;
+        }
+        if (cityConnections[d.triangles[i + 1]][d.triangles[i + 2]] !== false && angle1 < maxAngle) {
+            cityConnections[d.triangles[i + 1]][d.triangles[i + 2]] = true;
+            cityConnections[d.triangles[i + 2]][d.triangles[i + 1]] = true;
+        }
+        else {
+            cityConnections[d.triangles[i + 1]][d.triangles[i + 2]] = false;
+            cityConnections[d.triangles[i + 2]][d.triangles[i + 1]] = false;
+        }
+    }
+    let maxDist = 0;
+    let minDist = 1000;
+    for (let i = 0; i < cities.length; i++) {
+        for (let j = 0; j < i; j++) {
+            if (cityConnections[i][j]) {
+                const dist = cityDists[i][j];
+                maxDist = Math.max(maxDist, dist);
+                minDist = Math.min(minDist, dist);
+            }
+        }
+    }
+    const centroids = regionCount === 5
+        ? [
+            [width / 4, height / 4],
+            [width / 4, (3 * height) / 4],
+            [width / 2, height / 2],
+            [(3 * width) / 4, height / 4],
+            [(3 * width) / 4, (3 * height) / 4],
+        ]
+        : regionCount === 4
+            ? [
+                [width / 4, height / 4],
+                [width / 4, (3 * height) / 4],
+                [(3 * width) / 4, height / 4],
+                [(3 * width) / 4, (3 * height) / 4],
+            ]
+            : [
+                [width / 4, height / 4],
+                [width / 2, height / 2],
+                [(3 * width) / 4, (3 * height) / 4],
+            ];
+    const indexes = bkmeans(cities.map((c) => [c.x, c.y]), regionCount, centroids, cityConnections);
+    const countRegions = Array(regionCount).fill(0);
+    cities.forEach((city, index) => {
+        city.region = regions[indexes[index]];
+        city.name = lodash_1.upperFirst(city.region) + ' ' + (countRegions[indexes[index]]++ + 1);
+    });
+    const connections = [];
+    for (let i = 0; i < cities.length; i++) {
+        for (let j = 0; j < i; j++) {
+            if (cityConnections[i][j]) {
+                const city1 = cities[i];
+                const city2 = cities[j];
+                const dist = cityDists[i][j];
+                connections.push({
+                    nodes: [city1.name, city2.name],
+                    cost: Math.floor((5 * dist) / gridCellSize),
+                });
+            }
+        }
+    }
+    map.cities = cities;
+    map.connections = connections;
+    return map;
+}
+exports.createRandomizedMap = createRandomizedMap;
+function bkmeans(points, regions, centroids, connections, iterations = 100) {
+    const indexes = Array(points.length).fill(0);
+    const pointsPerRegion = Math.ceil(points.length / regions);
+    let conv = false;
+    do {
+        // Assign
+        const regionsCount = Array(regions).fill(0);
+        const pointCentDists = Array(points.length)
+            .fill(0)
+            .map((_) => Array(regions).fill(0));
+        points.forEach((point, pi) => {
+            let minDist = null;
+            let index = 0;
+            centroids.forEach((centroid, ci) => {
+                const d = dist(point, centroid);
+                if (minDist === null || d < minDist) {
+                    if (regionsCount[ci] < pointsPerRegion) {
+                        minDist = d;
+                        index = ci;
+                    }
+                }
+                pointCentDists[pi][ci] = d;
+            });
+            indexes[pi] = index;
+            regionsCount[index]++;
+        });
+        // Update
+        const newCentroids = Array(centroids.length)
+            .fill(0)
+            .map((_) => [0, 0]);
+        const centroidsCount = Array(centroids.length).fill(0);
+        points.forEach((point, pi) => {
+            newCentroids[indexes[pi]][0] += point[0];
+            newCentroids[indexes[pi]][1] += point[1];
+            centroidsCount[indexes[pi]]++;
+        });
+        conv = true;
+        centroids.forEach((centroid, ci) => {
+            newCentroids[ci][0] = newCentroids[ci][0] / centroidsCount[ci];
+            newCentroids[ci][1] = newCentroids[ci][1] / centroidsCount[ci];
+            if (centroid[0] !== newCentroids[ci][0] || centroid[1] !== newCentroids[ci][1]) {
+                conv = false;
+            }
+        });
+        centroids = newCentroids;
+        console.log('iterations', iterations);
+        console.log('centroids', centroids);
+        conv = conv || --iterations === 0;
+    } while (!conv);
+    // Refine
+    let maxRefine = 10;
+    do {
+        console.log('Refining');
+        conv = true;
+        points.forEach((_, p1) => {
+            const index = indexes[p1];
+            const hasSameColorNeighbor = connections[p1].some((connection, p2) => connection && index === indexes[p2]);
+            if (!hasSameColorNeighbor) {
+                const centroid = centroids[index];
+                let minDist = null;
+                let closestNeighbor = null;
+                connections[p1].forEach((connection, p2) => {
+                    if (connection) {
+                        const neighbor = points[p2];
+                        const d = dist(neighbor, centroid);
+                        if (minDist === null || d < minDist) {
+                            minDist = d;
+                            closestNeighbor = p2;
+                        }
+                    }
+                });
+                indexes[p1] = indexes[closestNeighbor];
+                indexes[closestNeighbor] = index;
+                conv = false;
+            }
+        });
+        conv = conv || --maxRefine === 0;
+    } while (!conv);
+    return indexes;
+}
+function dist(p1, p2) {
+    return (p1[0] - p2[0]) * (p1[0] - p2[0]) + (p1[1] - p2[1]) * (p1[1] - p2[1]);
+}

package/dist/src/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function asserts<T>(move: any): asserts move is T;
+export declare function shuffle<T>(array: T[], seed: string): T[];

package/dist/src/utils.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shuffle = exports.asserts = void 0;
+const seedrandom_1 = __importDefault(require("seedrandom"));
+/* eslint-disable */
+function asserts(move) { }
+exports.asserts = asserts;
+/* eslint-enable */
+function shuffle(array, seed) {
+    const rng = seedrandom_1.default.alea(seed);
+    const reverse = new Map();
+    array.forEach((item, i) => {
+        let n = rng.int32();
+        while (reverse.has(n)) {
+            n = rng.int32();
+        }
+        reverse.set(n, i);
+    });
+    return [...reverse.keys()].sort().map((n) => array[reverse.get(n)]);
+}
+exports.shuffle = shuffle;

package/dist/wrapper.d.ts

@@ -0,0 +1,30 @@
+import type { GameState } from './index';
+import { GameOptions } from './src/gamestate';
+import { Move } from './src/move';
+export declare function init(nbPlayers: number, expansions: string[], options: GameOptions, seed?: string): Promise<GameState>;
+export declare function setPlayerMetaData(G: GameState, player: number, metaData: {
+    name: string;
+}): GameState;
+export declare function move(G: GameState, move: Move, player: number): Promise<GameState>;
+export { ended, scores, stripSecret } from './src/engine';
+export declare function rankings(G: GameState): number[];
+export declare function factions(G: GameState): string[];
+export declare function replay(G: GameState, { to }: {
+    to: number;
+}): GameState;
+export declare function round(G: GameState): number;
+export declare function dropPlayer(G: GameState, playerNum: number): Promise<GameState>;
+export declare function currentPlayer(G: GameState): number[];
+export declare function messages(G: GameState): {
+    messages: never[];
+    data: GameState;
+};
+export declare function logLength(G: GameState, _player?: number): number;
+export declare function logSlice(G: GameState, options?: {
+    player?: number;
+    start?: number;
+    end?: number;
+}): {
+    log: import("./index").LogItem[];
+    availableMoves: (import("./index").AvailableMoves | null)[];
+};

package/dist/wrapper.js

@@ -0,0 +1,127 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logSlice = exports.logLength = exports.messages = exports.currentPlayer = exports.dropPlayer = exports.round = exports.replay = exports.factions = exports.rankings = exports.stripSecret = exports.scores = exports.ended = exports.move = exports.setPlayerMetaData = exports.init = void 0;
+const engine = __importStar(require("./src/engine"));
+const engine_1 = require("./src/engine");
+const move_1 = require("./src/move");
+const utils_1 = require("./src/utils");
+async function init(nbPlayers, expansions, options, seed) {
+    return engine.setup(nbPlayers, options, seed);
+}
+exports.init = init;
+function setPlayerMetaData(G, player, metaData) {
+    G.players[player].name = metaData.name;
+    return G;
+}
+exports.setPlayerMetaData = setPlayerMetaData;
+async function move(G, move, player) {
+    G = engine.move(G, move, player);
+    return G;
+}
+exports.move = move;
+var engine_2 = require("./src/engine");
+Object.defineProperty(exports, "ended", { enumerable: true, get: function () { return engine_2.ended; } });
+Object.defineProperty(exports, "scores", { enumerable: true, get: function () { return engine_2.scores; } });
+Object.defineProperty(exports, "stripSecret", { enumerable: true, get: function () { return engine_2.stripSecret; } });
+function rankings(G) {
+    const sortedPlayers = engine_1.playersSortedByScore(G);
+    sortedPlayers.forEach((player, index) => {
+        player.ranking = index + 1;
+        if (index > 0) {
+            const prev = sortedPlayers[index - 1];
+            if (player.citiesPowered === prev.citiesPowered &&
+                player.money === prev.money &&
+                player.cities.length === prev.cities.length) {
+                player.ranking = prev.ranking;
+            }
+        }
+    });
+    return G.players.map((pl) => sortedPlayers.find((spl) => pl.id === spl.id).ranking);
+}
+exports.rankings = rankings;
+function factions(G) {
+    return G.players.map((pl) => engine.playerColors[pl.id]);
+}
+exports.factions = factions;
+function replay(G, { to = Infinity }) {
+    const oldPlayers = G.players;
+    const oldG = G;
+    G = engine.setup(G.players.length, G.options, G.seed);
+    for (let i = 0; i < oldPlayers.length && i < G.players.length; i++) {
+        G.players[i].name = oldPlayers[i].name;
+    }
+    for (const move of oldG.log.slice(0, to).filter((event) => event.type === 'move')) {
+        utils_1.asserts(move);
+        G = engine.move(G, move.move, move.player);
+    }
+    return G;
+}
+exports.replay = replay;
+function round(G) {
+    return G.round;
+}
+exports.round = round;
+async function dropPlayer(G, playerNum) {
+    const player = G.players[playerNum];
+    player.isDropped = true;
+    G.log.push({
+        type: 'event',
+        event: `Player ${playerNum} was dropped`,
+    });
+    if (player.availableMoves[move_1.MoveName.Pass]) {
+        G = engine.move(G, { name: move_1.MoveName.Pass, data: true }, playerNum);
+    }
+    else {
+        while (G.currentPlayers.includes(playerNum)) {
+            G = engine.moveAI(G, playerNum);
+        }
+    }
+    return G;
+}
+exports.dropPlayer = dropPlayer;
+function currentPlayer(G) {
+    return G.currentPlayers;
+}
+exports.currentPlayer = currentPlayer;
+function messages(G) {
+    return {
+        messages: [],
+        data: G,
+    };
+}
+exports.messages = messages;
+function logLength(G, _player) {
+    return G.log.length;
+}
+exports.logLength = logLength;
+function logSlice(G, options) {
+    const stripped = engine.stripSecret(G, options === null || options === void 0 ? void 0 : options.player);
+    return {
+        log: stripped.log.slice(options === null || options === void 0 ? void 0 : options.start, options === null || options === void 0 ? void 0 : options.end),
+        availableMoves: (options === null || options === void 0 ? void 0 : options.end) === undefined
+            ? stripped.players.map((pl) => pl.availableMoves)
+            : engine
+                .stripSecret(replay(G, { to: options.end }), options.player)
+                .players.map((pl) => pl.availableMoves),
+    };
+}
+exports.logSlice = logSlice;

package/index.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/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "powergrid-engine",
+  "version": "1.9.7",
+  "description": "An engine for Power Grid",
+  "main": "dist/index.js",
+  "types": "index.ts",
+  "source": "index.ts",
+  "repository": "git@github.com:LucasAMello/powergrid-engine.git",
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "LucasAMello",
+  "license": "MIT",
+  "dependencies": {
+    "delaunator": "^4.0.0",
+    "lodash": "^4.17.15",
+    "seedrandom": "^3.0.5"
+  },
+  "devDependencies": {
+    "@types/chai": "^4.1.2",
+    "@types/delaunator": "^5.0.0",
+    "@types/lodash": "^4.14.149",
+    "@types/mocha": "^2.2.48",
+    "@types/node": "^13.11.0",
+    "@types/seedrandom": "^2.4.27",
+    "@typescript-eslint/eslint-plugin": "^4.25.0",
+    "@typescript-eslint/parser": "^4.25.0",
+    "chai": "^4.1.2",
+    "eslint": "^6.8.0",
+    "eslint-plugin-import": "^2.20.2",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-promise": "^4.2.1",
+    "eslint-plugin-standard": "^4.0.1",
+    "mocha": "^5.0.4",
+    "ts-node": "^10.0.0",
+    "typescript": "^4.3.5"
+  },
+  "files": [
+    "index.ts",
+    "wrapper.ts",
+    "src",
+    "dist",
+    "tsconfig.json"
+  ],
+  "scripts": {
+    "build": "npm run clean && tsc",
+    "clean": "rm -Rf dist",
+    "lint": "eslint . --ext .ts",
+    "test": "mocha -r ts-node/register src/*.spec.ts"
+  }
+}