powergrid-engine 1.9.7

package/wrapper.ts

@@ -0,0 +1,126 @@
+import type { GameState } from './index';
+import * as engine from './src/engine';
+import { playersSortedByScore } from './src/engine';
+import { GameOptions } from './src/gamestate';
+import type { LogMove } from './src/log';
+import { Move, MoveName } from './src/move';
+import { asserts } from './src/utils';
+
+export async function init(
+    nbPlayers: number,
+    expansions: string[],
+    options: GameOptions,
+    seed?: string
+): Promise<GameState> {
+    return engine.setup(nbPlayers, options, seed);
+}
+
+export function setPlayerMetaData(G: GameState, player: number, metaData: { name: string }): GameState {
+    G.players[player].name = metaData.name;
+
+    return G;
+}
+
+export async function move(G: GameState, move: Move, player: number): Promise<GameState> {
+    G = engine.move(G, move, player);
+
+    return G;
+}
+
+export { ended, scores, stripSecret } from './src/engine';
+
+export function rankings(G: GameState): number[] {
+    const sortedPlayers = 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!);
+}
+
+export function factions(G: GameState): string[] {
+    return G.players.map((pl) => engine.playerColors[pl.id]);
+}
+
+export function replay(G: GameState, { to = Infinity }: { to: number }): GameState {
+    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')) {
+        asserts<LogMove>(move);
+
+        G = engine.move(G, move.move, move.player);
+    }
+
+    return G;
+}
+
+export function round(G: GameState): number {
+    return G.round;
+}
+
+export async function dropPlayer(G: GameState, playerNum: number): Promise<GameState> {
+    const player = G.players[playerNum];
+    player.isDropped = true;
+
+    G.log.push({
+        type: 'event',
+        event: `Player ${playerNum} was dropped`,
+    });
+
+    if (player.availableMoves![MoveName.Pass]) {
+        G = engine.move(G, { name: MoveName.Pass, data: true }, playerNum);
+    } else {
+        while (G.currentPlayers.includes(playerNum)) {
+            G = engine.moveAI(G, playerNum);
+        }
+    }
+
+    return G;
+}
+
+export function currentPlayer(G: GameState): number[] {
+    return G.currentPlayers;
+}
+
+export function messages(G: GameState) {
+    return {
+        messages: [],
+        data: G,
+    };
+}
+
+export function logLength(G: GameState, _player?: number): number {
+    return G.log.length;
+}
+
+export function logSlice(G: GameState, options?: { player?: number; start?: number; end?: number }) {
+    const stripped = engine.stripSecret(G, options?.player);
+    return {
+        log: stripped.log.slice(options?.start, options?.end),
+        availableMoves:
+            options?.end === undefined
+                ? stripped.players.map((pl) => pl.availableMoves)
+                : engine
+                      .stripSecret(replay(G, { to: options.end }), options!.player)
+                      .players.map((pl) => pl.availableMoves),
+    };
+}