✨ (viewer) make replay more permissive

Author: zeitlinger

engine/src/available-command.spec.ts

@@ -98,7 +98,7 @@ describe("Available commands", () => {
       const player = { data: d } as Player;
 
       function possible() {
-        return possibleBoardActions(actions, player)[0].data.poweracts.map((a) => a.name);
+        return possibleBoardActions(actions, player, false)[0].data.poweracts.map((a) => a.name);
       }
 
       expect(possible()).to.include("power1");

engine/src/available-command.ts

@@ -205,7 +205,7 @@ export function generate(engine: Engine, subPhase: SubPhase = null, data?: any):
         ...possibleBuildings(engine, player),
         ...possibleFederations(engine, player),
         ...possibleResearchAreas(engine, player, UPGRADE_RESEARCH_COST),
-        ...possibleBoardActions(engine.boardActions, engine.player(player)),
+        ...possibleBoardActions(engine.boardActions, engine.player(player), engine.replay),
         ...possibleSpecialActions(engine, player),
         ...possibleFreeActions(engine.player(player)),
         ...possibleRoundBoosters(engine, player),
@@ -278,14 +278,15 @@ function addPossibleNewPlanet(
   planet: Planet,
   building: Building,
   buildings: AvailableBuilding[],
-  lastRound: boolean
+  lastRound: boolean,
+  replay: boolean
 ) {
-  const qicNeeded = qicForDistance(map, hex, pl);
+  const qicNeeded = qicForDistance(map, hex, pl, replay);
   if (qicNeeded === null) {
     return;
   }
 
-  const check = pl.canBuild(planet, building, lastRound, {
+  const check = pl.canBuild(planet, building, lastRound, replay, {
     addedCost: [new Reward(qicNeeded.amount, Resource.Qic)],
   });
 
@@ -368,9 +369,10 @@ export function possibleBuildings(engine: Engine, player: Player): AvailableComm
       const upgraded = upgradedBuildings(building, engine.player(player).faction);
 
       for (const upgrade of upgraded) {
-        const check = engine
-          .player(player)
-          .canBuild(hex.data.planet, upgrade, engine.isLastRound, { isolated, existingBuilding: building });
+        const check = engine.player(player).canBuild(hex.data.planet, upgrade, engine.isLastRound, engine.replay, {
+          isolated,
+          existingBuilding: building,
+        });
         if (check) {
           buildings.push(newAvailableBuilding(upgrade, hex, check, true));
         }
@@ -382,7 +384,7 @@ export function possibleBuildings(engine: Engine, player: Player): AvailableComm
       // No need for terra forming if already occupied by another faction
       const planet = hex.occupied() ? pl.planet : hex.data.planet;
       const building = hex.data.planet === Planet.Transdim ? Building.GaiaFormer : Building.Mine;
-      addPossibleNewPlanet(map, hex, pl, planet, building, buildings, engine.isLastRound);
+      addPossibleNewPlanet(map, hex, pl, planet, building, buildings, engine.isLastRound, engine.replay);
     }
   } // end for hex
 
@@ -412,7 +414,7 @@ export function possibleSpaceStations(engine: Engine, player: Player): Available
     }
 
     const building = Building.SpaceStation;
-    addPossibleNewPlanet(map, hex, pl, pl.planet, building, buildings, engine.isLastRound);
+    addPossibleNewPlanet(map, hex, pl, pl.planet, building, buildings, engine.isLastRound, engine.replay);
   }
 
   if (buildings.length > 0) {
@@ -494,7 +496,7 @@ export function possibleSpecialActions(engine: Engine, player: Player) {
   return commands;
 }
 
-export function possibleBoardActions(actions: BoardActions, p: PlayerObject): AvailableCommand[] {
+export function possibleBoardActions(actions: BoardActions, p: PlayerObject, replay: boolean): AvailableCommand[] {
   const commands: AvailableCommand[] = [];
 
   // not allowed if everything is lost - see https://github.com/boardgamers/gaia-project/issues/76
@@ -512,7 +514,7 @@ export function possibleBoardActions(actions: BoardActions, p: PlayerObject): Av
     (pwract) =>
       actions[pwract] === null &&
       p.data.canPay(Reward.parse(boardActions[pwract].cost)) &&
-      boardActions[pwract].income.some((income) => Reward.parse(income).some((reward) => canGain(reward)))
+      boardActions[pwract].income.some((income) => Reward.parse(income).some((reward) => replay || canGain(reward)))
   );
 
   // Prevent using the rescore action if no federation token
@@ -687,7 +689,7 @@ export function possibleSpaceLostPlanet(engine: Engine, player: Player) {
     if (hex.data.planet !== Planet.Empty || hex.data.federations || hex.data.building) {
       continue;
     }
-    const qicNeeded = qicForDistance(engine.map, hex, p);
+    const qicNeeded = qicForDistance(engine.map, hex, p, engine.replay);
 
     if (qicNeeded.amount > data.qics) {
       continue;

engine/src/cost.spec.ts

@@ -131,7 +131,7 @@ describe("cost", () => {
           player: PlayerEnum.Player1,
         } as Player;
 
-        const qic = qicForDistance(m, m.getS(g.location), p);
+        const qic = qicForDistance(m, m.getS(g.location), p, false);
         expect(qic).to.deep.equal(test.want);
       });
     }
@@ -179,7 +179,7 @@ describe("cost", () => {
       it(test.name, () => {
         const g = test.give;
         const p = { temporaryStep: g.temporaryStep, terraformCostDiscount: g.discount } as PlayerData;
-        const cost = terraformingCost(p, g.steps);
+        const cost = terraformingCost(p, g.steps, false);
         expect(cost).to.deep.equal(test.want.cost);
       });
     }

engine/src/cost.ts

@@ -8,12 +8,12 @@ import Reward from "./reward";
 const TERRAFORMING_COST = 3;
 const QIC_RANGE_UPGRADE = 2;
 
-export function terraformingCost(d: PlayerData, steps: number): Reward | null {
+export function terraformingCost(d: PlayerData, steps: number, replay: boolean): Reward | null {
   const oreNeeded = (temporaryStep: number) =>
     (TERRAFORMING_COST - d.terraformCostDiscount) * Math.max(steps - temporaryStep, 0);
 
   const cost = oreNeeded(d.temporaryStep);
-  if (d.temporaryStep > 0 && oreNeeded(0) === cost) {
+  if (!replay && d.temporaryStep > 0 && oreNeeded(0) === cost) {
     // not allowed - see https://github.com/boardgamers/gaia-project/issues/76
     // OR (for booster) there's no reason to activate the booster and not use it
     return null;
@@ -23,7 +23,7 @@ export function terraformingCost(d: PlayerData, steps: number): Reward | null {
 
 export type QicNeeded = { amount: number; distance: number; warning?: BuildWarning } | null;
 
-export function qicForDistance(map: SpaceMap, hex: GaiaHex, pl: PlayerObject): QicNeeded {
+export function qicForDistance(map: SpaceMap, hex: GaiaHex, pl: PlayerObject, replay: boolean): QicNeeded {
   const distance = (acceptGaiaFormer: boolean) => {
     const hexes = acceptGaiaFormer
       ? Array.from(map.grid.values()).filter((loc) => loc.data.player === pl.player)
@@ -37,7 +37,7 @@ export function qicForDistance(map: SpaceMap, hex: GaiaHex, pl: PlayerObject): Q
 
   const d = distance(false);
   const qicNeeded = qic(pl.data.temporaryRange, d);
-  if (pl.data.temporaryRange > 0 && qic(0, distance(false)) === qicNeeded) {
+  if (!replay && pl.data.temporaryRange > 0 && qic(0, distance(false)) === qicNeeded) {
     // there's no reason to activate the booster and not use it
     return null;
   }

engine/src/engine.ts

@@ -227,6 +227,8 @@ export default class Engine {
   oldPhase: Phase;
   randomFactions?: Faction[];
   version = version;
+  replayVersion: string;
+  replay: boolean; // be more permissive during replay
 
   get expansions() {
     return 0;
@@ -266,13 +268,19 @@ export default class Engine {
   // Tells the UI if the new move should be on the same line or not
   newTurn = true;
 
-  constructor(moves: string[] = [], options: EngineOptions = {}, engineVersion?: string) {
+  constructor(moves: string[] = [], options: EngineOptions = {}, engineVersion?: string, replay = false) {
     this.options = options;
     if (engineVersion) {
       this.version = engineVersion;
     }
+    this.replay = replay;
+    if (replay) {
+      this.options.noFedCheck = true;
+      this.options.flexibleFederations = true;
+    }
     this.sanitizeOptions();
     this.loadMoves(moves);
+    this.options = options;
   }
 
   /** Fix old options passed. To remove when legacy data is no more in database */
@@ -311,12 +319,23 @@ export default class Engine {
   }
 
   move(_move: string, allowIncomplete = true) {
-    assert(this.newTurn, "Cannot execute a move after executing an incomplete move");
+    if (this.replay) {
+      this.newTurn = true;
+    } else {
+      assert(this.newTurn, "Cannot execute a move after executing an incomplete move");
+    }
 
     const execute = () => {
-      if (!this.executeMove(move)) {
-        assert(allowIncomplete, `Move ${move} (line ${this.moveHistory.length + 1}) is not complete!`);
-        this.newTurn = false;
+      try {
+        if (!this.executeMove(move)) {
+          if (!this.replay) {
+            assert(allowIncomplete, `Move ${move} (line ${this.moveHistory.length + 1}) is not complete!`);
+          }
+          this.newTurn = false;
+        }
+      } catch (e) {
+        console.log(this.assertContext());
+        throw e;
       }
     };
 
@@ -329,7 +348,9 @@ export default class Engine {
       execute();
     }
 
-    assert(this.turnMoves.length === 0, "Unnecessary commands at the end of the turn: " + this.turnMoves.join(". "));
+    if (!this.replay) {
+      assert(this.turnMoves.length === 0, "Unnecessary commands at the end of the turn: " + this.turnMoves.join(". "));
+    }
     this.moveHistory.push(moveToShow);
   }
 
@@ -711,7 +732,7 @@ export default class Engine {
     return false;
   }
 
-  static fromData(data: Record<string, any>) {
+  static fromData(data: Record<string, any>): Engine {
     const engine = new Engine();
     delete engine.version;
 
@@ -836,10 +857,12 @@ export default class Engine {
       }
     }
 
-    assert(
-      this.playerToMove === (player as PlayerEnum),
-      "Wrong turn order in move " + move + ", expected player " + (this.playerToMove + 1) + this.assertContext()
-    );
+    if (!this.replay) {
+      assert(
+        this.playerToMove === (player as PlayerEnum),
+        "Wrong turn order in move " + move + ", expected player " + (this.playerToMove + 1)
+      );
+    }
     this.processedPlayer = player;
 
     const split = params.split ?? true;
@@ -896,7 +919,7 @@ export default class Engine {
     if (subphase) {
       this.generateAvailableCommands(subphase, data);
       if (this.availableCommands.length === 0) {
-        if (required) {
+        if (required && !this.replay) {
           // not allowed - see https://github.com/boardgamers/gaia-project/issues/76
           this.availableCommands = [{ name: Command.DeadEnd, player: this.currentPlayer, data: subphase }];
         } else {
@@ -927,10 +950,10 @@ export default class Engine {
   }
 
   checkCommand(command: Command) {
-    assert(
-      (this.availableCommand = this.findAvailableCommand(this.playerToMove, command)),
-      `Command ${command} is not in the list of available commands: ${this.assertContext()}`
-    );
+    this.availableCommand = this.findAvailableCommand(this.playerToMove, command);
+    if (!this.availableCommand && !this.replay) {
+      assert(this.availableCommand, `Command ${command} is not in the list of available commands`);
+    }
   }
 
   private assertContext(): string {
@@ -1525,10 +1548,12 @@ export default class Engine {
   }
 
   [Command.Bid](player: PlayerEnum, faction: string, bid: number) {
-    const bidsAC = this.avCommand<Command.Bid>().data.bids;
-    const bidAC = bidsAC.find((b) => b.faction === faction);
-    assert(bidAC.bid.includes(+bid), "You have to bid the right amount");
-    assert(bidAC, `${faction} is not in the available factions`);
+    if (!this.replay) {
+      const bidsAC = this.avCommand<Command.Bid>().data.bids;
+      const bidAC = bidsAC.find((b) => b.faction === faction);
+      assert(bidAC, `${faction} is not in the available factions`);
+      assert(bidAC.bid.includes(+bid), "You have to bid the right amount");
+    }
     this.executeBid(player, faction, bid);
   }
 
@@ -1746,7 +1771,7 @@ export default class Engine {
       return false;
     };
 
-    assert(isPossible(cost, income), `spend ${cost} for ${income} is not allowed: ${this.assertContext()}`);
+    assert(isPossible(cost, income), `spend ${cost} for ${income} is not allowed`);
 
     pl.payCosts(cost, Command.Spend);
     pl.gainRewards(income, Command.Spend);
@@ -1796,7 +1821,7 @@ export default class Engine {
   [Command.FormFederation](player: PlayerEnum, hexes: string, federation: Federation) {
     const pl = this.player(player);
 
-    const fedInfo = pl.checkAndGetFederationInfo(hexes, this.map, this.options.flexibleFederations);
+    const fedInfo = pl.checkAndGetFederationInfo(hexes, this.map, this.options.flexibleFederations, this.replay);
 
     assert(fedInfo, `Impossible to form federation at ${hexes}`);
     assert(

engine/src/player.spec.ts

@@ -17,7 +17,7 @@ describe("Player", () => {
       player.faction = Faction.Terrans;
       player.loadFaction(standard);
 
-      const { cost } = player.canBuild(Planet.Terra, Building.Mine, false, {
+      const { cost } = player.canBuild(Planet.Terra, Building.Mine, false, false, {
         addedCost: [new Reward(1, Resource.Qic)],
       });
 

engine/src/player.ts

@@ -247,6 +247,7 @@ export default class Player extends EventEmitter {
     targetPlanet: Planet,
     building: Building,
     lastRound: boolean,
+    replay: boolean,
     {
       isolated,
       addedCost,
@@ -285,7 +286,7 @@ export default class Player extends EventEmitter {
     } else if (building === Building.Mine) {
       // habitability costs
       if (targetPlanet === Planet.Gaia) {
-        if (this.data.temporaryStep > 0) {
+        if (this.data.temporaryStep > 0 && !replay) {
           // not allowed - see https://github.com/boardgamers/gaia-project/issues/76
           // OR (for booster) there's no reason to activate the booster and not use it
           return null;
@@ -300,7 +301,7 @@ export default class Player extends EventEmitter {
       } else {
         // Get the number of terraforming steps to pay discounting terraforming track
         steps = terraformingStepsRequired(factionPlanet(this.faction), targetPlanet);
-        const reward = terraformingCost(this.data, steps);
+        const reward = terraformingCost(this.data, steps, replay);
 
         if (reward === null) {
           return null;
@@ -1058,7 +1059,7 @@ export default class Player extends EventEmitter {
     this.federationCache = null;
   }
 
-  checkAndGetFederationInfo(location: string, map: SpaceMap, flexible: boolean): FederationInfo {
+  checkAndGetFederationInfo(location: string, map: SpaceMap, flexible: boolean, replay: boolean): FederationInfo {
     const hexes = this.hexesForFederationLocation(location, map);
 
     // Check if no forbidden square
@@ -1079,13 +1080,17 @@ export default class Player extends EventEmitter {
 
     const info = this.federationInfo(hexes);
 
-    assert(info.newSatellites <= this.maxSatellites, "Federation requires too many satellites");
+    if (!replay) {
+      assert(info.newSatellites <= this.maxSatellites, "Federation requires too many satellites");
+    }
 
     // Check if outclassed by available federations
     const available = this.availableFederations(map, flexible);
     const outclasser = available.find((fed) => isOutclassedBy(info, fed));
 
-    assert(!outclasser, "Federation is outclassed by other federation at " + (outclasser?.hexes ?? []).join(","));
+    if (!replay) {
+      assert(!outclasser, "Federation is outclassed by other federation at " + (outclasser?.hexes ?? []).join(","));
+    }
 
     // Check if federation can be built with less satellites
     if (!flexible) {

engine/src/tiles/boosters.spec.ts

@@ -137,8 +137,7 @@ describe("boosters", () => {
     `);
 
     expect(() => new Engine([...moves], { factionVariant: "more-balanced" })).to.throw(
-      "Command endturn is not in the list of available commands: last command: firaks pass booster9 returning booster4, index: 10,\n" +
-        '    available: [{"name":"deadEnd","player":0,"data":"buildMineOrGaiaFormer"}]'
+      "Command endturn is not in the list of available commands"
     );
   });
 });

engine/wrapper.ts

@@ -180,10 +180,10 @@ export function factions(engine: Engine) {
   return engine.players.map((pl) => pl.faction);
 }
 
-export async function replay(engine: Engine) {
+export async function replay(engine: Engine): Promise<Engine> {
   const oldPlayers = engine.players;
 
-  engine = new Engine(engine.moveHistory, engine.options);
+  engine = new Engine(engine.moveHistory, engine.options, engine.version ?? "1.0.0", true); //fall back to unknown version
 
   assert(engine.newTurn, "Last move of the game is incomplete");