Correctly save and restore source grids (Penrose etc.).

Author: gvtulder

src/game/Game.test.ts

@@ -8,6 +8,9 @@ import { SquaresAtlas } from "../grid/atlas/SquaresAtlas";
 import { TileGenerators } from "./TileGenerator";
 import { Game } from "./Game";
 import { AutoPlayer } from "./autoplayer/AutoPlayer";
+import { seedPRNG } from "../geom/RandomSampler";
+import { TrianglesAtlas } from "../grid/atlas/TrianglesAtlas";
+import { Penrose3GridAtlas } from "../grid/atlas/Penrose3GridAtlas";
 
 describe("Game", () => {
     test("can be created", () => {
@@ -21,28 +24,34 @@ describe("Game", () => {
         const game = new Game(settings);
     });
 
-    test("can be saved and restored", () => {
+    const atlases = [SquaresAtlas, TrianglesAtlas, Penrose3GridAtlas];
+    test.each(atlases)("can be saved and restored: $id", (atlas) => {
+        const prng = seedPRNG(1234);
+
         const colors = ["red", "blue", "green", "black"];
         const settings = {
-            atlas: SquaresAtlas,
+            atlas: atlas,
             initialTile: colors,
             tilesShownOnStack: 3,
             tileGenerator: [TileGenerators.permutations(colors)],
         };
-        const game = new Game(settings);
+        const game = new Game(settings, prng);
 
         const player = new AutoPlayer(game);
-        player.playOneTile();
-        player.playOneTile();
-        player.playOneTile();
+        player.playOneTile(prng);
+        player.playOneTile(prng);
+        player.playOneTile(prng);
         expect(game.grid.tiles.size).toBe(4);
 
         const saved = game.saveState();
 
-        const game2 = new Game(settings, undefined, saved);
+        const game2 = new Game(settings, seedPRNG(4321), saved);
         expect(game2.points).toBe(game.points);
         expect(game2.continued).toBe(game.continued);
         expect(game2.tileStack).toEqual(game.tileStack);
         expect(game2.grid.tiles.size).toBe(game.grid.tiles.size);
+        expect(game2.grid.sourceGrid).toEqual(game.grid.sourceGrid);
+        game2.grid.generatePlaceholders();
+        expect(game2.grid.tiles.size).toBe(game.grid.tiles.size);
     });
 });

src/game/Game.ts

@@ -23,6 +23,7 @@ import {
     DemoGameSettings,
     GameInitializer,
 } from "./GameInitializer";
+import { SourceGrid } from "../grid/SourceGrid";
 
 export type GameSettings = {
     serializedJSON?: string;
@@ -67,6 +68,7 @@ export const GameState_S = zod.object({
     continued: zod.boolean(),
     tileStack: TileStackWithSlots_S,
     tiles: TileSet_S,
+    sourceGrid: zod.optional(zod.unknown()),
 });
 export type GameState_S = zod.infer<typeof GameState_S>;
 
@@ -114,28 +116,37 @@ export class Game extends EventTarget {
 
         this.settings = settings;
 
-        this.grid = new Grid(this.settings.atlas);
-        if (settings.rules) this.grid.rules = settings.rules.create();
-        this.scorer = (settings.scorer || ConnectedSegmentScorer).create();
-
+        let state = null;
+        let sourceGrid = undefined;
         if (restoreState) {
-            // restore previous game state
             try {
-                const state = GameState_S.parse(restoreState);
-                this.points = state.points;
-                this.continued = state.continued;
-                this.tileStack = TileStackWithSlots.restore(
-                    state.tileStack,
-                    this.grid.atlas.shapes,
-                );
-                this.grid.restoreTiles(state.tiles);
-                return;
+                state = GameState_S.parse(restoreState);
+                if (state.sourceGrid && this.settings.atlas.sourceGrid) {
+                    sourceGrid = this.settings.atlas.sourceGrid.restore(
+                        state.sourceGrid,
+                    );
+                }
             } catch (err) {
                 console.log(err);
                 // continue with default initialization
             }
         }
 
+        this.grid = new Grid(this.settings.atlas, undefined, sourceGrid);
+        if (settings.rules) this.grid.rules = settings.rules.create();
+        this.scorer = (settings.scorer || ConnectedSegmentScorer).create();
+
+        if (state) {
+            this.points = state.points;
+            this.continued = state.continued;
+            this.tileStack = TileStackWithSlots.restore(
+                state.tileStack,
+                this.grid.atlas.shapes,
+            );
+            this.grid.restoreTiles(state.tiles);
+            return;
+        }
+
         this.points = 0;
         this.continued = false;
 
@@ -182,6 +193,7 @@ export class Game extends EventTarget {
             continued: this.continued,
             tileStack: this.tileStack.save(this.grid.atlas.shapes),
             tiles: this.grid.saveTilesAndPlaceholders(),
+            sourceGrid: this.grid.sourceGrid?.save(),
         };
     }
 

src/grid/Grid.test.ts

@@ -15,6 +15,9 @@ import { SquaresAtlas } from "./atlas/SquaresAtlas";
 import { TrianglesAtlas } from "./atlas/TrianglesAtlas";
 import { Atlas } from "./Atlas";
 import { SnubSquareSourceGrid } from "./source/SnubSquareSourceGrid";
+import { Penrose3SourceGrid } from "./source/Penrose3SourceGrid";
+import { SetupCatalog } from "../saveGames";
+import { SnubSquareGridAtlas } from "./atlas/SnubSquareGridAtlas";
 
 const TRIANGLE = TrianglesAtlas.shapes[0];
 
@@ -467,13 +470,16 @@ describe("Grid", () => {
         expect(grid2.placeholders.size).toBe(1);
     });
 
-    test("can save and restore tiles with a source grid", () => {
-        const atlas = Atlas.fromSourceGrid("", "", "", SnubSquareSourceGrid);
-        const grid = new Grid(atlas);
+    const atlases = [...SetupCatalog.atlas.values()];
+    test.each(atlases)("can save and restore from $atlas.id", (atlasEntry) => {
+        const grid = new Grid(atlasEntry.atlas);
         const tile = grid.addInitialTile();
         const savedTiles = grid.saveTilesAndPlaceholders();
+        const savedSourceGrid = grid.sourceGrid?.save();
 
-        const grid2 = new Grid(atlas);
+        const sourceGrid2 =
+            atlasEntry.atlas.sourceGrid?.restore(savedSourceGrid);
+        const grid2 = new Grid(atlasEntry.atlas, undefined, sourceGrid2);
         grid2.restoreTiles(savedTiles);
         const restoredTile = [...grid2.tiles][0];
         expect(restoredTile.centroid).toEqual(tile.centroid);

src/grid/SourceGrid.ts

@@ -12,6 +12,8 @@ export abstract class SourceGrid {
     static readonly shapes: readonly Shape[];
     static readonly shapeFrequencies: ReadonlyMap<Shape, number>;
 
+    static restore: (data: unknown) => SourceGrid;
+
     static create(prng?: PRNG): SourceGrid {
         throw new Error("Must be implemented in a subclass.");
     }