@jgengine/core 0.6.0 → 0.8.0

package/dist/world/weather.js

@@ -0,0 +1,169 @@
+const NEUTRAL = {
+    grip: 1,
+    visibility: 1,
+    structureDamage: 0,
+    chill: 0,
+    ignition: 0,
+    spread: 1,
+};
+function lerp(from, to, t) {
+    return from + (to - from) * t;
+}
+/**
+ * Resolve a weather state against a game-owned modifier table into concrete gameplay
+ * numbers. Multiplier-style effects (grip, visibility, spread) interpolate from the
+ * neutral 1 by intensity; rate-style effects (structureDamage, ignition, chill) scale
+ * linearly. Games read `grip`/`visibility` in movement and AI, `structureDamage` on a
+ * building tick, and `spread`/`ignition` feed the fire grid.
+ */
+export function resolveWeather(state, table) {
+    const entry = table[state.kind];
+    if (entry === undefined)
+        return { ...NEUTRAL };
+    const t = Math.max(0, Math.min(1, state.intensity));
+    return {
+        grip: lerp(1, entry.grip ?? 1, t),
+        visibility: lerp(1, entry.visibility ?? 1, t),
+        structureDamage: (entry.structureDamage ?? 0) * t,
+        chill: (entry.chill ?? 0) * t,
+        ignition: (entry.ignition ?? 0) * t,
+        spread: lerp(1, entry.spread ?? 1, t),
+    };
+}
+const NEIGHBOURS = [
+    [1, 0],
+    [-1, 0],
+    [0, 1],
+    [0, -1],
+    [1, 1],
+    [1, -1],
+    [-1, 1],
+    [-1, -1],
+];
+export function createFireGrid(config) {
+    const { cols, rows, cellSize } = config;
+    if (cols <= 0 || rows <= 0)
+        throw new Error("createFireGrid: cols/rows must be positive");
+    const originX = config.origin?.[0] ?? 0;
+    const originZ = config.origin?.[1] ?? 0;
+    const ignitionThreshold = config.ignitionThreshold ?? 1;
+    const spreadRate = config.spreadRate ?? 0.6;
+    const burnRate = config.burnRate ?? 0.25;
+    const windBias = Math.max(0, Math.min(1, config.windBias ?? 0.6));
+    const wind = config.wind;
+    const windLen = wind === undefined ? 0 : Math.hypot(wind[0], wind[1]);
+    const windX = windLen > 0 ? wind[0] / windLen : 0;
+    const windZ = windLen > 0 ? wind[1] / windLen : 0;
+    const cells = new Array(cols * rows);
+    for (let row = 0; row < rows; row += 1) {
+        for (let col = 0; col < cols; col += 1) {
+            const fuel = config.fuelAt?.(col, row) ?? 1;
+            cells[row * cols + col] = { fuel: Math.max(0, fuel), heat: 0, state: "unburnt" };
+        }
+    }
+    const index = (col, row) => row * cols + col;
+    const inBounds = (col, row) => col >= 0 && col < cols && row >= 0 && row < rows;
+    const cellCoord = (x, z) => {
+        const col = Math.round((x - originX) / cellSize);
+        const row = Math.round((z - originZ) / cellSize);
+        return inBounds(col, row) ? { col, row } : null;
+    };
+    const directionalWeight = (dx, dz) => {
+        if (windLen === 0)
+            return 1;
+        const len = Math.hypot(dx, dz) || 1;
+        const alignment = (dx / len) * windX + (dz / len) * windZ;
+        return 1 + windBias * alignment;
+    };
+    let burning = 0;
+    for (const cell of cells)
+        if (cell.state === "burning")
+            burning += 1;
+    const igniteCell = (col, row) => {
+        if (!inBounds(col, row))
+            return;
+        const cell = cells[index(col, row)];
+        if (cell.state === "burnt" || cell.fuel <= 0)
+            return;
+        if (cell.state !== "burning")
+            burning += 1;
+        cell.state = "burning";
+        cell.heat = Math.max(cell.heat, ignitionThreshold);
+    };
+    return {
+        cols,
+        rows,
+        step(dt, options) {
+            if (dt <= 0)
+                return;
+            const globalSpread = options?.spread ?? 1;
+            const wetnessAt = options?.wetnessAt;
+            const addedHeat = new Float64Array(cols * rows);
+            for (let row = 0; row < rows; row += 1) {
+                for (let col = 0; col < cols; col += 1) {
+                    const cell = cells[index(col, row)];
+                    if (cell.state !== "burning")
+                        continue;
+                    for (const [dx, dz] of NEIGHBOURS) {
+                        const nc = col + dx;
+                        const nr = row + dz;
+                        if (!inBounds(nc, nr))
+                            continue;
+                        const neighbour = cells[index(nc, nr)];
+                        if (neighbour.state === "burnt" || neighbour.fuel <= 0)
+                            continue;
+                        addedHeat[index(nc, nr)] +=
+                            spreadRate * globalSpread * directionalWeight(dx, dz) * dt;
+                    }
+                }
+            }
+            for (let row = 0; row < rows; row += 1) {
+                for (let col = 0; col < cols; col += 1) {
+                    const i = index(col, row);
+                    const cell = cells[i];
+                    if (cell.state === "burning") {
+                        cell.fuel = Math.max(0, cell.fuel - burnRate * dt);
+                        if (cell.fuel <= 0) {
+                            cell.state = "burnt";
+                            cell.heat = 0;
+                            burning -= 1;
+                        }
+                        continue;
+                    }
+                    if (cell.state !== "unburnt" || addedHeat[i] === 0)
+                        continue;
+                    const resist = wetnessAt === undefined ? 0 : Math.max(0, Math.min(1, wetnessAt(col, row)));
+                    cell.heat += addedHeat[i] * (1 - resist);
+                    if (cell.heat >= ignitionThreshold && cell.fuel > 0) {
+                        cell.state = "burning";
+                        burning += 1;
+                    }
+                }
+            }
+        },
+        igniteCell,
+        ignite(x, z) {
+            const coord = cellCoord(x, z);
+            if (coord === null)
+                return false;
+            igniteCell(coord.col, coord.row);
+            return true;
+        },
+        cell(col, row) {
+            if (!inBounds(col, row))
+                throw new Error(`fire cell out of bounds: ${col},${row}`);
+            return cells[index(col, row)];
+        },
+        cellAt(x, z) {
+            const coord = cellCoord(x, z);
+            return coord === null ? null : cells[index(coord.col, coord.row)];
+        },
+        cellCoord,
+        get burning() {
+            return burning;
+        },
+        snapshot() {
+            return cells.map((cell) => ({ ...cell }));
+        },
+    };
+}