.prettierignore

@@ -1,2 +1,3 @@
 pnpm-lock.yaml
-dist
+dist
+replay

batch/package.json

@@ -10,6 +10,7 @@
   "scripts": {
     "build": "tsc -p .",
     "stats": "ts-node src/stats.ts",
+    "stats-replay-errors": "ts-node src/stats.ts replay-errors",
     "replay": "ts-node src/replay.ts"
   },
   "dependencies": {

batch/src/stats.ts

@@ -10,6 +10,8 @@ import { Game, GameDocument, PlayerInfo } from "./game";
 import { connectMongo, shouldReplay } from "./util";
 import { ChartSetup } from "../../viewer/src/logic/charts/chart-factory";
 
+const errorDir = "error/";
+
 function getDetailStats(commonProps: any, data: Engine, pl: Player) {
   const newDetailRow = (round: any) => {
     const d = {
@@ -54,12 +56,18 @@ function getGameStats(pl: Player, outerPlayer: PlayerInfo<any>, data: Engine, ga
   const rank = sortBy(data.players, (p: Player) => -p.data.victoryPoints);
   const rankWithoutBid = sortBy(data.players, (p: Player) => -(p.data.victoryPoints + (p.data.bid ?? 0))); // bid is positive
 
+  const date = game.createdAt;
+
+  function toIso(date: any) {
+    return typeof date == "string" ? date : date?.toISOString();
+  }
+
   const row = {
     initialTurnOrder: pl.player + 1,
     version: data.version ?? "1.0.0",
     players: data.players.length,
-    started: game.createdAt?.toISOString(),
-    ended: game.lastMove?.toISOString(),
+    started: toIso(game.createdAt),
+    ended: toIso(game.lastMove),
     variant: data.options.factionVariant,
     auction: data.options.auction,
     layout: data.options.layout,
@@ -143,7 +151,13 @@ function getStats(game: GameDocument, data: Engine): { game: any[]; detail: any[
     });
 }
 
-async function main() {
+function readJson(file: string) {
+  return JSON.parse(fs.readFileSync(file, { encoding: "utf8" }));
+}
+
+async function main(args: string[]) {
+  const replayErrors = args.length > 0 && args[0] == "replay-errors";
+
   let success = 0;
   let errors = 0;
   let skipReplay = 0;
@@ -190,7 +204,7 @@ async function main() {
     if (shouldReplay(game)) {
       const file = `replay/${game._id}.json`;
       if (fs.existsSync(file)) {
-        data = Engine.fromData(JSON.parse(fs.readFileSync(file, { encoding: "utf8" })));
+        data = Engine.fromData(readJson(file));
       } else {
         skipReplay++;
         return;
@@ -202,13 +216,16 @@ async function main() {
     const stats = getStats(game, data);
 
     if (gameWriter == null) {
+      const append = replayErrors
       gameWriter = createObjectCsvWriter({
         path: "gaia-stats-game.csv",
         header: Object.keys(stats.game[0]).map((k) => ({ id: k, title: k })),
+        append,
       });
       detailWriter = createObjectCsvWriter({
         path: "gaia-stats-turns.csv",
         header: Object.keys(stats.detail[0]).map((k) => ({ id: k, title: k })),
+        append,
       });
     }
 
@@ -217,24 +234,30 @@ async function main() {
     success++;
   }
 
-  connectMongo();
-
-  for await (const game of Game.find().where("game.name").equals("gaia-project")) {
-    try {
-      await process(game);
-    } catch (e) {
-      console.log(game._id);
-      console.log(e);
-      fs.writeFileSync("error/" + game._id, JSON.stringify(game.toJSON()), { encoding: "utf8" });
-      errors++;
+  if (replayErrors) {
+    for (const file of fs.readdirSync(errorDir)) {
+      console.log(file);
+      await process(readJson(errorDir + file));
+    }
+  } else {
+    connectMongo();
+    for await (const game of Game.find().where("game.name").equals("gaia-project")) {
+      try {
+        await process(game);
+      } catch (e) {
+        console.log(game._id);
+        console.log(e);
+        fs.writeFileSync(errorDir + game._id + ".json", JSON.stringify(game.toJSON()), { encoding: "utf8" });
+        errors++;
+      }
     }
   }
 
   console.log(outcomes());
 }
 
 const start = new Date();
-main().then(() => {
+main(process.argv.slice(2)).then(() => {
   console.log("done");
   console.log(new Date().getTime() - start.getTime());
   process.exit(0);

engine/index.ts

@@ -5,7 +5,7 @@ import Engine from "./src/engine";
 import Event, { EventSource } from "./src/events";
 import SpaceMap, { parseLocation } from "./src/map";
 import Player, { BuildWarning, MAX_SATELLITES } from "./src/player";
-import PlayerData, { Power } from "./src/player-data";
+import PlayerData, { BrainstoneDest, MaxLeech, Power } from "./src/player-data";
 import researchTracks from "./src/research-tracks";
 import Reward from "./src/reward";
 import tiles from "./src/tiles";
@@ -65,11 +65,15 @@ export {
 } from "./src/enums";
 export { FactionBoard, factionBoard, factionVariantBoard } from "./src/faction-boards";
 export { factionPlanet } from "./src/factions";
+export { federationCost, parseFederationLocation } from "./src/federation";
 export { GaiaHex, GaiaHexData } from "./src/gaia-hex";
 export { applyChargePowers } from "./src/income";
 export { planetNames, terraformingStepsRequired } from "./src/planets";
+export { AvailableSetupOption, SetupType } from "./src/setup";
 export { finalScorings, roundScorings } from "./src/tiles/scoring";
 export {
+  BrainstoneDest,
+  MaxLeech,
   BuildWarning,
   Player,
   PlayerData,

engine/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gaia-project/engine",
-  "version": "4.8.18",
+  "version": "4.8.21",
   "description": "Javascript engine for project gaia",
   "main": "dist/index.js",
   "types": "index.ts",

engine/src/available-command.ts

@@ -38,6 +38,7 @@ import PlayerObject, { BuildCheck, BuildWarning } from "./player";
 import PlayerData, { BrainstoneDest, resourceLimits } from "./player-data";
 import * as researchTracks from "./research-tracks";
 import Reward from "./reward";
+import { AvailableSetupOption, possibleSetupBoardActions } from "./setup";
 import { isAdvanced } from "./tiles/techs";
 
 const ISOLATED_DISTANCE = 3;
@@ -141,6 +142,7 @@ interface CommandData {
   [Command.PISwap]: AvailableBuildCommandData;
   [Command.PlaceLostPlanet]: { spaces: AvailableHex[] };
   [Command.RotateSectors]: never;
+  [Command.Setup]: AvailableSetupOption;
   [Command.Special]: { specialacts: { income: string; spec: string }[] };
   [Command.Spend]: AvailableFreeActionData;
   [Command.UpgradeResearch]: AvailableResearchData;
@@ -223,7 +225,7 @@ export function generate(engine: Engine, subPhase: SubPhase = null, data?: any):
     case Phase.SetupInit:
       return [{ name: Command.Init } as AvailableCommand]; //doesn't have player
     case Phase.SetupBoard:
-      return [{ name: Command.RotateSectors, player }];
+      return possibleSetupBoardActions(engine, player);
     case Phase.SetupFaction:
       return chooseFactionOrBid(engine, player);
     case Phase.SetupAuction:

engine/src/engine.ts

@@ -40,11 +40,20 @@ import {
 import Event, { EventSource } from "./events";
 import { factionVariantBoard, latestVariantVersion } from "./faction-boards";
 import { remainingFactions } from "./factions";
+import { GaiaHex } from "./gaia-hex";
 import SpaceMap, { MapConfiguration } from "./map";
 import Player from "./player";
 import PlayerData, { BrainstoneDest, MoveTokens, powerLogString } from "./player-data";
 import * as researchTracks from "./research-tracks";
 import Reward from "./reward";
+import {
+  applySetupOption,
+  initCustomSetup,
+  possibleSetupBoardActions,
+  SetupOption,
+  SetupPosition,
+  SetupType,
+} from "./setup";
 import federations from "./tiles/federations";
 import { roundScorings } from "./tiles/scoring";
 import { isAdvanced } from "./tiles/techs";
@@ -76,6 +85,8 @@ export type Layout = "standard" | "balanced" | "xshape";
 export interface EngineOptions {
   /** Allow last player to rotate sector BEFORE faction selection */
   advancedRules?: boolean;
+  /** Allow last player the entire board */
+  customBoardSetup?: boolean;
   /** disable Federation check for available commands */
   noFedCheck?: boolean;
   /** Custom map given */
@@ -395,7 +406,7 @@ export default class Engine {
       }
     } else {
       // Add new entry
-      this.advancedLog.push({
+      this.addAdvancedLog({
         player,
         move,
         changes: amount
@@ -407,6 +418,10 @@ export default class Engine {
     }
   }
 
+  protected addAdvancedLog(entry: LogEntry) {
+    this.advancedLog.push(entry);
+  }
+
   generateAvailableCommandsIfNeeded(subphase: SubPhase = null, data?: any): AvailableCommand[] {
     return this.availableCommands || this.generateAvailableCommands(subphase, data);
   }
@@ -1091,13 +1106,17 @@ export default class Engine {
 
   beginSetupBoardPhase() {
     this.changePhase(Phase.SetupBoard);
-    // The last player is the one to rotate the sectors
-    this.currentPlayer = this.players.slice(-1).pop().player;
 
-    if (!this.options.advancedRules) {
-      // No sector rotation
+    if (this.options.customBoardSetup) {
+      initCustomSetup(this);
+
+      // The first player (host) does board setup and rotation
+      this.currentPlayer = this.players[0].player;
+    } else if (this.options.advancedRules) {
+      // The last player is the one to rotate the sectors
+      this.currentPlayer = this.players.slice(-1).pop().player;
+    } else {
       this.beginSetupFactionPhase();
-      return;
     }
   }
 
@@ -1162,7 +1181,7 @@ export default class Engine {
 
   beginRoundStartPhase() {
     this.round += 1;
-    this.advancedLog.push({ round: this.round });
+    this.addAdvancedLog({ round: this.round });
     this.turnOrder = this.passedPlayers || this.turnOrderAfterSetupAuction;
     this.passedPlayers = [];
     this.currentPlayer = this.turnOrder[0];
@@ -1176,7 +1195,7 @@ export default class Engine {
 
   beginIncomePhase() {
     this.changePhase(Phase.RoundIncome);
-    this.advancedLog.push({ phase: Phase.RoundIncome });
+    this.addAdvancedLog({ phase: Phase.RoundIncome });
     this.tempTurnOrder = [...this.turnOrder];
 
     this.moveToNextPlayer(this.tempTurnOrder, { loop: false });
@@ -1194,7 +1213,7 @@ export default class Engine {
 
   beginGaiaPhase() {
     this.changePhase(Phase.RoundGaia);
-    this.advancedLog.push({ phase: Phase.RoundGaia });
+    this.addAdvancedLog({ phase: Phase.RoundGaia });
     this.tempTurnOrder = [...this.turnOrder];
 
     // transform Transdim planets into Gaia if gaiaformed
@@ -1258,7 +1277,7 @@ export default class Engine {
 
   finalScoringPhase() {
     this.changePhase(Phase.EndGame);
-    this.advancedLog.push({ phase: Phase.EndGame });
+    this.addAdvancedLog({ phase: Phase.EndGame });
     this.currentPlayer = this.tempCurrentPlayer = undefined;
     const allRankings = finalRankings(this.tiles.scorings.final, this.players);
 
@@ -1298,15 +1317,8 @@ export default class Engine {
         pl.data.leechPossible = 0;
         continue;
       }
-
-      // Exclude the one who made the building from the leech
-      let leech = 0;
-      for (const hex of this.map.withinDistance(sourceHex, LEECHING_DISTANCE)) {
-        leech = Math.max(leech, pl.buildingValue(this.map.grid.get(hex)));
-      }
-
-      // Do not use maxLeech() here, cuz taklons
-      pl.data.leechPossible = leech;
+      // Do not use PlayerData.maxLeech() here, cuz taklons
+      pl.data.leechPossible = this.leechPossible(sourceHex, (hex) => pl.buildingValue(this.map.grid.get(hex)));
       if (pl.canLeech()) {
         canLeechPlayers.push(pl);
       }
@@ -1321,6 +1333,14 @@ export default class Engine {
     }
   }
 
+  leechPossible(sourceHex: GaiaHex, buildingValue: (GaiaHex) => number) {
+    let leech = 0;
+    for (const hex of this.map.withinDistance(sourceHex, LEECHING_DISTANCE)) {
+      leech = Math.max(leech, buildingValue(hex));
+    }
+    return leech;
+  }
+
   advanceResearchAreaPhase(player: PlayerEnum, cost: string, field: ResearchField) {
     const pl = this.player(player);
 
@@ -1371,7 +1391,9 @@ export default class Engine {
   [Phase.SetupBoard](move: string) {
     this.loadTurnMoves(move, { split: false, processFirst: true });
 
-    this.beginSetupFactionPhase();
+    if (possibleSetupBoardActions(this, this.currentPlayer).length === 0 || move.includes(Command.RotateSectors)) {
+      this.beginSetupFactionPhase();
+    }
   }
 
   [Phase.SetupFaction](move: string) {
@@ -1569,6 +1591,10 @@ export default class Engine {
     }
   }
 
+  [Command.Setup](player: PlayerEnum, type: SetupType, position: SetupPosition, _to: "to", option: SetupOption) {
+    applySetupOption(this, type, position, option);
+  }
+
   [Command.RotateSectors](player: PlayerEnum, ...params: string[]) {
     assert(params.length % 2 === 0, "The rotate command needs an even number of parameters");
 

engine/src/enums.ts

@@ -188,6 +188,7 @@ export enum Command {
   PlaceLostPlanet = "lostPlanet",
   RotateSectors = "rotate",
   Special = "special",
+  Setup = "set",
   Spend = "spend",
   UpgradeResearch = "up",
 }

engine/src/federation.ts

@@ -1,5 +1,8 @@
-import { difference } from "lodash";
+import assert from "assert";
+import { difference, uniq } from "lodash";
+import { Faction } from "./enums";
 import { GaiaHex } from "./gaia-hex";
+import SpaceMap from "./map";
 
 export interface FederationInfo {
   hexes: GaiaHex[];
@@ -56,3 +59,26 @@ export function isOutclassedBy(fed: FederationInfo, comparison: FederationInfo)
   // Not outclassed
   return false;
 }
+
+export function federationCost(faction: Faction, hasPlanetaryInstitute: boolean, federationCount: number) {
+  if (faction === Faction.Xenos && hasPlanetaryInstitute) {
+    return 6;
+  }
+  if (faction === Faction.Ivits) {
+    return 7 * (1 + federationCount);
+  }
+  return 7;
+}
+
+export function parseFederationLocation(location: string, map: SpaceMap) {
+  const coords = location.split(",").map((loc) => map.parse(loc));
+
+  for (const coord of coords) {
+    assert(map.grid.get(coord), `Coord ${coord.q}x${coord.r} is not part of the map`);
+  }
+
+  const hexes: GaiaHex[] = uniq(coords.map((coord) => map.grid.get(coord)));
+
+  assert(hexes.length === coords.length, "There are repeating coordinates in the given federation");
+  return hexes;
+}