perf: use typed arrays and inline loops across generators

Replace sparse JS cost/checked arrays with Float32Array/Uint8Array in
cultures, states, provinces, religions, zones, lakes, and pathUtils.
In river-generator, precompute outCell-to-lake map, replace sort-based
min-finding with inline loops, and remove dead debug code. In ice.js,
use Set for ID lookup and sequential IDs during generate().

Author: barrulus

public/modules/ice.js

@@ -3,15 +3,13 @@
 // Ice layer data model - separates ice data from SVG rendering
 window.Ice = (function () {
 
-  // Find next available id for new ice element idealy filling gaps
+  // Find next available id for new ice element ideally filling gaps
   function getNextId() {
     if (pack.ice.length === 0) return 0;
-    // find gaps in existing ids
-    const existingIds = pack.ice.map(e => e.i).sort((a, b) => a - b);
-    for (let id = 0; id < existingIds[existingIds.length - 1]; id++) {
-      if (!existingIds.includes(id)) return id;
+    const existingIds = new Set(pack.ice.map(e => e.i));
+    for (let id = 0; ; id++) {
+      if (!existingIds.has(id)) return id;
     }
-    return existingIds[existingIds.length - 1] + 1;
   }
 
   // Generate glaciers and icebergs based on temperature and height
@@ -24,6 +22,7 @@ window.Ice = (function () {
     const ICEBERG_MAX_TEMP = 0;
     const GLACIER_MAX_TEMP = -8;
     const minMaxTemp = d3.min(temp);
+    let nextId = 0; // sequential IDs since we start from clear()
 
     // Generate glaciers on cold land
     {
@@ -36,7 +35,7 @@ window.Ice = (function () {
         isolines[type].polygons.forEach(points => {
           const clipped = clipPoly(points);
           pack.ice.push({
-            i: getNextId(),
+            i: nextId++,
             points: clipped,
             type: "glacier"
           });
@@ -64,7 +63,7 @@ window.Ice = (function () {
       ]);
 
       pack.ice.push({
-        i: getNextId(),
+        i: nextId++,
         points,
         type: "iceberg",
         cellId,

src/modules/cultures-generator.ts

@@ -1289,7 +1289,7 @@ class CulturesModule {
     const { cells, cultures } = pack;
 
     const queue = new FlatQueue();
-    const cost: number[] = [];
+    const cost = new Float32Array(cells.i.length);
 
     const neutralRate =
       (byId("neutralRate") as HTMLInputElement)?.valueAsNumber || 1;
@@ -1313,6 +1313,7 @@ class CulturesModule {
         { cellId: culture.center, cultureId: culture.i, priority: 0 },
         0,
       );
+      cost[culture.center as number] = 1; // mark as seeded
     }
 
     const getBiomeCost = (c: number, biome: number, type: string) => {

src/modules/lakes.ts

@@ -101,6 +101,7 @@ export class LakesModule {
     const ELEVATION_LIMIT = +(
       byId("lakeElevationLimitOutput") as HTMLInputElement
     )?.value;
+    const checked = new Uint8Array(cells.i.length);
 
     pack.features.forEach((feature) => {
       if (feature.type !== "lake") return;
@@ -117,8 +118,8 @@ export class LakesModule {
         (a, b) => h[a] - h[b],
       )[0];
       const queue = [lowestShorelineCell];
-      const checked = [];
-      checked[lowestShorelineCell] = true;
+      const visited = [lowestShorelineCell];
+      checked[lowestShorelineCell] = 1;
 
       while (queue.length && isDeep) {
         const cellId: number = queue.pop() as number;
@@ -133,11 +134,15 @@ export class LakesModule {
               isDeep = false;
           }
 
-          checked[neibCellId] = true;
+          checked[neibCellId] = 1;
+          visited.push(neibCellId);
           queue.push(neibCellId);
         }
       }
 
+      // reset checked for visited cells only
+      for (let j = 0; j < visited.length; j++) checked[visited[j]] = 0;
+
       feature.closed = isDeep;
     });
   }

src/modules/provinces-generator.ts

@@ -174,7 +174,7 @@ class ProvinceModule {
 
     // expand generated provinces
     const queue = new FlatQueue();
-    const cost: number[] = [];
+    const cost = new Float32Array(cells.i.length);
 
     provinces.forEach((p) => {
       if (!p.i || p.removed || isProvinceLocked(p)) return;
@@ -269,7 +269,7 @@ class ProvinceModule {
         provinceIds[center] = provinceId;
 
         // expand province
-        const cost: number[] = [];
+        const cost = new Float32Array(cells.i.length);
         cost[center] = 1;
         queue.push({ e: center, p: 0 }, 0);
         while (queue.length) {

src/modules/religions-generator.ts

@@ -894,7 +894,7 @@ class ReligionsModule {
     const religionIds = this.spreadFolkReligions(religions);
 
     const queue = new FlatQueue();
-    const cost: number[] = [];
+    const cost = new Float32Array(cells.i.length);
 
     // limit cost for organized religions growth
     const maxExpansionCost =

src/modules/river-generator.ts

@@ -1,5 +1,5 @@
 import Alea from "alea";
-import { curveBasis, curveCatmullRom, line, mean, min, sum } from "d3";
+import { curveBasis, curveCatmullRom, line, mean, sum } from "d3";
 import { each, rn, round, rw } from "../utils";
 
 declare global {
@@ -69,16 +69,21 @@ class RiverModule {
         .sort((a: number, b: number) => h[b] - h[a]);
       const lakeOutCells = Lakes.defineClimateData(h);
 
+      // pre-compute map from outCell to qualifying lake features
+      const outCellToLakes = new Map<number, any[]>();
+      for (const feature of features) {
+        if (feature.type !== "lake" || !feature.outCell) continue;
+        if (!(feature.flux > feature.evaporation)) continue;
+        const list = outCellToLakes.get(feature.outCell);
+        if (list) list.push(feature);
+        else outCellToLakes.set(feature.outCell, [feature]);
+      }
+
       for (const i of land) {
         cells.fl[i] += prec[cells.g[i]] / cellsNumberModifier; // add flux from precipitation
 
         // create lake outlet if lake is not in deep depression and flux > evaporation
-        const lakes = lakeOutCells[i]
-          ? features.filter(
-              (feature: any) =>
-                i === feature.outCell && feature.flux > feature.evaporation,
-            )
-          : [];
+        const lakes = (lakeOutCells[i] && outCellToLakes.get(i)) || [];
         for (const lake of lakes) {
           const lakeCell = cells.c[i].find(
             (c: number) => h[c] < 20 && cells.f[c] === lake.i,
@@ -121,34 +126,29 @@ class RiverModule {
         }
 
         // downhill cell (make sure it's not in the source lake)
-        let min = null;
+        let minCell = -1;
         if (lakeOutCells[i]) {
-          const filtered = cells.c[i].filter(
-            (c: number) =>
-              !lakes.map((lake: any) => lake.i).includes(cells.f[c]),
-          );
-          min = filtered.sort((a: number, b: number) => h[a] - h[b])[0];
+          const lakeIds = new Set(lakes.map((lake: any) => lake.i));
+          let minH = Infinity;
+          for (const c of cells.c[i]) {
+            if (lakeIds.has(cells.f[c])) continue;
+            if (h[c] < minH) { minH = h[c]; minCell = c; }
+          }
         } else if (cells.haven[i]) {
-          min = cells.haven[i];
+          minCell = cells.haven[i];
         } else {
-          min = cells.c[i].sort((a: number, b: number) => h[a] - h[b])[0];
+          let minH = Infinity;
+          for (const c of cells.c[i]) {
+            if (h[c] < minH) { minH = h[c]; minCell = c; }
+          }
         }
 
         // cells is depressed
-        if (h[i] <= h[min]) continue;
-
-        // debug
-        //   .append("line")
-        //   .attr("x1", pack.cells.p[i][0])
-        //   .attr("y1", pack.cells.p[i][1])
-        //   .attr("x2", pack.cells.p[min][0])
-        //   .attr("y2", pack.cells.p[min][1])
-        //   .attr("stroke", "#333")
-        //   .attr("stroke-width", 0.2);
+        if (minCell < 0 || h[i] <= h[minCell]) continue;
 
         if (cells.fl[i] < MIN_FLUX_TO_FORM_RIVER) {
           // flux is too small to operate as a river
-          if (h[min] >= 20) cells.fl[min] += cells.fl[i];
+          if (h[minCell] >= 20) cells.fl[minCell] += cells.fl[i];
           continue;
         }
 
@@ -159,7 +159,7 @@ class RiverModule {
           riverNext++;
         }
 
-        flowDown(min, cells.fl[i], cells.r[i]);
+        flowDown(minCell, cells.fl[i], cells.r[i]);
       }
     };
 
@@ -370,28 +370,39 @@ class RiverModule {
       if (iteration < checkLakeMaxIteration) {
         for (const l of lakes) {
           if (l.closed) continue;
-          const minHeight = min(l.shoreline.map((s: number) => h[s])) as number;
+          let minHeight = Infinity;
+          for (let si = 0; si < l.shoreline.length; si++) {
+            const sh = h[l.shoreline[si]];
+            if (sh < minHeight) minHeight = sh;
+          }
           if (minHeight >= 100 || l.height > minHeight) continue;
 
           if (iteration > elevateLakeMaxIteration) {
             l.shoreline.forEach((i: number) => {
               h[i] = cells.h[i];
             });
-            l.height =
-              (min(l.shoreline.map((s: number) => h[s])) as number) - 1;
+            let resetMin = Infinity;
+            for (let si = 0; si < l.shoreline.length; si++) {
+              const sh = h[l.shoreline[si]];
+              if (sh < resetMin) resetMin = sh;
+            }
+            l.height = resetMin - 1;
             l.closed = true;
             continue;
           }
 
           depressions++;
-          l.height = (minHeight as number) + 0.2;
+          l.height = minHeight + 0.2;
         }
       }
 
       for (const i of land) {
-        const minHeight = min(
-          cells.c[i].map((c: number) => height(c)),
-        ) as number;
+        const neighbors = cells.c[i];
+        let minHeight = Infinity;
+        for (let ni = 0; ni < neighbors.length; ni++) {
+          const nh = height(neighbors[ni]);
+          if (nh < minHeight) minHeight = nh;
+        }
         if (minHeight >= 100 || h[i] > minHeight) continue;
 
         depressions++;

src/modules/states-generator.ts

@@ -146,7 +146,7 @@ class StatesModule {
     cells.state = cells.state || new Uint16Array(cells.i.length);
 
     const queue = new FlatQueue();
-    const cost: number[] = [];
+    const cost = new Float32Array(cells.i.length);
 
     const globalGrowthRate =
       (byId("growthRate") as HTMLInputElement)?.valueAsNumber || 1;

src/modules/zones-generator.ts

@@ -265,7 +265,7 @@ class ZonesModule {
     if (!burg) return;
 
     const cellsArray: number[] = [];
-    const cost: number[] = [];
+    const cost = new Float32Array(pack.cells.i.length);
     const maxCells = rand(20, 40);
 
     const queue = new FlatQueue();
@@ -409,7 +409,7 @@ class ZonesModule {
     usedCells[burg.cell] = 1;
 
     const cellsArray: number[] = [];
-    const cost: number[] = [];
+    const cost = new Float32Array(pack.cells.i.length);
     const maxCells = rand(5, 25);
 
     const queue = new FlatQueue();

src/utils/pathUtils.ts

@@ -341,10 +341,14 @@ export const findPath = (
 ): number[] | null => {
   if (isExit(start)) return null;
 
-  const from = [];
-  const cost = [];
+  const cellCount = packedGraph.cells.i.length;
+  const from = new Int32Array(cellCount).fill(-1);
+  const cost = new Float32Array(cellCount);
+  cost.fill(Infinity);
+
   const queue = new window.FlatQueue();
   queue.push(start, 0);
+  cost[start] = 0;
 
   while (queue.length) {
     const currentCost = queue.peekValue();
@@ -353,7 +357,7 @@ export const findPath = (
     for (const next of packedGraph.cells.c[current]) {
       if (isExit(next)) {
         from[next] = current;
-        return restorePath(next, start, from);
+        return restorePath(next, start, from as any);
       }
 
       const nextCost = getCost(current, next);