Refactor: migrate ice (#1308)

* refactor: migrate ice module

* chore: lint

* refactor: enhance rand function documentation for clarity on argument usage

* refactor: reorganize imports in probabilityUtils test file for clarity

Author: SheepFromHeaven

src/index.html

@@ -8494,7 +8494,6 @@
 
     <script defer src="config/heightmap-templates.js"></script>
     <script defer src="config/precreated-heightmaps.js"></script>
-    <script defer src="modules/ice.js?v=1.111.0"></script>
     <script defer src="modules/military-generator.js?v=1.107.0"></script>
     <script defer src="modules/markers-generator.js?v=1.107.0"></script>
     <script defer src="modules/coa-generator.js?v=1.99.00"></script>

public/modules/ice.js src/modules/ice.tspublic/modules/ice.js renamed to src/modules/ice.ts

@@ -1,44 +1,65 @@
-"use strict";
-
-// Ice layer data model - separates ice data from SVG rendering
-window.Ice = (function () {
-
+import Alea from "alea";
+import { min } from "d3";
+import {
+  clipPoly,
+  getGridPolygon,
+  getIsolines,
+  lerp,
+  minmax,
+  normalize,
+  P,
+  ra,
+  rand,
+  rn,
+} from "../utils";
+import type { Point } from "./voronoi";
+
+declare global {
+  var Ice: IceModule;
+}
+
+class IceModule {
   // Find next available id for new ice element idealy filling gaps
-  function getNextId() {
+  private 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);
+    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;
     }
     return existingIds[existingIds.length - 1] + 1;
   }
 
+  // Clear all ice
+  private clear() {
+    pack.ice = [];
+  }
+
   // Generate glaciers and icebergs based on temperature and height
-  function generate() {
-    clear();
+  public generate() {
+    this.clear();
     const { cells, features } = grid;
     const { temp, h } = cells;
-    Math.random = aleaPRNG(seed);
+    Math.random = Alea(seed);
 
     const ICEBERG_MAX_TEMP = 0;
     const GLACIER_MAX_TEMP = -8;
-    const minMaxTemp = d3.min(temp);
+    const minMaxTemp = min<number>(temp)!;
 
     // Generate glaciers on cold land
     {
       const type = "iceShield";
-      const getType = cellId =>
+      const getType = (cellId: number) =>
         h[cellId] >= 20 && temp[cellId] <= GLACIER_MAX_TEMP ? type : null;
       const isolines = getIsolines(grid, getType, { polygons: true });
 
       if (isolines[type]?.polygons) {
-        isolines[type].polygons.forEach(points => {
-          const clipped = clipPoly(points);
+        isolines[type].polygons.forEach((points: Point[]) => {
+          const clipped = clipPoly(points, graphWidth, graphHeight);
           pack.ice.push({
-            i: getNextId(),
+            i: this.getNextId(),
             points: clipped,
-            type: "glacier"
+            type: "glacier",
           });
         });
       }
@@ -58,62 +79,53 @@ window.Ice = (function () {
       const size = minmax(rn(baseSize * randomFactor, 2), 0.1, 1);
 
       const [cx, cy] = grid.points[cellId];
-      const points = getGridPolygon(cellId).map(([x, y]) => [
+      const points = getGridPolygon(cellId, grid).map(([x, y]: Point) => [
         rn(lerp(cx, x, size), 2),
-        rn(lerp(cy, y, size), 2)
+        rn(lerp(cy, y, size), 2),
       ]);
 
       pack.ice.push({
-        i: getNextId(),
+        i: this.getNextId(),
         points,
         type: "iceberg",
         cellId,
-        size
+        size,
       });
     }
   }
 
-  function addIceberg(cellId, size) {
+  addIceberg(cellId: number, size: number) {
     const [cx, cy] = grid.points[cellId];
-    const points = getGridPolygon(cellId).map(([x, y]) => [
+    const points = getGridPolygon(cellId, grid).map(([x, y]: Point) => [
       rn(lerp(cx, x, size), 2),
-      rn(lerp(cy, y, size), 2)
+      rn(lerp(cy, y, size), 2),
     ]);
-    const id = getNextId();
+    const id = this.getNextId();
     pack.ice.push({
       i: id,
       points,
       type: "iceberg",
       cellId,
-      size
+      size,
     });
     redrawIceberg(id);
   }
 
-  function removeIce(id) {
-    const index = pack.ice.findIndex(element => element.i === id);
+  removeIce(id: number) {
+    const index = pack.ice.findIndex((element) => element.i === id);
     if (index !== -1) {
-      const type = pack.ice.find(element => element.i === id).type;
+      const type = pack.ice.find((element) => element.i === id).type;
       pack.ice.splice(index, 1);
       if (type === "glacier") {
         redrawGlacier(id);
       } else {
         redrawIceberg(id);
       }
-      
     }
   }
 
-  function updateIceberg(id, points, size) {
-    const iceberg = pack.ice.find(element => element.i === id);
-    if (iceberg) {
-      iceberg.points = points;
-      iceberg.size = size;
-    }
-  }
-
-  function randomizeIcebergShape(id) {
-    const iceberg = pack.ice.find(element => element.i === id);
+  randomizeIcebergShape(id: number) {
+    const iceberg = pack.ice.find((element) => element.i === id);
     if (!iceberg) return;
 
     const cellId = iceberg.cellId;
@@ -123,17 +135,20 @@ window.Ice = (function () {
     // Get a different random cell for the polygon template
     const i = ra(grid.cells.i);
     const cn = grid.points[i];
-    const poly = getGridPolygon(i).map(p => [p[0] - cn[0], p[1] - cn[1]]);
-    const points = poly.map(p => [
+    const poly = getGridPolygon(i, grid).map((p: Point) => [
+      p[0] - cn[0],
+      p[1] - cn[1],
+    ]);
+    const points = poly.map((p: Point) => [
       rn(cx + p[0] * size, 2),
-      rn(cy + p[1] * size, 2)
+      rn(cy + p[1] * size, 2),
     ]);
 
     iceberg.points = points;
   }
 
-  function changeIcebergSize(id, newSize) {
-    const iceberg = pack.ice.find(element => element.i === id);
+  changeIcebergSize(id: number, newSize: number) {
+    const iceberg = pack.ice.find((element) => element.i === id);
     if (!iceberg) return;
 
     const cellId = iceberg.cellId;
@@ -143,28 +158,18 @@ window.Ice = (function () {
     const flat = iceberg.points.flat();
     const pairs = [];
     while (flat.length) pairs.push(flat.splice(0, 2));
-    const poly = pairs.map(p => [(p[0] - cx) / oldSize, (p[1] - cy) / oldSize]);
-    const points = poly.map(p => [
+    const poly = pairs.map((p) => [
+      (p[0] - cx) / oldSize,
+      (p[1] - cy) / oldSize,
+    ]);
+    const points = poly.map((p) => [
       rn(cx + p[0] * newSize, 2),
-      rn(cy + p[1] * newSize, 2)
+      rn(cy + p[1] * newSize, 2),
     ]);
 
     iceberg.points = points;
     iceberg.size = newSize;
   }
+}
 
-  // Clear all ice
-  function clear() {
-    pack.ice = [];
-  }
-
-  return {
-    generate,
-    addIceberg,
-    removeIce,
-    updateIceberg,
-    randomizeIcebergShape,
-    changeIcebergSize,
-    clear
-  };
-})();
+window.Ice = new IceModule();

src/modules/index.ts

@@ -13,3 +13,4 @@ import "./states-generator";
 import "./zones-generator";
 import "./religions-generator";
 import "./provinces-generator";
+import "./ice";