powergrid-engine 1.9.7

package/src/engine.ts

@@ -0,0 +1,2270 @@
+import assert from 'assert';
+import { cloneDeep, isEqual, range } from 'lodash';
+import seedrandom from 'seedrandom';
+import { availableMoves } from './available-moves';
+import { GameOptions, GameState, Phase, Player, PowerPlant, PowerPlantType, ResourceType } from './gamestate';
+import { LogMove } from './log';
+import { GameMap, maps, mapsRecharged } from './maps';
+import { Move, MoveName, Moves } from './move';
+import { indiaPowerPlants, powerPlants } from './powerPlants';
+import prices from './prices';
+import { createRandomizedMap } from './randomizeMap';
+import { asserts, shuffle } from './utils';
+
+export const playerColors = ['limegreen', 'mediumorchid', 'red', 'dodgerblue', 'yellow', 'brown'];
+
+const citiesToStep2 = [10, 7, 7, 7, 6];
+const citiesToEndGame = [21, 17, 17, 15, 14];
+const cityIncome = [10, 22, 33, 44, 54, 64, 73, 82, 90, 98, 105, 112, 118, 124, 129, 134, 138, 142, 145, 148, 150, 150];
+const regionsInPlay = [3, 3, 4, 5, 5];
+
+export function defaultSetupDeck(
+    numPlayers: number,
+    variant: string,
+    rng: seedrandom.prng,
+    useNewRechargedSetup: boolean
+) {
+    let actualMarket: PowerPlant[];
+    let futureMarket: PowerPlant[];
+    let powerPlantsDeck: PowerPlant[] = cloneDeep(powerPlants);
+
+    if (variant == 'original') {
+        powerPlantsDeck = powerPlantsDeck.slice(8);
+        const powerPlant13 = powerPlantsDeck.splice(2, 1)[0];
+        const step3 = powerPlantsDeck.pop()!;
+
+        powerPlantsDeck = shuffle(powerPlantsDeck, rng() + '');
+        if (numPlayers == 2 || numPlayers == 3) {
+            powerPlantsDeck = powerPlantsDeck.slice(8);
+        } else if (numPlayers == 4) {
+            powerPlantsDeck = powerPlantsDeck.slice(4);
+        }
+
+        powerPlantsDeck.unshift(powerPlant13);
+        powerPlantsDeck.push(step3);
+
+        actualMarket = [getPowerPlant(3), getPowerPlant(4), getPowerPlant(5), getPowerPlant(6)];
+        futureMarket = [getPowerPlant(7), getPowerPlant(8), getPowerPlant(9), getPowerPlant(10)];
+    } else {
+        let initialPowerPlants = shuffle(powerPlantsDeck.splice(0, 13), rng() + '');
+        let initialPlantMarket = initialPowerPlants.splice(0, 8);
+        initialPlantMarket = initialPlantMarket.sort((a, b) => a.number - b.number);
+        actualMarket = initialPlantMarket.slice(0, 4);
+        futureMarket = initialPlantMarket.slice(4);
+
+        const first = initialPowerPlants.shift()!;
+        const step3 = powerPlantsDeck.pop()!;
+
+        powerPlantsDeck = shuffle(powerPlantsDeck, rng() + '');
+        if (numPlayers == 2 || numPlayers == 3) {
+            initialPowerPlants = initialPowerPlants.slice(2);
+            powerPlantsDeck = shuffle(powerPlantsDeck.slice(6).concat(initialPowerPlants), rng() + '');
+        } else if (numPlayers == 4) {
+            initialPowerPlants = initialPowerPlants.slice(1);
+            powerPlantsDeck = shuffle(powerPlantsDeck.slice(3).concat(initialPowerPlants), rng() + '');
+        } else if (useNewRechargedSetup) {
+            // TODO: This flag exists solely to make old tests pass. We should eventually
+            // fix the test and remove the flag.
+            powerPlantsDeck = shuffle(powerPlantsDeck.concat(initialPowerPlants), rng() + '');
+        }
+
+        powerPlantsDeck.unshift(first);
+        powerPlantsDeck.push(step3);
+    }
+
+    return { actualMarket, futureMarket, powerPlantsDeck };
+}
+
+export function setup(
+    numPlayers: number,
+    {
+        fastBid = false,
+        map = 'USA',
+        variant = 'original',
+        showMoney = false,
+        useNewRechargedSetup = true,
+        trackTotalSpent = true,
+        randomizeMap = false,
+    }: GameOptions,
+    seed?: string,
+    forceDeck?: PowerPlant[],
+    forceMap?: GameMap
+): GameState {
+    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)!
+    );
+
+    let actualMarket: PowerPlant[];
+    let futureMarket: PowerPlant[];
+    let powerPlantsDeck: PowerPlant[];
+
+    if (forceDeck) {
+        powerPlantsDeck = forceDeck;
+        actualMarket = powerPlantsDeck.splice(0, 4);
+        futureMarket = powerPlantsDeck.splice(0, 4);
+    } else {
+        if (chosenMap.setupDeck) {
+            ({ actualMarket, futureMarket, powerPlantsDeck } = chosenMap.setupDeck(numPlayers, variant, rng));
+        } else {
+            ({ actualMarket, futureMarket, powerPlantsDeck } = defaultSetupDeck(
+                numPlayers,
+                variant,
+                rng,
+                useNewRechargedSetup
+            ));
+        }
+    }
+
+    const players: Player[] = range(numPlayers).map((id) => ({
+        id,
+        powerPlants: [],
+        coalCapacity: 0,
+        coalLeft: 0,
+        oilCapacity: 0,
+        oilLeft: 0,
+        garbageCapacity: 0,
+        garbageLeft: 0,
+        uraniumCapacity: 0,
+        uraniumLeft: 0,
+        hybridCapacity: 0,
+        hybridLeft: 0,
+        money: 50,
+        housesLeft: 22,
+        cities: [],
+        powerPlantsNotUsed: [],
+        availableMoves: null,
+        lastMove: null,
+        isDropped: false,
+        isAI: false,
+        bid: 0,
+        passed: false,
+        skipAuction: false,
+        citiesPowered: 0,
+        resourcesUsed: [],
+        totalIncome: 0,
+        totalSpentCities: 0,
+        totalSpentConnections: 0,
+        totalSpentPlants: 0,
+        totalSpentResources: 0,
+    }));
+
+    const p = players.length - 2;
+
+    const playerOrder = range(numPlayers);
+    const startingPlayer = playerOrder[0];
+
+    let coalResupply: number[][];
+    let oilResupply: number[][];
+    let garbageResupply: number[][];
+    let uraniumResupply: number[][];
+    if (chosenMap.resupply) {
+        coalResupply = chosenMap.resupply[0];
+        oilResupply = chosenMap.resupply[1];
+        garbageResupply = chosenMap.resupply[2];
+        uraniumResupply = chosenMap.resupply[3];
+    } else {
+        coalResupply = [
+            [3, 4, 3],
+            [4, 5, 3],
+            [5, 6, 4],
+            [5, 7, 5],
+            [7, 9, 6],
+        ];
+        oilResupply = [
+            [2, 2, 4],
+            [2, 3, 4],
+            [3, 4, 5],
+            [4, 5, 6],
+            [5, 6, 7],
+        ];
+        garbageResupply = [
+            [1, 2, 3],
+            [1, 2, 3],
+            [2, 3, 4],
+            [3, 3, 5],
+            [3, 5, 6],
+        ];
+        uraniumResupply = [
+            [1, 1, 1],
+            [1, 1, 1],
+            [1, 2, 2],
+            [2, 3, 2],
+            [2, 3, 3],
+        ];
+    }
+
+    if (chosenMap.layout == 'Portrait' || randomizeMap) {
+        const isUsaRecharged = chosenMap.name === 'USA' && variant === 'recharged';
+        chosenMap.viewBox = chosenMap.viewBox || [1480, 1060];
+        chosenMap.adjustRatio = chosenMap.adjustRatio || [1, 1];
+        chosenMap.playerOrderPosition = chosenMap.playerOrderPosition || [1160, 160];
+        chosenMap.cityCountPosition = chosenMap.cityCountPosition || [0, 0];
+        chosenMap.powerPlantMarketPosition = chosenMap.powerPlantMarketPosition || [745, 0];
+        chosenMap.actualMarketWidth = chosenMap.actualMarketWidth || 430;
+        chosenMap.mapPosition = chosenMap.mapPosition || [0, 0];
+        chosenMap.buttonsPosition = chosenMap.buttonsPosition || [1305, 0];
+        chosenMap.playerBoardsPosition = chosenMap.playerBoardsPosition || [1105, 240];
+        chosenMap.roundInfoPosition = chosenMap.roundInfoPosition || [20, 920];
+        chosenMap.supplyPosition = chosenMap.supplyPosition || [isUsaRecharged ? 480 : 675, 920];
+    } else {
+        chosenMap.viewBox = chosenMap.viewBox || [1465, 860];
+        chosenMap.adjustRatio = chosenMap.adjustRatio || [1, 1];
+        chosenMap.playerOrderPosition = chosenMap.playerOrderPosition || [1160, 140];
+        chosenMap.cityCountPosition = chosenMap.cityCountPosition || [0, 0];
+        chosenMap.powerPlantMarketPosition = chosenMap.powerPlantMarketPosition || [745, 0];
+        chosenMap.actualMarketWidth = chosenMap.actualMarketWidth || 430;
+        chosenMap.mapPosition = chosenMap.mapPosition || [-10, 0];
+        chosenMap.buttonsPosition = chosenMap.buttonsPosition || [1305, 0];
+        chosenMap.playerBoardsPosition = chosenMap.playerBoardsPosition || [1105, 200];
+        chosenMap.roundInfoPosition = chosenMap.roundInfoPosition || [20, 590];
+        chosenMap.supplyPosition = chosenMap.supplyPosition || [0, 720];
+    }
+
+    let finalMap: GameMap;
+    if (randomizeMap) {
+        finalMap = createRandomizedMap(chosenMap, regionsInPlay[p], rng);
+    } else {
+        chosenMap.cities = chosenMap.cities.map((city) => ({
+            ...city,
+            x: city.x * chosenMap.adjustRatio![0],
+            y: city.y * chosenMap.adjustRatio![1],
+        }));
+
+        const regions = chosenMap.cities
+            .filter((c, i) => chosenMap.cities.findIndex((cc) => cc.region == c.region) == i)
+            .map((c) => c.region);
+        const connections = chosenMap.connections.map((con) =>
+            con.nodes.map((n) => chosenMap.cities.find((city) => city.name == n)!.region)
+        );
+        const regionConnections = regions.map((region) =>
+            regions.filter(
+                (area2) => region != area2 && connections.some((con) => con.includes(region) && con.includes(area2))
+            )
+        );
+
+        const playRegions = new Set<string>();
+        while (playRegions.size != Math.min(regionsInPlay[p], regions.length)) {
+            const region = regions[Math.floor(rng() * regions.length)];
+            if (
+                playRegions.size == 0 ||
+                regionConnections[regions.indexOf(region)].some((con) => playRegions.has(con))
+            ) {
+                playRegions.add(region);
+
+                // Avoid italy Red Green Blue
+                if (chosenMap.name === 'Italy') {
+                    if (playRegions.has('red') && playRegions.has('green') && playRegions.has('blue')) {
+                        playRegions.clear();
+                    }
+                }
+            }
+        }
+
+        const filteredMap = cloneDeep(chosenMap);
+        filteredMap.cities = filteredMap.cities.filter((city) => playRegions.has(city.region));
+        filteredMap.connections = filteredMap.connections.filter((con) =>
+            con.nodes
+                .map((n) => chosenMap.cities.find((city) => city.name == n)!.region)
+                .every((r) => playRegions.has(r))
+        );
+
+        finalMap = filteredMap;
+    }
+
+    const coalMarket = chosenMap.startingResources ? chosenMap.startingResources[0] : 24;
+    const oilMarket = chosenMap.startingResources ? chosenMap.startingResources[1] : 18;
+    const garbageMarket = chosenMap.startingResources ? chosenMap.startingResources[2] : variant == 'original' ? 6 : 9;
+    const uraniumMarket = chosenMap.startingResources ? chosenMap.startingResources[3] : 2;
+
+    const totalCoal = chosenMap.startingSupply ? chosenMap.startingSupply[0] : 24;
+    const totalOil = chosenMap.startingSupply ? chosenMap.startingSupply[1] : 24;
+    const totalGarbage = chosenMap.startingSupply ? chosenMap.startingSupply[2] : 24;
+    const totalUranium = chosenMap.startingSupply ? chosenMap.startingSupply[3] : 12;
+
+    const coalSupply = totalCoal - coalMarket;
+    const oilSupply = totalOil - oilMarket;
+    const garbageSupply = totalGarbage - garbageMarket;
+    const uraniumSupply = totalUranium - uraniumMarket;
+
+    const coalPrices = cloneDeep(chosenMap.coalPrices ?? prices.coal);
+    const oilPrices = cloneDeep(chosenMap.oilPrices ?? prices.oil);
+    const garbagePrices = cloneDeep(chosenMap.garbagePrices ?? prices.garbage);
+    const uraniumPrices = cloneDeep(chosenMap.uraniumPrices ?? prices.uranium);
+
+    const G: GameState = {
+        map: forceMap || finalMap,
+        players,
+        playerOrder,
+        currentPlayers: [startingPlayer],
+        powerPlantsDeck,
+        coalSupply,
+        oilSupply,
+        garbageSupply,
+        uraniumSupply,
+        coalResupply,
+        oilResupply,
+        garbageResupply,
+        uraniumResupply,
+        coalMarket,
+        oilMarket,
+        garbageMarket,
+        uraniumMarket,
+        coalPrices,
+        oilPrices,
+        garbagePrices,
+        uraniumPrices,
+        actualMarket,
+        futureMarket,
+        chosenPowerPlant: undefined,
+        currentBid: undefined,
+        highestBidders: [],
+        auctioningPlayer: undefined,
+        step: 1,
+        phase: Phase.Auction,
+        options: { fastBid, map, variant, showMoney, useNewRechargedSetup, trackTotalSpent },
+        log: [],
+        hiddenLog: [],
+        seed,
+        round: 1,
+        auctionSkips: 0,
+        citiesToStep2: citiesToStep2[numPlayers - 2],
+        citiesToEndGame: citiesToEndGame[numPlayers - 2],
+        resourceResupply: [
+            `[${coalResupply[p][0]}, ${oilResupply[p][0]}, ${garbageResupply[p][0]}, ${uraniumResupply[p][0]}]`,
+            `[${coalResupply[p][1]}, ${oilResupply[p][1]}, ${garbageResupply[p][1]}, ${uraniumResupply[p][1]}]`,
+            `[${coalResupply[p][2]}, ${oilResupply[p][2]}, ${garbageResupply[p][2]}, ${uraniumResupply[p][2]}]`,
+        ],
+        paymentTable: cityIncome,
+        variant,
+        minimunBid: 0,
+        plantDiscountActive:
+            variant == 'recharged' && (forceMap || finalMap).name != 'China' && (forceMap || finalMap).name != 'Russia',
+        discardSmallestPlant: false,
+        cardsLeft: powerPlantsDeck.length,
+        nextCardWeak: variant == 'recharged',
+        card39Bought: false,
+        knownPowerPlantDeck: actualMarket.concat(futureMarket),
+        knownPowerPlantDeckStep3: [],
+        powerPlantDeckAfterStep3: undefined,
+    } as GameState;
+
+    G.log.push({ type: 'event', event: 'Game Start!' });
+
+    if (G.map.name == 'Middle East') {
+        removePlantsForMiddleEastStep1(G);
+    }
+
+    G.players[startingPlayer].availableMoves = availableMoves(G, G.players[startingPlayer]);
+
+    return G;
+}
+
+export function stripSecret(G: GameState, player?: number): GameState {
+    return {
+        ...G,
+        seed: 'secret',
+        hiddenLog: [],
+        powerPlantsDeck: [],
+        players: G.players.map((pl, i) => {
+            if (player === i) {
+                return pl;
+            } else {
+                return {
+                    ...pl,
+                    availableMoves: pl.availableMoves ? {} : null,
+                    money: ended(G) || G.options.showMoney ? pl.money : -1,
+                    bid: G.options.fastBid ? 0 : pl.bid,
+                };
+            }
+        }),
+        log: G.log,
+    };
+}
+
+export function currentPlayers(G: GameState): number[] {
+    return G.currentPlayers;
+}
+
+export function move(G: GameState, move: Move, playerNumber: number, isUndo = false): GameState {
+    const player = G.players[playerNumber];
+    const available = player.availableMoves?.[move.name];
+
+    updateGameState(G);
+
+    assert(G.currentPlayers.includes(playerNumber), 'It is not your turn!');
+    assert(available, 'You are not allowed to run the command ' + move.name);
+
+    // Fix for issue 8: can't undo because of a move (discaring the pp you just bought) that is now invalid
+    if (
+        !isUndo ||
+        move.name != MoveName.DiscardPowerPlant ||
+        player.powerPlants[player.powerPlants.length - 1].number != move.data
+    ) {
+        assert(
+            available.some((x) => isEqual(x, move.data)),
+            'Wrong argument for the command ' + move.name
+        );
+    }
+
+    switch (move.name) {
+        case MoveName.ChoosePowerPlant: {
+            asserts<Moves.MoveChoosePowerPlant>(move);
+
+            G.chosenPowerPlant = getPowerPlant(move.data, G.map.name);
+            G.auctioningPlayer = player.id;
+
+            if (move.data == 39) {
+                G.card39Bought = true;
+            }
+
+            if (
+                G.options.variant == 'recharged' &&
+                G.plantDiscountActive &&
+                G.chosenPowerPlant.number == G.actualMarket[0].number
+            ) {
+                G.minimunBid = 1;
+                G.plantDiscountActive = false;
+                move.usedPlantDiscount = true;
+            } else {
+                G.minimunBid = move.data;
+            }
+
+            const notPassed = G.players.filter((p) => !p.skipAuction && !p.isDropped);
+            if (notPassed.length == 1) {
+                G.log.push({
+                    type: 'move',
+                    player: playerNumber,
+                    move,
+                    simple: `${player.name} chooses Power Plant ${move.data}.`,
+                    pretty: `${playerNameHTML(player)} chooses Power Plant <b>${move.data}</b>.`,
+                });
+
+                const winningPlayer = notPassed[0];
+                endAuction(G, winningPlayer, G.minimunBid);
+
+                if (G.round == 1) {
+                    setPlayerOrder(G);
+                }
+
+                if (
+                    winningPlayer.powerPlants.length <= 3 ||
+                    (G.players.length == 2 && winningPlayer.powerPlants.length == 4)
+                ) {
+                    if (G.map.name != 'China' || G.step == 3) {
+                        addPowerPlant(G);
+                    }
+
+                    toResourcesPhase(G);
+                }
+            } else {
+                G.log.push({
+                    type: 'move',
+                    player: playerNumber,
+                    move,
+                    simple: `${player.name} chooses Power Plant ${move.data} to initiate an auction.`,
+                    pretty: `${playerNameHTML(player)} chooses Power Plant <b>${move.data}</b> to initiate an auction.`,
+                });
+
+                if (G.options.fastBid) {
+                    G.currentPlayers = G.playerOrder.filter(
+                        (p) => !G.players[p].skipAuction && !G.players[p].isDropped
+                    );
+                }
+            }
+
+            break;
+        }
+
+        case MoveName.Bid: {
+            asserts<Moves.MoveBid>(move);
+
+            if (G.options.fastBid) {
+                G.hiddenLog.push({
+                    type: 'move',
+                    player: playerNumber,
+                    move,
+                    simple: `${player.name} bids $${move.data}.`,
+                    pretty: `${playerNameHTML(player)} bids <span style="color: green">$${move.data}</span>.`,
+                });
+
+                fastAuction(G, player, move.data);
+            } else {
+                G.currentBid = player.bid = move.data;
+
+                G.log.push({
+                    type: 'move',
+                    player: playerNumber,
+                    move,
+                    simple: `${player.name} bids $${move.data}.`,
+                    pretty: `${playerNameHTML(player)} bids <span style="color: green">$${move.data}</span>.`,
+                });
+
+                nextPlayerClockwise(G);
+            }
+
+            break;
+        }
+
+        case MoveName.Pass: {
+            asserts<Moves.MovePass>(move);
+
+            if (!G.options.fastBid || G.phase != Phase.Auction || !G.chosenPowerPlant) {
+                G.log.push({
+                    type: 'move',
+                    player: playerNumber,
+                    move,
+                    simple: `${player.name} passes.`,
+                    pretty: `${playerNameHTML(player)} passes.`,
+                });
+            }
+
+            switch (G.phase) {
+                case Phase.Auction: {
+                    if (G.chosenPowerPlant == undefined) {
+                        player.skipAuction = true;
+                        G.auctionSkips++;
+                        if (G.auctionSkips == 1 && G.map.name == 'Russia' && G.actualMarket?.length > 0) {
+                            G.log.push({
+                                type: 'event',
+                                event: `First pass, removing lowest numbered Power Plant (${G.actualMarket[0].number}).`,
+                            });
+
+                            G.actualMarket.shift();
+                            addPowerPlant(G);
+                        }
+
+                        if (G.players.some((p) => !p.skipAuction && !p.isDropped)) {
+                            nextPlayerAuction(G);
+                        } else {
+                            if (
+                                G.auctionSkips == G.players.length &&
+                                G.options.variant == 'original' &&
+                                G.map.name != 'China' &&
+                                G.map.name != 'Russia'
+                            ) {
+                                G.log.push({
+                                    type: 'event',
+                                    event: `Everyone passed, removing lowest numbered Power Plant (${G.actualMarket[0].number}).`,
+                                });
+
+                                G.actualMarket.shift();
+                                addPowerPlant(G);
+                            }
+
+                            toResourcesPhase(G);
+                        }
+                    } else {
+                        if (G.options.fastBid) {
+                            G.hiddenLog.push({
+                                type: 'move',
+                                player: playerNumber,
+                                move,
+                                simple: `${player.name} passes.`,
+                                pretty: `${playerNameHTML(player)} passes.`,
+                            });
+
+                            fastAuction(G, player, 0);
+                        } else {
+                            player.passed = true;
+
+                            const notPassed = G.players.filter((p) => !p.passed && !p.skipAuction && !p.isDropped);
+                            if (notPassed.length == 1) {
+                                const winningPlayer = notPassed[0];
+                                endAuction(G, winningPlayer, winningPlayer.bid);
+
+                                if (
+                                    (winningPlayer.powerPlants.length > 4 ||
+                                        (G.players.length > 2 && winningPlayer.powerPlants.length > 3)) &&
+                                    !winningPlayer.isDropped
+                                ) {
+                                    setCurrentPlayer(G, winningPlayer.id);
+                                } else {
+                                    if (G.map.name != 'China' || G.step == 3) {
+                                        addPowerPlant(G);
+                                    }
+
+                                    if (G.players.some((p) => !p.skipAuction && !p.isDropped)) {
+                                        G.players.forEach((p) => {
+                                            p.bid = 0;
+                                            p.passed = p.isDropped;
+                                        });
+
+                                        nextPlayerAuction(G, true);
+                                    } else {
+                                        toResourcesPhase(G);
+                                    }
+                                }
+                            } else {
+                                nextPlayerClockwise(G);
+                            }
+                        }
+                    }
+
+                    break;
+                }
+
+                case Phase.Resources: {
+                    if (G.map.name == 'India') {
+                        if (G.chosenResource) {
+                            G.chosenResource = undefined;
+                        } else {
+                            player.passed = true;
+                        }
+                    } else {
+                        player.passed = true;
+                    }
+
+                    if (G.players.filter((p) => !p.passed && !p.isDropped).length == 0) {
+                        G.players.forEach((p) => {
+                            p.passed = p.isDropped;
+                        });
+                        G.phase = Phase.Building;
+
+                        if (G.map.name == 'India') {
+                            G.citiesBuiltInCurrentRound = 0;
+                        }
+
+                        setCurrentPlayer(G, G.playerOrder[G.players.length - 1]);
+
+                        if (G.players[G.currentPlayers[0]].isDropped && G.players.some((p) => !p.isDropped)) {
+                            G.players[G.currentPlayers[0]].passed = true;
+                            nextPlayerReverse(G);
+                        }
+                    } else {
+                        nextPlayerReverse(G);
+                    }
+
+                    if (G.map.name == 'India') {
+                        while (G.players[G.currentPlayers[0]].passed) {
+                            nextPlayerReverse(G);
+                        }
+                    }
+
+                    break;
+                }
+
+                case Phase.Building: {
+                    player.passed = true;
+
+                    if (G.players.filter((p) => !p.passed && !p.isDropped).length == 0) {
+                        const maxCities = Math.max(...G.players.map((p) => p.cities.length));
+                        if (G.step == 1) {
+                            if (maxCities >= G.citiesToStep2 && G.map.name != 'Middle East') {
+                                const powerPlant = G.actualMarket.shift()!;
+                                G.log.push({
+                                    type: 'event',
+                                    event: `Starting Step 2, Power Plant ${powerPlant?.number} discarded.`,
+                                });
+                                G.step = 2;
+
+                                // Spain & Portugal: put plants 18, 22 and 27 on top
+                                if (G.map.name == 'Spain & Portugal') {
+                                    if (!G.powerPlantsDeck.find((p) => p.number == 18)) {
+                                        G.powerPlantsDeck.unshift(getPowerPlant(27));
+                                        G.powerPlantsDeck.unshift(getPowerPlant(22));
+                                        G.powerPlantsDeck.unshift(getPowerPlant(18));
+                                    }
+                                }
+
+                                addPowerPlant(G);
+                            }
+                        }
+
+                        if (maxCities >= G.citiesToEndGame) {
+                            G.phase = Phase.GameEnd;
+                            G.currentPlayers = [];
+                            calculateCitiesPowered(G);
+
+                            // Include payouts in phase 5 if there is a power outage in India.
+                            if (G.map.name == 'India' && G.citiesBuiltInCurrentRound! > G.players.length * 2) {
+                                G.players.forEach((player) => {
+                                    const payment = G.paymentTable[player.citiesPowered] - 3 * player.cities.length;
+                                    player.money += Math.max(payment, 0);
+                                    player.totalIncome += Math.max(payment, 0);
+                                });
+                            }
+
+                            G.log.push({ type: 'event', event: 'Game Ended!' });
+                        } else {
+                            G.players.forEach((p) => {
+                                p.passed = p.isDropped;
+                                p.powerPlantsNotUsed = p.powerPlants.map((pp) => pp.number);
+                            });
+                            G.phase = Phase.Bureaucracy;
+                            G.currentPlayers = G.playerOrder.filter(
+                                (p) => !G.players[p].passed && !G.players[p].isDropped
+                            );
+
+                            if (G.map.name == 'India') {
+                                // Compute the maximum number of cities each player can power.
+                                G.players.forEach(
+                                    (player) => (player.targetCitiesPowered = calculateMaxCitiesPowered(player))
+                                );
+
+                                // Output log for power outage.
+                                if (G.citiesBuiltInCurrentRound! > G.players.length * 2) {
+                                    G.log.push({
+                                        type: 'event',
+                                        event: `Power outage! ${G.citiesBuiltInCurrentRound} built this round, which is more than twice the number of players.`,
+                                    });
+                                }
+                            }
+
+                            if (G.map.name == 'China' && G.step <= 2) {
+                                rebuildPlantMarketForChina(G);
+                            } else if (G.futureMarket.length == 0) {
+                                G.step = 3;
+                            }
+                        }
+                    } else {
+                        nextPlayerReverse(G);
+                    }
+
+                    break;
+                }
+
+                case Phase.Bureaucracy: {
+                    player.passed = true;
+                    const citiesPowered: number = Math.min(player.cities.length, player.citiesPowered);
+                    let payment: number = G.paymentTable[citiesPowered];
+
+                    // For the India map, if the number of cities built in the current round is more than twice
+                    // the number of players, each player is penalized three Elektro per city (power outage).
+                    if (G.map.name == 'India' && G.citiesBuiltInCurrentRound! > G.players.length * 2) {
+                        payment -= 3 * player.cities.length;
+                        payment = Math.max(payment, 0); // No negative income
+                    }
+
+                    player.money += payment;
+
+                    if (G.options.trackTotalSpent) {
+                        player.totalIncome += payment;
+                    }
+
+                    player.citiesPowered = 0;
+
+                    if (G.map.name == 'India') {
+                        player.targetCitiesPowered = 0;
+                    }
+
+                    if (G.players.filter((p) => !p.passed && !p.isDropped).length == 0) {
+                        const coalResupplyValue = Math.min(
+                            G.coalSupply,
+                            G.coalResupply![G.players.length - 2][G.step - 1]
+                        );
+                        G.coalMarket += coalResupplyValue;
+                        G.coalSupply -= coalResupplyValue;
+
+                        let oilResupplyValue: number;
+                        if (G.map.name == 'Middle East') {
+                            if (G.oilMarket == 0) {
+                                G.oilPrices = prices[ResourceType.Oil];
+                            }
+
+                            oilResupplyValue = G.oilResupply![G.players.length - 2][G.step - 1];
+                            for (let i = 0; i < oilResupplyValue; i++) {
+                                if (G.oilSupply > 0) {
+                                    G.oilMarket++;
+                                    G.oilSupply--;
+                                } else {
+                                    // If we have more oil to stock than is in the supply, we shift the prices downward.
+                                    G.oilPrices!.pop()!;
+                                    G.oilPrices!.unshift(1);
+                                }
+                            }
+                        } else {
+                            oilResupplyValue = Math.min(G.oilSupply, G.oilResupply![G.players.length - 2][G.step - 1]);
+                            G.oilMarket += oilResupplyValue;
+                            G.oilSupply -= oilResupplyValue;
+                        }
+
+                        const garbageResupplyValue = Math.min(
+                            G.garbageSupply,
+                            G.garbageResupply![G.players.length - 2][G.step - 1]
+                        );
+                        G.garbageMarket += garbageResupplyValue;
+                        G.garbageSupply -= garbageResupplyValue;
+
+                        let uraniumResupplyValue = 0;
+                        if (
+                            G.options.variant != 'recharged' ||
+                            (G.options.map != 'Germany' && G.options.map != 'Italy') ||
+                            !G.card39Bought
+                        ) {
+                            uraniumResupplyValue = Math.min(
+                                G.uraniumSupply,
+                                G.uraniumResupply![G.players.length - 2][G.step - 1]
+                            );
+                            G.uraniumMarket += uraniumResupplyValue;
+                            G.uraniumSupply -= uraniumResupplyValue;
+                        }
+
+                        G.log.push({
+                            type: 'event',
+                            event: `Resupplying resources: [${coalResupplyValue}, ${oilResupplyValue}, ${garbageResupplyValue}, ${uraniumResupplyValue}].`,
+                        });
+
+                        if (G.map.name == 'Middle East' && G.step == 2 && G.futureMarket.length > 0) {
+                            // If we aren't about to enter step 3, discard top two plants instead of one.
+                            let powerPlantToPush: PowerPlant = G.futureMarket.pop()!;
+                            G.log.push({
+                                type: 'event',
+                                event: `Putting Power Plant ${powerPlantToPush.number} on the bottom of the deck.`,
+                            });
+                            G.powerPlantsDeck.push(powerPlantToPush);
+                            addPowerPlant(G);
+
+                            // If Step 3 was drawn above, futureMarket will be empty so use actualMarket instead
+                            powerPlantToPush = G.futureMarket.length ? G.futureMarket.pop()! : G.actualMarket.pop()!;
+                            G.log.push({
+                                type: 'event',
+                                event: `Putting Power Plant ${powerPlantToPush.number} on the bottom of the deck.`,
+                            });
+                            G.powerPlantsDeck.push(powerPlantToPush);
+                            addPowerPlant(G);
+                        } else if (G.futureMarket.length > 0) {
+                            if (
+                                G.map.name == 'Benelux' &&
+                                (G.options.variant == 'original' || G.discardSmallestPlant)
+                            ) {
+                                const removedPlant = G.actualMarket[0];
+                                G.log.push({
+                                    type: 'event',
+                                    event: `Removing smallest plant, Power Plant ${removedPlant.number}.`,
+                                });
+                                G.actualMarket.shift();
+                                addPowerPlant(G);
+                                G.discardSmallestPlant = false;
+                            }
+
+                            let powerPlantToPush: PowerPlant | undefined;
+                            if (G.map.name == 'Quebec') {
+                                // For the Quebec map, ecological plants will never be put on the bottom of the deck.
+                                const nonEcoPlants = G.futureMarket.filter((pp) => pp.type != PowerPlantType.Wind);
+                                powerPlantToPush = nonEcoPlants.pop();
+
+                                if (powerPlantToPush) {
+                                    G.futureMarket = G.futureMarket.filter(
+                                        (pp) => pp.number != powerPlantToPush?.number
+                                    );
+                                } else {
+                                    const nonEcoPlants = G.actualMarket.filter((pp) => pp.type != PowerPlantType.Wind);
+                                    powerPlantToPush = nonEcoPlants.pop();
+
+                                    if (powerPlantToPush) {
+                                        G.actualMarket = G.actualMarket.filter(
+                                            (pp) => pp.number != powerPlantToPush?.number
+                                        );
+                                    }
+                                }
+                            } else {
+                                powerPlantToPush = G.futureMarket.pop()!;
+                            }
+
+                            // This check covers the rare case in which a Quebec game might have a futures market consisting of
+                            // all ecological plants. In that case, we do not draw a new plant.
+                            if (powerPlantToPush) {
+                                G.log.push({
+                                    type: 'event',
+                                    event: `Putting Power Plant ${powerPlantToPush.number} on the bottom of the deck.`,
+                                });
+                                G.powerPlantsDeck.push(powerPlantToPush);
+                                addPowerPlant(G);
+                            }
+                        } else if (G.actualMarket.length > 0 && (G.map.name != 'China' || G.step == 3)) {
+                            G.log.push({ type: 'event', event: `Discarding Power Plant ${G.actualMarket[0].number}.` });
+                            G.actualMarket.shift();
+                            addPowerPlant(G);
+                        }
+
+                        G.round++;
+
+                        setPlayerOrder(G);
+
+                        G.players.forEach((p) => {
+                            p.passed = p.isDropped;
+                        });
+                        G.auctionSkips = 0;
+
+                        if (G.actualMarket.length > 0) {
+                            G.phase = Phase.Auction;
+
+                            if (G.futureMarket.length == 0 && G.map.name != 'China') {
+                                G.step = 3;
+                            }
+
+                            G.plantDiscountActive =
+                                G.options.variant == 'recharged' && G.map.name != 'China' && G.map.name != 'Russia';
+                            setCurrentPlayer(G, G.playerOrder[0]);
+                        } else {
+                            toResourcesPhase(G);
+                        }
+                    } else {
+                        G.currentPlayers = G.playerOrder.filter((p) => !G.players[p].passed && !G.players[p].isDropped);
+                    }
+
+                    break;
+                }
+            }
+
+            break;
+        }
+
+        case MoveName.DiscardPowerPlant: {
+            asserts<Moves.MoveDiscardPowerPlant>(move);
+
+            if (!move.extra) {
+                G.log.push({
+                    type: 'move',
+                    player: playerNumber,
+                    move,
+                    simple: `${player.name} discards Power Plant ${move.data}.`,
+                    pretty: `${playerNameHTML(player)} discards Power Plant <b>${move.data}</b>.`,
+                });
+            }
+
+            const powerPlant = player.powerPlants.find((p) => p.number == move.data)!;
+            player.powerPlants = player.powerPlants.filter((p) => p.number != move.data);
+
+            updatePlayerCapacity(player);
+
+            if (move.extra) {
+                const discarded: string[] = [];
+                switch (powerPlant.type) {
+                    case PowerPlantType.Coal:
+                        G.coalSupply += move.extra[0];
+                        player.coalLeft -= move.extra[0];
+                        discarded.push(move.extra[0] + ' Coal');
+                        break;
+
+                    case PowerPlantType.Oil:
+                        G.oilSupply += move.extra[0];
+                        player.oilLeft -= move.extra[0];
+                        discarded.push(move.extra[0] + ' Oil');
+                        break;
+
+                    case PowerPlantType.Garbage:
+                        G.garbageSupply += move.extra[0];
+                        player.garbageLeft -= move.extra[0];
+                        discarded.push(move.extra[0] + ' Garbage');
+                        break;
+
+                    case PowerPlantType.Uranium:
+                        G.uraniumSupply += move.extra[0];
+                        player.uraniumLeft -= move.extra[0];
+                        discarded.push(move.extra[0] + ' Uranium');
+                        break;
+
+                    case PowerPlantType.Hybrid:
+                        if (move.extra[0] > 0) {
+                            G.coalSupply += move.extra[0];
+                            player.coalLeft -= move.extra[0];
+                            discarded.push(move.extra[0] + ' Coal');
+                        }
+
+                        if (move.extra[1] > 0) {
+                            G.oilSupply += move.extra[1];
+                            player.oilLeft -= move.extra[1];
+                            discarded.push(move.extra[1] + ' Oil');
+                        }
+
+                        break;
+                }
+
+                G.log.push({
+                    type: 'move',
+                    player: playerNumber,
+                    move,
+                    simple: `${player.name} discards Power Plant ${move.data} and ${discarded.join(', ')}.`,
+                    pretty: `${playerNameHTML(player)} discards Power Plant <b>${move.data}</b> and ${discarded.join(
+                        ', '
+                    )}.`,
+                });
+
+                if (G.map.name != 'China' || G.step == 3) {
+                    addPowerPlant(G);
+                }
+
+                G.players.forEach((p) => {
+                    p.bid = 0;
+                    p.passed = p.isDropped;
+                });
+
+                if (G.players.some((p) => !p.skipAuction && !p.isDropped)) {
+                    nextPlayerAuction(G, true);
+                } else {
+                    toResourcesPhase(G);
+                }
+            } else {
+                const toDiscard: ResourceType[] = [];
+                let hybridCapacityUsed =
+                    player.hybridCapacity > 0 ? Math.max(0, player.oilLeft - player.oilCapacity) : 0;
+                if (player.coalCapacity + player.hybridCapacity < player.coalLeft + hybridCapacityUsed) {
+                    toDiscard.push(ResourceType.Coal);
+                }
+
+                hybridCapacityUsed = player.hybridCapacity > 0 ? Math.max(0, player.coalLeft - player.coalCapacity) : 0;
+                if (player.oilCapacity + player.hybridCapacity < player.oilLeft + hybridCapacityUsed) {
+                    toDiscard.push(ResourceType.Oil);
+                }
+
+                if (player.garbageLeft > player.garbageCapacity) {
+                    G.garbageSupply += player.garbageLeft - player.garbageCapacity;
+                    player.garbageLeft = player.garbageCapacity;
+                }
+
+                if (player.uraniumLeft > player.uraniumCapacity) {
+                    G.uraniumSupply += player.uraniumLeft - player.uraniumCapacity;
+                    player.uraniumLeft = player.uraniumCapacity;
+                }
+
+                if (toDiscard.length == 1) {
+                    if (toDiscard[0] == ResourceType.Coal) {
+                        G.coalSupply += player.coalLeft - player.coalCapacity;
+                        player.coalLeft = player.coalCapacity;
+                    } else if (toDiscard[0] == ResourceType.Oil) {
+                        G.oilSupply += player.oilLeft - player.oilCapacity;
+                        player.oilLeft = player.oilCapacity;
+                    }
+
+                    toDiscard.pop();
+                }
+
+                if (toDiscard.length == 0) {
+                    if (G.map.name != 'China' || G.step == 3) {
+                        addPowerPlant(G);
+                    }
+                    G.players.forEach((p) => {
+                        p.bid = 0;
+                        p.passed = p.isDropped;
+                    });
+
+                    if (G.players.some((p) => !p.skipAuction && !p.isDropped)) {
+                        nextPlayerAuction(G, true);
+                    } else {
+                        toResourcesPhase(G);
+                    }
+                }
+            }
+
+            break;
+        }
+
+        case MoveName.DiscardResources: {
+            asserts<Moves.MoveDiscardResources>(move);
+
+            G.log.push({
+                type: 'move',
+                player: playerNumber,
+                move,
+                simple: `${player.name} discarded a ${move.data}.`,
+                pretty: `${playerNameHTML(player)} discarded a <b>${move.data}</b>.`,
+            });
+
+            if (move.data == ResourceType.Coal) {
+                player.coalLeft--;
+                G.coalSupply++;
+            } else if (move.data == ResourceType.Oil) {
+                player.oilLeft--;
+                G.oilSupply++;
+            }
+
+            const toDiscard: ResourceType[] = [];
+            let hybridCapacityUsed = player.hybridCapacity > 0 ? Math.max(0, player.oilLeft - player.oilCapacity) : 0;
+            if (player.coalCapacity + player.hybridCapacity < player.coalLeft + hybridCapacityUsed) {
+                toDiscard.push(ResourceType.Coal);
+            }
+
+            hybridCapacityUsed = player.hybridCapacity > 0 ? Math.max(0, player.coalLeft - player.coalCapacity) : 0;
+            if (player.oilCapacity + player.hybridCapacity < player.oilLeft + hybridCapacityUsed) {
+                toDiscard.push(ResourceType.Oil);
+            }
+
+            if (toDiscard.length == 1) {
+                if (toDiscard[0] == ResourceType.Coal) {
+                    player.coalLeft--;
+                } else if (toDiscard[0] == ResourceType.Oil) {
+                    player.oilLeft--;
+                }
+
+                toDiscard.pop();
+            }
+
+            if (toDiscard.length == 0) {
+                if (G.map.name != 'China' || G.step == 3) {
+                    addPowerPlant(G);
+                }
+                G.players.forEach((p) => {
+                    p.bid = 0;
+                    p.passed = p.isDropped;
+                });
+
+                if (G.players.some((p) => !p.skipAuction && !p.isDropped)) {
+                    nextPlayerAuction(G, true);
+                } else {
+                    toResourcesPhase(G);
+                }
+            }
+
+            break;
+        }
+
+        case MoveName.BuyResource: {
+            asserts<Moves.MoveBuyResource>(move);
+            G.chosenResource = move.data.resource;
+
+            let price: number;
+            switch (move.data.resource) {
+                case ResourceType.Coal: {
+                    if (G.coalMarket == 0) {
+                        price = 8;
+                        player.coalLeft++;
+                        G.coalSupply--;
+                        move.fromSupply = true;
+                    } else {
+                        const coalPrices = G.coalPrices ?? prices[ResourceType.Coal];
+                        price = coalPrices[coalPrices.length - G.coalMarket];
+                        player.coalLeft++;
+                        G.coalMarket--;
+                    }
+
+                    break;
+                }
+
+                case ResourceType.Oil: {
+                    const oilPrices = G.oilPrices ?? prices[ResourceType.Oil];
+                    price = oilPrices[oilPrices.length - G.oilMarket];
+                    player.oilLeft++;
+                    G.oilMarket--;
+                    break;
+                }
+
+                case ResourceType.Garbage: {
+                    const garbagePrices = G.garbagePrices ?? prices[ResourceType.Garbage];
+                    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?.length > 0) {
+                            price--;
+                        }
+                    }
+
+                    player.garbageLeft++;
+                    G.garbageMarket--;
+                    break;
+                }
+
+                case ResourceType.Uranium: {
+                    const uraniumPrices = G.uraniumPrices ?? prices[ResourceType.Uranium];
+                    price = uraniumPrices[uraniumPrices.length - G.uraniumMarket];
+                    player.uraniumLeft++;
+                    G.uraniumMarket--;
+                    break;
+                }
+            }
+
+            player.money -= price;
+
+            if (G.options.trackTotalSpent) {
+                player.totalSpentResources += price;
+            }
+
+            G.log.push({
+                type: 'move',
+                player: playerNumber,
+                move,
+                simple: `${player.name} buys ${move.data.resource} for $${price}.`,
+                pretty: `${playerNameHTML(player)} buys <b>${
+                    move.data.resource
+                }</b> for <span style="color: green">$${price}</span>.`,
+            });
+
+            break;
+        }
+
+        case MoveName.Build: {
+            asserts<Moves.MoveBuild>(move);
+
+            const position = G.players.filter((p) => p.cities.find((c) => c.name == move.data.name)).length;
+            player.cities.push({ name: move.data.name, position });
+            player.money -= move.data.price;
+
+            if (G.options.trackTotalSpent) {
+                player.totalSpentCities += 10 + position * 5;
+                player.totalSpentConnections += move.data.price - (10 + position * 5);
+            }
+
+            G.log.push({
+                type: 'move',
+                player: playerNumber,
+                move,
+                simple: `${player.name} builds on ${move.data.name} for $${move.data.price}.`,
+                pretty: `${playerNameHTML(player)} builds on <b>${move.data.name}</b> for <span style="color: green">$${
+                    move.data.price
+                }</span>.`,
+            });
+
+            if (G.map.name == 'India') {
+                G.citiesBuiltInCurrentRound!++;
+            }
+
+            if (G.options.variant == 'original') {
+                if (
+                    G.actualMarket.length > 0 &&
+                    player.cities.length >= G.actualMarket[0].number &&
+                    G.map.name != 'China' &&
+                    G.map.name != 'Russia'
+                ) {
+                    G.actualMarket.shift();
+                    addPowerPlant(G);
+                }
+            }
+
+            break;
+        }
+
+        case MoveName.UsePowerPlant: {
+            asserts<Moves.MoveUsePowerPlant>(move);
+
+            player.powerPlantsNotUsed = player.powerPlantsNotUsed.filter((x) => x != move.data.powerPlant);
+            move.data.resourcesSpent.forEach((resourceType) => {
+                switch (resourceType) {
+                    case ResourceType.Coal:
+                        player.coalLeft--;
+                        G.coalSupply++;
+                        break;
+
+                    case ResourceType.Oil:
+                        player.oilLeft--;
+                        G.oilSupply++;
+                        break;
+
+                    case ResourceType.Garbage:
+                        player.garbageLeft--;
+                        G.garbageSupply++;
+                        break;
+
+                    case ResourceType.Uranium:
+                        player.uraniumLeft--;
+                        G.uraniumSupply++;
+                        break;
+                }
+            });
+
+            player.citiesPowered += move.data.citiesPowered;
+
+            G.log.push({
+                type: 'move',
+                player: playerNumber,
+                move,
+                simple: `${player.name} uses Power Plant ${move.data.powerPlant}.`,
+                pretty: `${playerNameHTML(player)} uses Power Plant <b>${move.data.powerPlant}</b>.`,
+            });
+
+            break;
+        }
+
+        case MoveName.Undo: {
+            asserts<Moves.MoveUndo>(move);
+
+            const lastMove = player.lastMove;
+            switch (lastMove?.name) {
+                case MoveName.ChoosePowerPlant: {
+                    if (lastMove.data == 39) {
+                        G.card39Bought = false;
+                    }
+
+                    if (lastMove.usedPlantDiscount) {
+                        G.plantDiscountActive = true;
+                    }
+
+                    G.chosenPowerPlant = undefined;
+                    G.auctioningPlayer = undefined;
+
+                    G.currentPlayers = [player.id];
+
+                    G.log.pop();
+
+                    break;
+                }
+
+                case MoveName.BuyResource: {
+                    let price: number;
+                    switch (lastMove.data.resource) {
+                        case ResourceType.Coal:
+                            if (lastMove.fromSupply) {
+                                price = 8;
+                                player.coalLeft--;
+                                G.coalSupply++;
+                            } else {
+                                player.coalLeft--;
+                                G.coalMarket++;
+                                const coalPrices = G.coalPrices ?? prices[ResourceType.Coal];
+                                price = coalPrices[coalPrices.length - G.coalMarket];
+                            }
+
+                            break;
+
+                        case ResourceType.Oil: {
+                            player.oilLeft--;
+                            G.oilMarket++;
+                            const oilPrices = G.oilPrices ?? prices[ResourceType.Oil];
+                            price = oilPrices[oilPrices.length - G.oilMarket];
+                            break;
+                        }
+
+                        case ResourceType.Garbage: {
+                            player.garbageLeft--;
+                            G.garbageMarket++;
+                            const garbagePrices = G.garbagePrices ?? prices[ResourceType.Garbage];
+                            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?.length > 0) {
+                                    price--;
+                                }
+                            }
+
+                            break;
+                        }
+
+                        case ResourceType.Uranium: {
+                            player.uraniumLeft--;
+                            G.uraniumMarket++;
+                            const uraniumPrices = G.uraniumPrices ?? prices[ResourceType.Uranium];
+                            price = uraniumPrices[uraniumPrices.length - G.uraniumMarket];
+                            break;
+                        }
+                    }
+
+                    player.money += price;
+
+                    if (G.options.trackTotalSpent) {
+                        player.totalSpentResources -= price;
+                    }
+
+                    if (G.map.name == 'India') {
+                        G.chosenResource = undefined;
+                    }
+
+                    G.log.pop();
+                    break;
+                }
+
+                case MoveName.Build: {
+                    player.cities.pop();
+                    player.money += lastMove.data.price;
+
+                    const position = G.players.filter((p) => p.cities.find((c) => c.name == lastMove.data.name)).length;
+
+                    if (G.options.trackTotalSpent) {
+                        player.totalSpentCities -= 10 + position * 5;
+                        player.totalSpentConnections -= lastMove.data.price - (10 + position * 5);
+                    }
+
+                    G.log.pop();
+
+                    if (G.map.name == 'India') {
+                        G.citiesBuiltInCurrentRound!--;
+                    }
+
+                    break;
+                }
+
+                case MoveName.UsePowerPlant: {
+                    player.powerPlantsNotUsed.push(lastMove.data.powerPlant);
+                    lastMove.data.resourcesSpent.forEach((resourceType) => {
+                        switch (resourceType) {
+                            case ResourceType.Coal:
+                                player.coalLeft++;
+                                G.coalSupply--;
+                                break;
+
+                            case ResourceType.Oil:
+                                player.oilLeft++;
+                                G.oilSupply--;
+                                break;
+
+                            case ResourceType.Garbage:
+                                player.garbageLeft++;
+                                G.garbageSupply--;
+                                break;
+
+                            case ResourceType.Uranium:
+                                player.uraniumLeft++;
+                                G.uraniumSupply--;
+                                break;
+                        }
+                    });
+
+                    player.citiesPowered -= lastMove.data.citiesPowered;
+
+                    const reverseLog = G.log.slice().reverse();
+                    const index =
+                        G.log.length - reverseLog.findIndex((l) => l.type == 'move' && l.player == player.id) - 1;
+                    G.log.splice(index, 1);
+
+                    break;
+                }
+            }
+        }
+    }
+
+    player.availableMoves = null;
+
+    if (move.name == MoveName.Undo) {
+        const reverseLog = G.log.slice().reverse();
+        const logMove = reverseLog.find((m) => m.type == 'move' && m.player == player.id) as LogMove;
+        player.lastMove = logMove?.move;
+    } else {
+        player.lastMove = move;
+    }
+
+    G.cardsLeft = G.powerPlantsDeck.length;
+    G.nextCardWeak = G.options.variant == 'recharged' && G.cardsLeft > 0 && G.powerPlantsDeck[0].number <= 15;
+
+    G.currentPlayers.forEach((p) => (G.players[p].availableMoves = availableMoves(G, G.players[p])));
+
+    return G;
+}
+
+export function moveAI(G: GameState, playerNumber: number): GameState {
+    const player = G.players[playerNumber];
+    const availableMoves = player.availableMoves;
+    let chosenMove: Move = { name: MoveName.Pass, data: true };
+
+    switch (G.phase) {
+        case Phase.Auction: {
+            if (availableMoves?.ChoosePowerPlant) {
+                if (
+                    !availableMoves.Pass ||
+                    (Math.random() > 0.5 && player.money - availableMoves.ChoosePowerPlant[0] >= 20)
+                ) {
+                    chosenMove = {
+                        name: MoveName.ChoosePowerPlant,
+                        data: chooseRandom(availableMoves.ChoosePowerPlant),
+                    };
+                } else {
+                    chosenMove = { name: MoveName.Pass, data: true };
+                }
+            } else if (availableMoves?.Bid) {
+                if (
+                    !availableMoves.Pass ||
+                    (availableMoves.Bid.length > 0 &&
+                        Math.random() > 0.5 &&
+                        player.money - availableMoves?.Bid[0] >= 15)
+                ) {
+                    if (G.options.fastBid) {
+                        const bid = Math.floor((Math.random() * availableMoves.Bid.length) / 2);
+                        chosenMove = { name: MoveName.Bid, data: availableMoves?.Bid[bid] };
+                    } else {
+                        chosenMove = { name: MoveName.Bid, data: availableMoves?.Bid[0] };
+                    }
+                } else {
+                    chosenMove = { name: MoveName.Pass, data: true };
+                }
+            } else if (availableMoves?.DiscardPowerPlant) {
+                chosenMove = { name: MoveName.DiscardPowerPlant, data: player.powerPlants[0].number };
+            } else if (availableMoves?.DiscardResources) {
+                chosenMove = { name: MoveName.DiscardResources, data: chooseRandom(availableMoves.DiscardResources) };
+            }
+
+            break;
+        }
+
+        case Phase.Resources: {
+            if (availableMoves?.BuyResource && player.money > 20) {
+                const buyCoal = availableMoves.BuyResource.find((r) => r.resource == ResourceType.Coal);
+                const buyOil = availableMoves.BuyResource.find((r) => r.resource == ResourceType.Oil);
+                const buyGarbage = availableMoves.BuyResource.find((r) => r.resource == ResourceType.Garbage);
+                const buyUranium = availableMoves.BuyResource.find((r) => r.resource == ResourceType.Uranium);
+
+                if (buyCoal && player.coalLeft < (player.coalCapacity + player.hybridCapacity) / 2) {
+                    chosenMove = { name: MoveName.BuyResource, data: buyCoal };
+                } else if (buyOil && player.oilLeft < (player.oilCapacity + player.hybridCapacity) / 2) {
+                    chosenMove = { name: MoveName.BuyResource, data: buyOil };
+                } else if (buyGarbage && player.garbageLeft < player.garbageCapacity / 2) {
+                    chosenMove = { name: MoveName.BuyResource, data: buyGarbage };
+                } else if (buyUranium && player.uraniumLeft < player.uraniumCapacity / 2) {
+                    chosenMove = { name: MoveName.BuyResource, data: buyUranium };
+                }
+            }
+
+            break;
+        }
+
+        case Phase.Building: {
+            const capacity = player.powerPlants.map((pp) => pp.citiesPowered).reduce((a, b) => a + b);
+
+            if (availableMoves?.Build && (player.money >= 30 || capacity > player.cities.length)) {
+                const minPrice = availableMoves.Build.sort((a, b) => a.price - b.price)[0].price;
+                const cheapestCities = availableMoves.Build.filter((x) => x.price == minPrice);
+                chosenMove = { name: MoveName.Build, data: chooseRandom(cheapestCities) };
+            }
+
+            break;
+        }
+
+        case Phase.Bureaucracy: {
+            if (availableMoves?.UsePowerPlant && player.cities.length > player.citiesPowered) {
+                chosenMove = {
+                    name: MoveName.UsePowerPlant,
+                    data: availableMoves.UsePowerPlant.sort((a, b) => a.citiesPowered - b.citiesPowered)[0],
+                };
+            }
+
+            break;
+        }
+    }
+
+    console.log('ai move', chosenMove);
+    return move(G, chosenMove, playerNumber);
+}
+
+function chooseRandom(moves: any[]) {
+    return moves[Math.floor(Math.random() * moves.length)];
+}
+
+export function ended(G: GameState): boolean {
+    return G.phase == Phase.GameEnd;
+}
+
+export function scores(G: GameState): number[] {
+    return ended(G) ? G.players.map((p) => p.citiesPowered) : G.players.map((_) => 0);
+}
+
+export function reconstructState(gameState: GameState, to?: number): GameState {
+    const initialState = getBaseState(gameState);
+    const G = cloneDeep(initialState);
+
+    if (to != undefined && gameState.seed == 'secret') {
+        if (gameState.knownPowerPlantDeck) {
+            G.map = gameState.map;
+            G.powerPlantsDeck = cloneDeep(gameState.knownPowerPlantDeck);
+            G.actualMarket = G.powerPlantsDeck.splice(0, 4);
+            G.futureMarket = G.powerPlantsDeck.splice(0, 4);
+            G.players[G.currentPlayers[0]].availableMoves = availableMoves(G, G.players[G.currentPlayers[0]]);
+            G.powerPlantDeckAfterStep3 = gameState.knownPowerPlantDeckStep3;
+            G.knownPowerPlantDeck = G.actualMarket.concat(G.futureMarket);
+        }
+    }
+
+    const log = to != null ? gameState.log.slice(0, to) : gameState.log;
+    for (const item of log) {
+        switch (item.type) {
+            case 'event': {
+                if (item.event.endsWith('was dropped')) {
+                    const playerNum = +item.event.split(' ')[1];
+                    G.players[playerNum].isDropped = true;
+                }
+
+                break;
+            }
+
+            case 'move': {
+                move(G, item.move, item.player, true);
+                break;
+            }
+        }
+    }
+
+    return G;
+}
+
+function updatePlayerCapacity(player: Player) {
+    player.coalCapacity =
+        player.oilCapacity =
+        player.garbageCapacity =
+        player.uraniumCapacity =
+        player.hybridCapacity =
+            0;
+
+    player.powerPlants.forEach((powerPlant) => {
+        switch (powerPlant.type) {
+            case PowerPlantType.Coal: {
+                player.coalCapacity += powerPlant.cost * 2;
+                break;
+            }
+
+            case PowerPlantType.Oil: {
+                player.oilCapacity += powerPlant.cost * 2;
+                break;
+            }
+
+            case PowerPlantType.Garbage: {
+                if (powerPlant.storage) {
+                    // For the India map, garbage plants have cost one higher, but have no additional storage.
+                    player.garbageCapacity += powerPlant.storage;
+                } else {
+                    player.garbageCapacity += powerPlant.cost * 2;
+                }
+
+                break;
+            }
+
+            case PowerPlantType.Uranium: {
+                player.uraniumCapacity += powerPlant.cost * 2;
+                break;
+            }
+
+            case PowerPlantType.Hybrid: {
+                player.hybridCapacity += powerPlant.cost * 2;
+                break;
+            }
+        }
+    });
+}
+
+function addPowerPlant(G: GameState) {
+    let powerPlant = G.powerPlantsDeck.shift();
+
+    if (powerPlant) {
+        if (G.step == 3) {
+            if (G.knownPowerPlantDeckStep3) {
+                G.knownPowerPlantDeckStep3.push(powerPlant);
+            }
+        } else {
+            if (G.knownPowerPlantDeck) {
+                G.knownPowerPlantDeck.push(powerPlant);
+            }
+        }
+
+        if (G.options.variant == 'original' && G.map.name != 'China') {
+            const maxCities = Math.max(...G.players.map((p) => p.cities.length));
+            while (powerPlant.number <= maxCities) {
+                G.log.push({
+                    type: 'event',
+                    event: `Power plant ${powerPlant?.number} discarded.`,
+                });
+
+                if (G.powerPlantsDeck.length > 0) {
+                    powerPlant = G.powerPlantsDeck.shift()!;
+
+                    if (G.step == 3) {
+                        if (G.knownPowerPlantDeckStep3) {
+                            G.knownPowerPlantDeckStep3.push(powerPlant);
+                        }
+                    } else {
+                        if (G.knownPowerPlantDeck) {
+                            G.knownPowerPlantDeck.push(powerPlant);
+                        }
+                    }
+                } else {
+                    break;
+                }
+            }
+        }
+
+        let skipAdd = false;
+        if (powerPlant.number == 99) {
+            if (G.powerPlantDeckAfterStep3) {
+                G.powerPlantsDeck = G.powerPlantDeckAfterStep3;
+            } else if (G.map.name == 'China') {
+                G.step = 3;
+            } else {
+                G.powerPlantsDeck = shuffle(G.powerPlantsDeck, G.seed);
+            }
+
+            if (G.phase != Phase.Auction) {
+                if (G.map.name == 'Middle East' && G.step == 1) {
+                    // Add step 3 card to market, then trigger step 2 process.
+                    const market = [...G.actualMarket, ...G.futureMarket, powerPlant];
+                    market.sort((a, b) => a.number - b.number);
+                    G.actualMarket = market.slice(0, 4);
+                    G.futureMarket = market.slice(4);
+                    enterStepTwoMiddleEast(G);
+                    skipAdd = true;
+                } else {
+                    const powerPlantDiscarded = G.actualMarket.shift();
+                    G.log.push({
+                        type: 'event',
+                        event: `Step 3 will begin next phase, Power Plant ${powerPlantDiscarded?.number} discarded.`,
+                    });
+
+                    const market = [...G.actualMarket, ...G.futureMarket];
+                    market.sort((a, b) => a.number - b.number);
+                    G.actualMarket = market;
+                    G.futureMarket = [];
+                }
+            }
+        } else {
+            if (G.plantDiscountActive && powerPlant.number < G.actualMarket[0].number) {
+                G.log.push({
+                    type: 'event',
+                    event: `Power Plant ${powerPlant.number} drawn from the deck and discarded.`,
+                });
+                G.plantDiscountActive = false;
+                addPowerPlant(G);
+                return;
+            } else {
+                G.log.push({ type: 'event', event: `Power Plant ${powerPlant.number} drawn from the deck.` });
+            }
+        }
+
+        if (G.map.name == 'China' && powerPlant.type != PowerPlantType.Step3) {
+            const market = [...G.actualMarket, powerPlant];
+            market.sort((a, b) => a.number - b.number);
+            G.actualMarket = market;
+        } else {
+            if (!skipAdd) {
+                const market = [...G.actualMarket, ...G.futureMarket, powerPlant];
+                market.sort((a, b) => a.number - b.number);
+                if (G.futureMarket.length == 0) {
+                    if (G.map.name == 'Russia') {
+                        // Only four plants in market.
+                        G.actualMarket = market.slice(0, 4);
+                        G.futureMarket = [];
+                    } else {
+                        G.actualMarket = market.slice(0, 6);
+                        G.futureMarket = [];
+                    }
+                } else {
+                    if (G.map.name == 'Russia') {
+                        // Only 3 plants in actual market and 3 in future market.
+                        G.actualMarket = market.slice(0, 3);
+                        G.futureMarket = market.slice(3);
+                    } else if (G.map.name == 'Benelux' && market[4].type == PowerPlantType.Wind) {
+                        // Add extra ecological plant to actual market.
+                        G.actualMarket = market.slice(0, 5);
+                        G.futureMarket = market.slice(5);
+                    } else {
+                        G.actualMarket = market.slice(0, 4);
+                        G.futureMarket = market.slice(4);
+                    }
+                }
+
+                if (G.map.name == 'Middle East' && G.step == 1) {
+                    removePlantsForMiddleEastStep1(G);
+                }
+            }
+        }
+    }
+}
+
+// During step 1 for the Middle East map, we remove garbage and uranium plants from the actual market.
+// If the number is 6, 11, or 14, the plant is removed from the game. Otherwise, it's put under the deck.
+function removePlantsForMiddleEastStep1(G: GameState) {
+    let plantToRemove: PowerPlant | undefined = G.actualMarket.find(
+        (pp: PowerPlant) => pp.type == PowerPlantType.Garbage || pp.type == PowerPlantType.Uranium
+    );
+
+    while (plantToRemove) {
+        removePowerPlant(G, plantToRemove);
+
+        if ([6, 11, 14].includes(plantToRemove.number)) {
+            G.log.push({
+                type: 'event',
+                event: `Removing Power Plant ${plantToRemove.number} from game.`,
+            });
+        } else {
+            G.powerPlantsDeck.push(plantToRemove);
+            G.log.push({
+                type: 'event',
+                event: `Sending Power Plant ${plantToRemove.number} to the bottom of the deck.`,
+            });
+        }
+
+        // Prevent infinite loop cycling through power plants.
+        const availableFuturePlants = G.futureMarket.filter(
+            (pp) => pp.type != PowerPlantType.Garbage && pp.type != PowerPlantType.Uranium
+        );
+        const nextFuturePlantNumber = availableFuturePlants.length > 0 ? availableFuturePlants[0].number : 100;
+        if (
+            G.powerPlantsDeck.filter(
+                (pp) =>
+                    (pp.type != PowerPlantType.Garbage && pp.type != PowerPlantType.Uranium) ||
+                    pp.number > nextFuturePlantNumber
+            ).length == 0
+        ) {
+            G.log.push({
+                type: 'event',
+                event: 'No suitable power plants available to draw.',
+            });
+            break;
+        }
+
+        addPowerPlant(G);
+        plantToRemove = G.actualMarket.find(
+            (pp: PowerPlant) => pp.type == PowerPlantType.Garbage || pp.type == PowerPlantType.Uranium
+        );
+    }
+}
+
+function enterStepTwoMiddleEast(G: GameState) {
+    // Shuffle deck of remaining power plants and put step 3 card back underneath.
+    const step3 = G.futureMarket.pop()!;
+    G.powerPlantsDeck = shuffle(G.powerPlantsDeck, G.seed);
+    G.powerPlantsDeck.push(step3);
+
+    // Draw new plant to replace step 3 card.
+    addPowerPlant(G);
+
+    // Discard two lowest power plants from current market.
+    G.log.push({
+        type: 'event',
+        event: 'Step 2 will begin next phase, discarding two power plants.',
+    });
+    G.step = 2;
+
+    const powerPlantDiscarded1 = G.actualMarket.shift();
+    if (powerPlantDiscarded1) {
+        G.log.push({
+            type: 'event',
+            event: `Power Plant ${powerPlantDiscarded1.number} discarded to start step 2.`,
+        });
+        addPowerPlant(G);
+    }
+
+    const powerPlantDiscarded2 = G.actualMarket.shift();
+    if (powerPlantDiscarded2) {
+        G.log.push({
+            type: 'event',
+            event: `Power Plant ${powerPlantDiscarded2.number} discarded to start step 2.`,
+        });
+        addPowerPlant(G);
+    }
+}
+
+function rebuildPlantMarketForChina(G: GameState) {
+    /*At the beginning of phase 5, the players fill the power plant market with new power plants. Depending on the
+number of players, the players always add a minimum of 1, 2, or 3 power plants to the market from the supply:
+with 2 and 3 players, add at least 1 power plant.
+with 4 and 5 players, add at least 2 power plants.
+with 6 players, add at least 3 power plants.
+The players add more than the minimum if the number of plants in the market is still more than 1 less than the number of players.
+Exception: with 2 players, add plants until there are 2 in the market.*/
+    let minPlantsToAdd = 0;
+    if (G.players.length == 2 || G.players.length == 3) {
+        minPlantsToAdd = 1;
+    } else if (G.players.length == 4 || G.players.length == 5) {
+        minPlantsToAdd = 2;
+    } else if (G.players.length == 6) {
+        minPlantsToAdd = 3;
+    }
+
+    const currentActualSize = G.actualMarket.length;
+    const minSize = G.players.length - 1;
+    const numPlantsToAdd = Math.max(minPlantsToAdd, minSize - currentActualSize);
+    for (let i = 0; i < numPlantsToAdd; i++) {
+        if (G.step == 3) {
+            break;
+        } else {
+            addPowerPlant(G);
+        }
+    }
+
+    // Special rule to move the market for two players
+    while (G.players.length == 2 && G.actualMarket.length < 2 && G.step != 3) {
+        addPowerPlant(G);
+    }
+
+    if (G.step == 3) {
+        G.actualMarket = G.actualMarket.filter((pp) => pp.type != PowerPlantType.Step3);
+        while (G.actualMarket.length < 4 && G.powerPlantsDeck.length > 0) {
+            addPowerPlant(G);
+        }
+    } else {
+        // Target size is one less than number of players, or 2 for a 2-player game.
+        const targetSize = Math.max(2, G.players.length - 1);
+        while (G.actualMarket.length > targetSize) {
+            G.actualMarket.shift();
+        }
+    }
+}
+
+function removePowerPlant(G: GameState, powerPlant: PowerPlant) {
+    G.actualMarket.splice(
+        G.actualMarket.findIndex((pp) => pp.number == powerPlant.number),
+        1
+    );
+}
+
+export function getPowerPlant(num: number, mapName = ''): PowerPlant {
+    if (mapName == 'India') {
+        return indiaPowerPlants.find((p) => p.number == num)!;
+    } else {
+        return powerPlants.find((p) => p.number == num)!;
+    }
+}
+
+function getBaseState(G: GameState): GameState {
+    const baseState = setup(G.players.length, G.options, G.seed);
+    baseState.players.forEach((player, i) => {
+        player.name = G.players[i].name;
+        player.isAI = G.players[i].isAI;
+    });
+
+    return baseState;
+}
+
+function playerNameHTML(player) {
+    return `<span style="background-color: ${playerColors[player.id]}; font-weight: bold; padding: 0 3px;">${
+        player.name
+    }</span>`;
+}
+
+export function playersSortedByScore(G: GameState): Player[] {
+    return cloneDeep(G.players)
+        .sort((p1, p2) => {
+            if (p1.citiesPowered == p2.citiesPowered) {
+                if (p1.money == p2.money) {
+                    return p1.cities.length - p2.cities.length;
+                }
+
+                return p1.money - p2.money;
+            }
+
+            return p1.citiesPowered - p2.citiesPowered;
+        })
+        .reverse();
+}
+
+function calculateCitiesPowered(G: GameState) {
+    G.players.forEach((player) => {
+        player.citiesPowered = calculateMaxCitiesPowered(player);
+    });
+}
+
+function calculateMaxCitiesPowered(player: Player) {
+    const permutations: PowerPlant[][] = [];
+    for (let i = 0; i < Math.pow(2, player.powerPlants.length); i++) {
+        const perm: PowerPlant[] = [];
+        player.powerPlants.forEach((pp, index) => {
+            if (i & Math.pow(2, index)) {
+                perm.push(pp);
+            }
+        });
+        permutations.push(perm);
+    }
+
+    let max = 0;
+    permutations.forEach((permutation) => {
+        if (isValid(player, permutation)) {
+            const citiesPowered = permutation.map((p) => p.citiesPowered).reduce((a, b) => a + b, 0);
+            max = Math.max(max, citiesPowered);
+        }
+    });
+
+    return Math.min(player.cities.length, max);
+}
+
+function isValid(player: Player, powerPlants: PowerPlant[]) {
+    const coalUsed = powerPlants
+        .filter((pp) => pp.type == PowerPlantType.Coal)
+        .map((pp) => pp.cost)
+        .reduce((a, b) => a + b, 0);
+    const oilUsed = powerPlants
+        .filter((pp) => pp.type == PowerPlantType.Oil)
+        .map((pp) => pp.cost)
+        .reduce((a, b) => a + b, 0);
+    const garbageUsed = powerPlants
+        .filter((pp) => pp.type == PowerPlantType.Garbage)
+        .map((pp) => pp.cost)
+        .reduce((a, b) => a + b, 0);
+    const uraniumUsed = powerPlants
+        .filter((pp) => pp.type == PowerPlantType.Uranium)
+        .map((pp) => pp.cost)
+        .reduce((a, b) => a + b, 0);
+    const hybridUsed = powerPlants
+        .filter((pp) => pp.type == PowerPlantType.Hybrid)
+        .map((pp) => pp.cost)
+        .reduce((a, b) => a + b, 0);
+
+    if (
+        coalUsed > player.coalLeft ||
+        oilUsed > player.oilLeft ||
+        garbageUsed > player.garbageLeft ||
+        uraniumUsed > player.uraniumLeft
+    ) {
+        return false;
+    }
+
+    if (hybridUsed > player.coalLeft - coalUsed + player.oilLeft - oilUsed) {
+        return false;
+    }
+
+    return true;
+}
+
+function toResourcesPhase(G: GameState) {
+    G.players.forEach((p) => {
+        p.bid = 0;
+        p.passed = p.isDropped;
+    });
+
+    G.players.forEach((p) => {
+        p.skipAuction = false;
+    });
+
+    if (G.options.variant == 'recharged') {
+        if (G.plantDiscountActive) {
+            G.plantDiscountActive = false;
+            if (G.actualMarket.length > 0) {
+                G.log.push({ type: 'event', event: `Discarding Power Plant ${G.actualMarket[0].number}.` });
+                G.actualMarket.shift();
+                addPowerPlant(G);
+            }
+        } else if (G.map.name == 'Benelux') {
+            G.discardSmallestPlant = true;
+        }
+    }
+
+    if (G.futureMarket.find((pp) => pp.number == 99)) {
+        if (G.map.name == 'Middle East' && G.step == 1) {
+            enterStepTwoMiddleEast(G);
+        } else {
+            const powerPlantDiscarded = G.actualMarket.shift();
+            G.futureMarket.pop();
+            G.log.push({
+                type: 'event',
+                event: `Starting Step 3, Power Plant ${powerPlantDiscarded?.number} discarded.`,
+            });
+            G.step = 3;
+
+            G.actualMarket = [...G.actualMarket, ...G.futureMarket];
+            G.futureMarket = [];
+        }
+    }
+
+    G.phase = Phase.Resources;
+    setCurrentPlayer(G, G.playerOrder[G.players.length - 1]);
+}
+
+function endAuction(G: GameState, winningPlayer: Player, bid: number) {
+    winningPlayer.powerPlants.push(G.chosenPowerPlant!);
+    winningPlayer.money -= bid;
+
+    if (G.options.trackTotalSpent) {
+        winningPlayer.totalSpentPlants += bid;
+    }
+
+    winningPlayer.skipAuction = true;
+    updatePlayerCapacity(winningPlayer);
+
+    G.log.push({
+        type: 'event',
+        event: `${winningPlayer.name} wins the bid and pays ${bid}.`,
+        pretty: `${playerNameHTML(winningPlayer)} wins the bid and pays <span style="color: green">$${bid}</span>.`,
+    });
+
+    removePowerPlant(G, G.chosenPowerPlant!);
+    G.chosenPowerPlant = G.currentBid = undefined;
+}
+
+function setPlayerOrder(G: GameState) {
+    G.playerOrder = cloneDeep(G.players)
+        .sort((a, b) => {
+            const citiesA = a.cities.length;
+            const citiesB = b.cities.length;
+
+            if (citiesA == citiesB) {
+                return (
+                    Math.max(...a.powerPlants.map((pp) => pp.number)) -
+                    Math.max(...b.powerPlants.map((pp) => pp.number))
+                );
+            }
+
+            return citiesA - citiesB;
+        })
+        .map((p) => p.id)
+        .reverse();
+}
+
+function setCurrentPlayer(G: GameState, playerNum: number) {
+    G.currentPlayers = [playerNum];
+
+    if (G.players[playerNum].isDropped && G.players.some((p) => !p.isDropped)) {
+        G.players[playerNum].passed = true;
+        nextPlayer(G);
+    }
+}
+
+function nextPlayer(G: GameState) {
+    if (G.phase == Phase.Auction) {
+        if (G.chosenPowerPlant == undefined) {
+            nextPlayerAuction(G);
+        } else {
+            nextPlayerClockwise(G);
+        }
+    } else {
+        nextPlayerReverse(G);
+    }
+}
+
+function nextPlayerClockwise(G: GameState) {
+    const index = G.currentPlayers[0];
+    G.currentPlayers = [(index + 1) % G.players.length];
+
+    if (G.players[G.currentPlayers[0]].isDropped && G.players.some((p) => !p.isDropped)) {
+        G.players[G.currentPlayers[0]].passed = true;
+        G.players[G.currentPlayers[0]].skipAuction = true;
+        nextPlayerClockwise(G);
+    }
+
+    if (
+        (G.players[G.currentPlayers[0]].skipAuction || G.players[G.currentPlayers[0]].passed) &&
+        G.players.some((p) => !p.skipAuction && !p.passed && !p.isDropped)
+    ) {
+        nextPlayerClockwise(G);
+    }
+}
+
+function nextPlayerReverse(G: GameState) {
+    const index = G.playerOrder.indexOf(G.currentPlayers[0]);
+    G.currentPlayers = [G.playerOrder[(index - 1 + G.players.length) % G.players.length]];
+
+    if (G.players[G.currentPlayers[0]].isDropped && G.players.some((p) => !p.isDropped)) {
+        G.players[G.currentPlayers[0]].passed = true;
+        nextPlayerReverse(G);
+    }
+}
+
+function nextPlayerAuction(G: GameState, reset = false) {
+    let playerNum: number;
+    if (reset) {
+        playerNum = G.playerOrder[0];
+    } else {
+        const index = G.playerOrder.indexOf(G.currentPlayers[0]);
+        playerNum = G.playerOrder[(index + 1) % G.players.length];
+    }
+
+    G.currentPlayers = [playerNum];
+    const player = G.players[playerNum];
+
+    if (player.isDropped) {
+        player.passed = true;
+        player.skipAuction = true;
+    }
+
+    if ((player.skipAuction || player.passed) && G.players.some((p) => !p.skipAuction && !p.passed && !p.isDropped)) {
+        nextPlayerAuction(G);
+    }
+}
+
+function updateGameState(G: GameState) {
+    if (!G.coalResupply) {
+        const map = maps.find((map) => map.name === G.map.name);
+
+        if (map?.resupply) {
+            G.coalResupply = map.resupply[0];
+            G.oilResupply = map.resupply[1];
+            G.garbageResupply = map.resupply[2];
+            G.uraniumResupply = map.resupply[3];
+        } else {
+            G.coalResupply = [
+                [3, 4, 3],
+                [4, 5, 3],
+                [5, 6, 4],
+                [5, 7, 5],
+                [7, 9, 6],
+            ];
+            G.oilResupply = [
+                [2, 2, 4],
+                [2, 3, 4],
+                [3, 4, 5],
+                [4, 5, 6],
+                [5, 6, 7],
+            ];
+            G.garbageResupply = [
+                [1, 2, 3],
+                [1, 2, 3],
+                [2, 3, 4],
+                [3, 3, 5],
+                [3, 5, 6],
+            ];
+            G.uraniumResupply = [
+                [1, 1, 1],
+                [1, 1, 1],
+                [1, 2, 2],
+                [2, 3, 2],
+                [2, 3, 3],
+            ];
+        }
+
+        const p = G.players.length - 2;
+        G.resourceResupply = [
+            `[${G.coalResupply[p][0]}, ${G.oilResupply[p][0]}, ${G.garbageResupply[p][0]}, ${G.uraniumResupply[p][0]}]`,
+            `[${G.coalResupply[p][1]}, ${G.oilResupply[p][1]}, ${G.garbageResupply[p][1]}, ${G.uraniumResupply[p][1]}]`,
+            `[${G.coalResupply[p][2]}, ${G.oilResupply[p][2]}, ${G.garbageResupply[p][2]}, ${G.uraniumResupply[p][2]}]`,
+        ];
+    }
+}
+
+function fastAuction(G: GameState, player: Player, bid: number) {
+    player.bid = bid;
+    G.currentPlayers = G.currentPlayers.filter((id) => id !== player.id);
+
+    if (G.currentPlayers.length === 0) {
+        G.log.push(...G.hiddenLog);
+        G.hiddenLog = [];
+
+        const bids = G.players.map((p) => p.bid).filter((b) => b > 0);
+        let cost = G.minimunBid;
+        const highestBid = Math.max(...bids);
+        const highestBidders = G.players.filter((p) => !p.isDropped && p.bid === highestBid);
+        let winnerId = highestBidders[0].id;
+
+        if (bids.length > 1) {
+            bids.splice(bids.indexOf(highestBid), 1);
+            const secondHighestBid = Math.max(...bids);
+
+            // In case of a tie, use turn order
+            if (highestBidders.length > 1) {
+                let index = G.auctioningPlayer!;
+
+                while (!highestBidders.find((p) => p.id == index)) {
+                    index = (index + 1) % G.players.length;
+                }
+
+                cost = secondHighestBid;
+                winnerId = index;
+            } else {
+                let index = G.auctioningPlayer!;
+
+                cost = 0;
+                while (cost == 0) {
+                    if (highestBidders[0].id == index) {
+                        cost = secondHighestBid;
+                    } else if (G.players[index].bid == secondHighestBid) {
+                        cost = secondHighestBid + 1;
+                    }
+
+                    index = (index + 1) % G.players.length;
+                }
+            }
+        }
+
+        const winningPlayer = G.players[winnerId];
+
+        endAuction(G, winningPlayer, cost);
+
+        if (
+            (winningPlayer.powerPlants.length > 4 || (G.players.length > 2 && winningPlayer.powerPlants.length > 3)) &&
+            !winningPlayer.isDropped
+        ) {
+            setCurrentPlayer(G, winningPlayer.id);
+        } else {
+            if (G.map.name != 'China' || G.step == 3) {
+                addPowerPlant(G);
+            }
+
+            if (G.players.some((p) => !p.skipAuction && !p.isDropped)) {
+                G.players.forEach((p) => {
+                    p.bid = 0;
+                    p.passed = p.isDropped;
+                });
+
+                nextPlayerAuction(G, true);
+            } else {
+                toResourcesPhase(G);
+            }
+        }
+    }
+}