powergrid-engine 1.9.7

package/src/available-moves.ts

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

package/src/engine.spec.ts

@@ -0,0 +1,163 @@
+import { expect } from 'chai';
+import 'mocha';
+import { ended, move, reconstructState, setup } from './engine';
+import GermanyRecharged from './fixtures/GermanyRecharged.json';
+import supply from './fixtures/supply.json';
+import undo from './fixtures/undo.json';
+import USAOriginal from './fixtures/USAOriginal.json';
+import { GameOptions, MapName, Variant } from './gamestate';
+import { Move } from './move';
+
+describe('Engine', () => {
+    it('should setup a game correctly', () => {
+        const G = setup(5, { fastBid: false }, 'test');
+
+        expect(ended(G)).to.false;
+    });
+
+    it('should play full game Germany recharged', () => {
+        const game = GermanyRecharged;
+        const options: GameOptions = {
+            fastBid: game.options.fastBid,
+            map: game.options.map as MapName,
+            showMoney: game.options.showMoney,
+            variant: game.options.variant as Variant,
+            useNewRechargedSetup: game.options.useNewRechargedSetup,
+        };
+
+        expect(options.useNewRechargedSetup).to.be.false;
+
+        let G = setup(game.players.length, options, game.seed);
+
+        for (const item of game.log) {
+            if (item.type === 'move') {
+                G = move(G, item.move! as Move, item.player!);
+            }
+        }
+
+        expect(G.currentPlayers).to.deep.equal([]);
+        expect(ended(G)).to.be.true;
+    });
+
+    it('should replay game Germany recharged', () => {
+        const game = GermanyRecharged;
+
+        expect(game.options.useNewRechargedSetup).to.be.false;
+
+        const G = reconstructState(game as any, game.log.length - 1);
+
+        expect(ended(G)).to.be.true;
+    });
+
+    it('should replay game without seed Germany recharged', () => {
+        const game = GermanyRecharged;
+        const options: GameOptions = {
+            fastBid: game.options.fastBid,
+            map: game.options.map as MapName,
+            showMoney: game.options.showMoney,
+            variant: game.options.variant as Variant,
+            useNewRechargedSetup: game.options.useNewRechargedSetup,
+        };
+
+        expect(options.useNewRechargedSetup).to.be.false;
+
+        let G = setup(game.players.length, options, game.seed);
+
+        for (const item of game.log) {
+            if (item.type === 'move') {
+                G = move(G, item.move! as Move, item.player!);
+            }
+        }
+
+        expect(G.currentPlayers).to.deep.equal([]);
+        expect(ended(G)).to.be.true;
+
+        G.seed = 'secret';
+        G = reconstructState(G, G.log.length - 2);
+
+        expect(ended(G)).to.be.false;
+    });
+
+    it('should play full game USA original', () => {
+        const game = USAOriginal;
+        const options: GameOptions = {
+            fastBid: game.options.fastBid,
+            map: game.options.map as MapName,
+            showMoney: game.options.showMoney,
+            variant: game.options.variant as Variant,
+        };
+
+        let G = setup(game.players.length, options, game.seed);
+
+        for (const item of game.log) {
+            if (item.type === 'move') {
+                G = move(G, item.move! as Move, item.player!);
+            }
+        }
+
+        expect(G.currentPlayers).to.deep.equal([]);
+        expect(ended(G)).to.be.true;
+    });
+
+    it('should replay game USA original', () => {
+        const game = USAOriginal;
+
+        const G = reconstructState(game as any, game.log.length - 1);
+
+        expect(ended(G)).to.be.true;
+    });
+
+    it('should replay game without seed USA original', () => {
+        const game = USAOriginal;
+        const options: GameOptions = {
+            fastBid: game.options.fastBid,
+            map: game.options.map as MapName,
+            showMoney: game.options.showMoney,
+            variant: game.options.variant as Variant,
+        };
+
+        let G = setup(game.players.length, options, game.seed);
+
+        for (const item of game.log) {
+            if (item.type === 'move') {
+                G = move(G, item.move! as Move, item.player!);
+            }
+        }
+
+        expect(G.currentPlayers).to.deep.equal([]);
+        expect(ended(G)).to.be.true;
+
+        G.seed = 'secret';
+        G = reconstructState(G, G.log.length - 2);
+
+        expect(ended(G)).to.be.false;
+    });
+
+    it('should replay game supply', () => {
+        const game = supply;
+
+        const G = reconstructState(game as any, game.log.length - 1);
+
+        expect(ended(G)).to.be.false;
+    });
+
+    it('should allow invalid move when isUndo is true', () => {
+        const game = undo;
+        const options: GameOptions = {
+            fastBid: game.options.fastBid,
+            map: game.options.map as MapName,
+            showMoney: game.options.showMoney,
+            variant: game.options.variant as Variant,
+        };
+
+        let G = setup(game.players.length, options, game.seed, game.knownPowerPlantDeck, game.map);
+
+        for (const item of game.log) {
+            if (item.type === 'move') {
+                G = move(G, item.move! as Move, item.player!, true);
+            }
+        }
+
+        expect(ended(G)).to.be.false;
+    });
+});