feat: add all grid data to JSON export

index.html

@@ -7992,7 +7992,7 @@
     <script src="modules/ui/stylePresets.js?v=1.89.11"></script>
 
     <script src="modules/ui/general.js?v=1.93.01"></script>
-    <script src="modules/ui/options.js?v=1.93.02"></script>
+    <script src="modules/ui/options.js?v=1.93.03"></script>
     <script src="main.js?v=1.93.02"></script>
 
     <script defer src="modules/relief-icons.js"></script>

modules/dynamic/export-json.js

@@ -3,11 +3,12 @@ export function exportToJson(type) {
     return tip("Data cannot be exported when edit mode is active, please exit the mode and retry", false, "error");
   closeDialogs("#alert");
 
+  TIME && console.time("exportToJson");
   const typeMap = {
     Full: getFullDataJson,
     Minimal: getMinimalDataJson,
-    PackCells: getPackCellsDataJson,
+    PackCells: getPackDataJson,
-    GridCells: getGridCellsDataJson
+    GridCells: getGridDataJson
   };
 
   const mapData = typeMap[type]();
@@ -19,24 +20,28 @@ export function exportToJson(type) {
   link.click();
   tip(`${link.download} is saved. Open "Downloads" screen (CTRL + J) to check`, true, "success", 7000);
   window.URL.revokeObjectURL(URL);
+  TIME && console.timeEnd("exportToJson");
 }
 
 function getFullDataJson() {
-  TIME && console.time("getFullDataJson");
-
   const info = getMapInfo();
   const settings = getSettings();
-  const cells = getPackCellsData();
+  const pack = getPackCellsData();
-  const vertices = getPackVerticesData();
+  const grid = getGridCellsData();
-  const exportData = {info, settings, coords: mapCoordinates, cells, vertices, biomes: biomesData, notes, nameBases};
 
-  TIME && console.timeEnd("getFullDataJson");
+  return JSON.stringify({
-  return JSON.stringify(exportData);
+    info,
+    settings,
+    mapCoordinates,
+    pack,
+    grid,
+    biomesData,
+    notes,
+    nameBases
+  });
 }
 
 function getMinimalDataJson() {
-  TIME && console.time("getMinimalDataJson");
-
   const info = getMapInfo();
   const settings = getSettings();
   const packData = {
@@ -49,36 +54,23 @@ function getMinimalDataJson() {
     rivers: pack.rivers,
     markers: pack.markers
   };
-  const exportData = {info, settings, coords: mapCoordinates, pack: packData, biomes: biomesData, notes, nameBases};
+  return JSON.stringify({info, settings, mapCoordinates, pack: packData, biomesData, notes, nameBases});
-
-  TIME && console.timeEnd("getMinimalDataJson");
-  return JSON.stringify(exportData);
 }
 
-function getPackCellsDataJson() {
+function getPackDataJson() {
-  TIME && console.time("getCellsDataJson");
-
   const info = getMapInfo();
   const cells = getPackCellsData();
-  const exportData = {info, cells};
+  return JSON.stringify({info, cells});
-
-  TIME && console.timeEnd("getCellsDataJson");
-  return JSON.stringify(exportData);
 }
 
-function getGridCellsDataJson() {
+function getGridDataJson() {
-  TIME && console.time("getGridCellsDataJson");
-
   const info = getMapInfo();
-  const gridCells = getGridCellsData();
+  const cells = getGridCellsData();
-  const exportData = {info, gridCells};
+  return JSON.stringify({info, cells});
-
-  TIME && console.log("getGridCellsDataJson");
-  return JSON.stringify(exportData);
 }
 
 function getMapInfo() {
-  const info = {
+  return {
     version,
     description: "Azgaar's Fantasy Map Generator output: azgaar.github.io/Fantasy-map-generator",
     exportedAt: new Date().toISOString(),
@@ -86,12 +78,10 @@ function getMapInfo() {
     seed,
     mapId
   };
-
-  return info;
 }
 
 function getSettings() {
-  const settings = {
+  return {
     distanceUnit: distanceUnitInput.value,
     distanceScale: distanceScaleInput.value,
     areaUnit: areaUnit.value,
@@ -116,13 +106,10 @@ function getSettings() {
     rescaleLabels: rescaleLabels.checked,
     urbanDensity: urbanDensity
   };
-
-  return settings;
 }
 
 function getPackCellsData() {
-  const cellConverted = {
+  const dataArrays = {
-    i: Array.from(pack.cells.i),
     v: pack.cells.v,
     c: pack.cells.c,
     p: pack.cells.p,
@@ -148,41 +135,39 @@ function getPackCellsData() {
     province: Array.from(pack.cells.province)
   };
 
-  const cellObjArr = [];
+  return {
-  {
+    cells: Array.from(pack.cells.i).map(cellId => ({
-    cellConverted.i.forEach(value => {
+      i: cellId,
-      const cellobj = {
+      v: dataArrays.v[cellId],
-        i: value,
+      c: dataArrays.c[cellId],
-        v: cellConverted.v[value],
+      p: dataArrays.p[cellId],
-        c: cellConverted.c[value],
+      g: dataArrays.g[cellId],
-        p: cellConverted.p[value],
+      h: dataArrays.h[cellId],
-        g: cellConverted.g[value],
+      area: dataArrays.area[cellId],
-        h: cellConverted.h[value],
+      f: dataArrays.f[cellId],
-        area: cellConverted.area[value],
+      t: dataArrays.t[cellId],
-        f: cellConverted.f[value],
+      haven: dataArrays.haven[cellId],
-        t: cellConverted.t[value],
+      harbor: dataArrays.harbor[cellId],
-        haven: cellConverted.haven[value],
+      fl: dataArrays.fl[cellId],
-        harbor: cellConverted.harbor[value],
+      r: dataArrays.r[cellId],
-        fl: cellConverted.fl[value],
+      conf: dataArrays.conf[cellId],
-        r: cellConverted.r[value],
+      biome: dataArrays.biome[cellId],
-        conf: cellConverted.conf[value],
+      s: dataArrays.s[cellId],
-        biome: cellConverted.biome[value],
+      pop: dataArrays.pop[cellId],
-        s: cellConverted.s[value],
+      culture: dataArrays.culture[cellId],
-        pop: cellConverted.pop[value],
+      burg: dataArrays.burg[cellId],
-        culture: cellConverted.culture[value],
+      road: dataArrays.road[cellId],
-        burg: cellConverted.burg[value],
+      crossroad: dataArrays.crossroad[cellId],
-        road: cellConverted.road[value],
+      state: dataArrays.state[cellId],
-        crossroad: cellConverted.crossroad[value],
+      religion: dataArrays.religion[cellId],
-        state: cellConverted.state[value],
+      province: dataArrays.province[cellId]
-        religion: cellConverted.religion[value],
+    })),
-        province: cellConverted.province[value]
+    vertices: pack.vertices.c.map(vertexId => ({
-      };
+      i: vertexId,
-      cellObjArr.push(cellobj);
+      p: pack.vertices.p[vertexId],
-    });
+      v: pack.vertices.v[vertexId],
-  }
+      c: pack.vertices.c[vertexId]
-
+    })),
-  const cellsData = {
-    cells: cellObjArr,
     features: pack.features,
     cultures: pack.cultures,
     burgs: pack.burgs,
@@ -192,32 +177,46 @@ function getPackCellsData() {
     rivers: pack.rivers,
     markers: pack.markers
   };
-
-  return cellsData;
 }
 
 function getGridCellsData() {
+  const dataArrays = {
+    v: grid.cells.v,
+    c: grid.cells.c,
+    b: grid.cells.b,
+    f: Array.from(grid.cells.f),
+    t: Array.from(grid.cells.t),
+    h: Array.from(grid.cells.h),
+    temp: Array.from(grid.cells.temp),
+    prec: Array.from(grid.cells.prec)
+  };
+
   const gridData = {
+    cells: Array.from(grid.cells.i).map(cellId => ({
+      i: cellId,
+      v: dataArrays.v[cellId],
+      c: dataArrays.c[cellId],
+      b: dataArrays.b[cellId],
+      f: dataArrays.f[cellId],
+      t: dataArrays.t[cellId],
+      h: dataArrays.h[cellId],
+      temp: dataArrays.temp[cellId],
+      prec: dataArrays.prec[cellId]
+    })),
+    vertices: grid.vertices.c.map(vertexId => ({
+      i: vertexId,
+      p: pack.vertices.p[vertexId],
+      v: pack.vertices.v[vertexId],
+      c: pack.vertices.c[vertexId]
+    })),
     cellsDesired: grid.cellsDesired,
     spacing: grid.spacing,
     cellsY: grid.cellsY,
     cellsX: grid.cellsX,
     points: grid.points,
-    boundary: grid.boundary
+    boundary: grid.boundary,
+    seed: grid.seed,
+    features: pack.features
   };
   return gridData;
 }
-
-function getPackVerticesData() {
-  const {vertices} = pack;
-  const verticesNumber = vertices.p.length;
-  const verticesArray = new Array(verticesNumber);
-  for (let i = 0; i < verticesNumber; i++) {
-    verticesArray[i] = {
-      p: vertices.p[i],
-      v: vertices.v[i],
-      c: vertices.c[i]
-    };
-  }
-  return verticesArray;
-}

modules/ui/options.js

@@ -785,7 +785,7 @@ function showExportPane() {
 }
 
 async function exportToJson(type) {
-  const {exportToJson} = await import("../dynamic/export-json.js");
+  const {exportToJson} = await import("../dynamic/export-json.js?v=1.93.03");
   exportToJson(type);
 }
 

versioning.js

@@ -1,7 +1,7 @@
 "use strict";
 
 // version and caching control
-const version = "1.93.02"; // generator version, update each time
+const version = "1.93.03"; // generator version, update each time
 
 {
   document.title += " v" + version;