@jgengine/core 0.5.0 → 0.7.0

package/dist/world/walls.d.ts

@@ -0,0 +1,61 @@
+import { type Aabb, type Vec2 } from "./geometry.js";
+export type WallVec3 = readonly [number, number, number];
+export interface WallSegment {
+    from: Vec2;
+    to: Vec2;
+    length: number;
+    angle: number;
+}
+export interface EnclosedFootprint {
+    polygon: readonly Vec2[];
+    aabb: Aabb;
+    area: number;
+    perimeter: number;
+    closed: boolean;
+}
+export type RoofStyle = "hip" | "gable" | "flat";
+export interface RoofPlan {
+    style: RoofStyle;
+    ridge: readonly [Vec2, Vec2];
+    apexHeight: number;
+    eaveHeight: number;
+    faces: readonly (readonly WallVec3[])[];
+}
+export interface RoofConfig {
+    style?: RoofStyle;
+    eaveHeight?: number;
+    pitch?: number;
+    overhang?: number;
+}
+export declare function wallSegments(points: readonly Vec2[], closed: boolean): WallSegment[];
+export declare function isEnclosed(points: readonly Vec2[], tolerance?: number): boolean;
+export declare function enclosePath(points: readonly Vec2[], tolerance?: number): readonly Vec2[];
+export declare function polygonArea(polygon: readonly Vec2[]): number;
+export declare function footprintFromWalls(points: readonly Vec2[], tolerance?: number): EnclosedFootprint | null;
+export declare function autoRoof(footprint: EnclosedFootprint, config?: RoofConfig): RoofPlan;
+export type PaintTarget = "floor" | "wall";
+export interface SurfacePaintStore {
+    paint(target: PaintTarget, key: string, surface: string): void;
+    clear(target: PaintTarget, key: string): void;
+    get(target: PaintTarget, key: string): string | null;
+    entries(target: PaintTarget): readonly (readonly [string, string])[];
+    snapshot(): Record<PaintTarget, Record<string, string>>;
+    restore(snapshot: Record<PaintTarget, Record<string, string>>): void;
+}
+export declare function createSurfacePaint(): SurfacePaintStore;
+export interface WallDrawTool {
+    addPoint(point: Vec2, snap?: number): Vec2;
+    undo(): void;
+    close(): void;
+    clear(): void;
+    points(): readonly Vec2[];
+    segments(): WallSegment[];
+    isClosed(): boolean;
+    footprint(): EnclosedFootprint | null;
+    roof(config?: RoofConfig): RoofPlan | null;
+}
+export declare function createWallDrawTool(config?: {
+    snap?: number;
+    closeTolerance?: number;
+}): WallDrawTool;
+export declare function wallSegmentBounds(segment: WallSegment, thickness: number): Aabb;

package/dist/world/walls.js

@@ -0,0 +1,221 @@
+import { footprintAabb } from "./geometry.js";
+export function wallSegments(points, closed) {
+    const segments = [];
+    const count = closed ? points.length : points.length - 1;
+    for (let index = 0; index < count; index += 1) {
+        const from = points[index];
+        const to = points[(index + 1) % points.length];
+        const dx = to[0] - from[0];
+        const dz = to[1] - from[1];
+        segments.push({ from, to, length: Math.hypot(dx, dz), angle: Math.atan2(dz, dx) });
+    }
+    return segments;
+}
+export function isEnclosed(points, tolerance = 0.5) {
+    if (points.length < 3)
+        return false;
+    const first = points[0];
+    const last = points[points.length - 1];
+    return Math.hypot(first[0] - last[0], first[1] - last[1]) <= tolerance;
+}
+export function enclosePath(points, tolerance = 0.5) {
+    if (points.length < 3)
+        return points;
+    if (!isEnclosed(points, tolerance))
+        return points;
+    return points.slice(0, points.length - 1);
+}
+export function polygonArea(polygon) {
+    let sum = 0;
+    for (let index = 0; index < polygon.length; index += 1) {
+        const a = polygon[index];
+        const b = polygon[(index + 1) % polygon.length];
+        sum += a[0] * b[1] - b[0] * a[1];
+    }
+    return Math.abs(sum) / 2;
+}
+export function footprintFromWalls(points, tolerance = 0.5) {
+    const closed = isEnclosed(points, tolerance);
+    const polygon = enclosePath(points, tolerance);
+    if (polygon.length < 3)
+        return null;
+    let minX = Infinity;
+    let minZ = Infinity;
+    let maxX = -Infinity;
+    let maxZ = -Infinity;
+    let perimeter = 0;
+    for (let index = 0; index < polygon.length; index += 1) {
+        const point = polygon[index];
+        if (point[0] < minX)
+            minX = point[0];
+        if (point[0] > maxX)
+            maxX = point[0];
+        if (point[1] < minZ)
+            minZ = point[1];
+        if (point[1] > maxZ)
+            maxZ = point[1];
+        const next = polygon[(index + 1) % polygon.length];
+        perimeter += Math.hypot(next[0] - point[0], next[1] - point[1]);
+    }
+    return {
+        polygon,
+        aabb: { minX, minZ, maxX, maxZ },
+        area: polygonArea(polygon),
+        perimeter,
+        closed,
+    };
+}
+export function autoRoof(footprint, config = {}) {
+    const style = config.style ?? "hip";
+    const eaveHeight = config.eaveHeight ?? 3;
+    const pitch = config.pitch ?? 0.5;
+    const overhang = config.overhang ?? 0.4;
+    const aabb = footprint.aabb;
+    const minX = aabb.minX - overhang;
+    const maxX = aabb.maxX + overhang;
+    const minZ = aabb.minZ - overhang;
+    const maxZ = aabb.maxZ + overhang;
+    const width = maxX - minX;
+    const depth = maxZ - minZ;
+    const cx = (minX + maxX) / 2;
+    const cz = (minZ + maxZ) / 2;
+    const ridgeAlongX = width >= depth;
+    const halfSpan = (ridgeAlongX ? depth : width) / 2;
+    const apexHeight = style === "flat" ? eaveHeight : eaveHeight + halfSpan * pitch;
+    if (style === "flat") {
+        const face = [
+            [minX, eaveHeight, minZ],
+            [maxX, eaveHeight, minZ],
+            [maxX, eaveHeight, maxZ],
+            [minX, eaveHeight, maxZ],
+        ];
+        const flatRidge = [
+            [minX, cz],
+            [maxX, cz],
+        ];
+        return { style, ridge: flatRidge, apexHeight, eaveHeight, faces: [face] };
+    }
+    const ridge = ridgeAlongX
+        ? [
+            [minX + (style === "hip" ? halfSpan : 0), cz],
+            [maxX - (style === "hip" ? halfSpan : 0), cz],
+        ]
+        : [
+            [cx, minZ + (style === "hip" ? halfSpan : 0)],
+            [cx, maxZ - (style === "hip" ? halfSpan : 0)],
+        ];
+    const r0 = [ridge[0][0], apexHeight, ridge[0][1]];
+    const r1 = [ridge[1][0], apexHeight, ridge[1][1]];
+    const corners = {
+        nw: [minX, eaveHeight, minZ],
+        ne: [maxX, eaveHeight, minZ],
+        se: [maxX, eaveHeight, maxZ],
+        sw: [minX, eaveHeight, maxZ],
+    };
+    const faces = ridgeAlongX
+        ? [
+            [corners.nw, corners.ne, r1, r0],
+            [corners.se, corners.sw, r0, r1],
+        ]
+        : [
+            [corners.ne, corners.se, r1, r0],
+            [corners.sw, corners.nw, r0, r1],
+        ];
+    if (style === "hip") {
+        faces.push(ridgeAlongX
+            ? [corners.sw, corners.nw, r0]
+            : [corners.nw, corners.ne, r0]);
+        faces.push(ridgeAlongX
+            ? [corners.ne, corners.se, r1]
+            : [corners.se, corners.sw, r1]);
+    }
+    return { style, ridge, apexHeight, eaveHeight, faces };
+}
+export function createSurfacePaint() {
+    const maps = {
+        floor: new Map(),
+        wall: new Map(),
+    };
+    return {
+        paint(target, key, surface) {
+            maps[target].set(key, surface);
+        },
+        clear(target, key) {
+            maps[target].delete(key);
+        },
+        get(target, key) {
+            return maps[target].get(key) ?? null;
+        },
+        entries(target) {
+            return Array.from(maps[target].entries());
+        },
+        snapshot() {
+            return {
+                floor: Object.fromEntries(maps.floor),
+                wall: Object.fromEntries(maps.wall),
+            };
+        },
+        restore(snapshot) {
+            maps.floor = new Map(Object.entries(snapshot.floor ?? {}));
+            maps.wall = new Map(Object.entries(snapshot.wall ?? {}));
+        },
+    };
+}
+function snapPoint(point, grid) {
+    if (!(grid > 0))
+        return point;
+    return [Math.round(point[0] / grid) * grid, Math.round(point[1] / grid) * grid];
+}
+export function createWallDrawTool(config = {}) {
+    const defaultSnap = config.snap ?? 0;
+    const closeTolerance = config.closeTolerance ?? 0.5;
+    let pts = [];
+    let closed = false;
+    return {
+        addPoint(point, snap) {
+            const grid = snap ?? defaultSnap;
+            const next = snapPoint(point, grid);
+            if (pts.length >= 3 && Math.hypot(next[0] - pts[0][0], next[1] - pts[0][1]) <= closeTolerance) {
+                closed = true;
+                return pts[0];
+            }
+            pts.push(next);
+            return next;
+        },
+        undo() {
+            pts.pop();
+            closed = false;
+        },
+        close() {
+            if (pts.length >= 3)
+                closed = true;
+        },
+        clear() {
+            pts = [];
+            closed = false;
+        },
+        points() {
+            return pts;
+        },
+        segments() {
+            return wallSegments(pts, closed);
+        },
+        isClosed() {
+            return closed;
+        },
+        footprint() {
+            if (!closed && !isEnclosed(pts, closeTolerance))
+                return null;
+            return footprintFromWalls(pts, closeTolerance);
+        },
+        roof(roofConfig) {
+            const fp = this.footprint();
+            return fp === null ? null : autoRoof(fp, roofConfig);
+        },
+    };
+}
+export function wallSegmentBounds(segment, thickness) {
+    const center = [(segment.from[0] + segment.to[0]) / 2, (segment.from[1] + segment.to[1]) / 2];
+    const quarterTurns = Math.abs(Math.round(segment.angle / (Math.PI / 2))) % 2;
+    return footprintAabb(center, { w: segment.length, d: thickness }, quarterTurns);
+}

package/dist/world/water.d.ts

@@ -0,0 +1,27 @@
+import type { OceanEnvironmentDescriptor } from "./features.js";
+export type WaterNormal = readonly [number, number, number];
+export interface GerstnerWave {
+    direction: readonly [number, number];
+    wavelength: number;
+    amplitude: number;
+    steepness: number;
+    speed: number;
+}
+export interface WaterSurfaceConfig {
+    level?: number;
+    waveHeight?: number;
+    waveScale?: number;
+    waveSpeed?: number;
+    waves?: number;
+    choppiness?: number;
+}
+export interface WaterSurface {
+    readonly level: number;
+    readonly waves: readonly GerstnerWave[];
+    height(x: number, z: number, time: number): number;
+    normal(x: number, z: number, time: number): WaterNormal;
+    displace(x: number, z: number, time: number): readonly [number, number, number];
+}
+export declare function synthesizeWaves(config?: WaterSurfaceConfig): GerstnerWave[];
+export declare function waterSurface(config?: WaterSurfaceConfig): WaterSurface;
+export declare function waterSurfaceFromDescriptor(descriptor: OceanEnvironmentDescriptor, waves?: number): WaterSurface;

package/dist/world/water.js

@@ -0,0 +1,125 @@
+const GRAVITY = 9.81;
+const TWO_PI = Math.PI * 2;
+const AMPLITUDE_FALLOFF = 0.65;
+const WAVELENGTH_FALLOFF = 0.65;
+const DIRECTION_SPREAD = 0.62;
+function resolveConfig(config) {
+    return {
+        level: config.level ?? 0,
+        waveHeight: config.waveHeight ?? 1.2,
+        waveScale: config.waveScale ?? 18,
+        waveSpeed: config.waveSpeed ?? 0.55,
+        waves: config.waves ?? 4,
+        choppiness: config.choppiness ?? 1,
+    };
+}
+export function synthesizeWaves(config = {}) {
+    const resolved = resolveConfig(config);
+    const count = Math.max(0, Math.floor(resolved.waves));
+    if (count === 0 || resolved.waveHeight <= 0) {
+        return [];
+    }
+    let amplitudeSum = 0;
+    for (let i = 0; i < count; i += 1) {
+        amplitudeSum += AMPLITUDE_FALLOFF ** i;
+    }
+    const amplitudeUnit = resolved.waveHeight / amplitudeSum;
+    const waves = [];
+    for (let i = 0; i < count; i += 1) {
+        const amplitude = amplitudeUnit * AMPLITUDE_FALLOFF ** i;
+        const wavelength = resolved.waveScale * WAVELENGTH_FALLOFF ** i;
+        const k = TWO_PI / wavelength;
+        const angle = DIRECTION_SPREAD * (i % 2 === 0 ? 1 : -1) * Math.ceil(i / 2);
+        const direction = [Math.cos(angle), Math.sin(angle)];
+        const omega = Math.sqrt(GRAVITY * k) * resolved.waveSpeed;
+        const speed = omega / k;
+        const steepnessLimit = 1 / (k * amplitude * count);
+        const steepness = Math.min(1, Math.max(0, 0.4 * steepnessLimit));
+        waves.push({ direction, wavelength, amplitude, steepness, speed });
+    }
+    return waves;
+}
+export function waterSurface(config = {}) {
+    const resolved = resolveConfig(config);
+    const level = resolved.level;
+    const choppiness = resolved.choppiness;
+    const waves = synthesizeWaves(config);
+    const height = (x, z, time) => {
+        let y = level;
+        for (const wave of waves) {
+            const k = TWO_PI / wave.wavelength;
+            const omega = wave.speed * k;
+            const phase = k * (wave.direction[0] * x + wave.direction[1] * z) - omega * time;
+            y += wave.amplitude * Math.sin(phase);
+        }
+        return y;
+    };
+    const displace = (x, z, time) => {
+        let dx = x;
+        let dz = z;
+        let dy = level;
+        for (const wave of waves) {
+            const k = TWO_PI / wave.wavelength;
+            const omega = wave.speed * k;
+            const phase = k * (wave.direction[0] * x + wave.direction[1] * z) - omega * time;
+            const cosPhase = Math.cos(phase);
+            const q = wave.steepness;
+            dx += q * wave.amplitude * choppiness * wave.direction[0] * cosPhase;
+            dz += q * wave.amplitude * choppiness * wave.direction[1] * cosPhase;
+            dy += wave.amplitude * Math.sin(phase);
+        }
+        return [dx, dy, dz];
+    };
+    const normal = (x, z, time) => {
+        let tx = 1;
+        let ty = 0;
+        let tz = 0;
+        let bx = 0;
+        let by = 0;
+        let bz = 1;
+        for (const wave of waves) {
+            const k = TWO_PI / wave.wavelength;
+            const omega = wave.speed * k;
+            const phase = k * (wave.direction[0] * x + wave.direction[1] * z) - omega * time;
+            const cosPhase = Math.cos(phase);
+            const sinPhase = Math.sin(phase);
+            const wa = k * wave.amplitude;
+            const q = wave.steepness;
+            const dxWave = wave.direction[0];
+            const dzWave = wave.direction[1];
+            tx += -q * dxWave * dxWave * wa * choppiness * sinPhase;
+            ty += dxWave * wa * cosPhase;
+            tz += -q * dxWave * dzWave * wa * choppiness * sinPhase;
+            bx += -q * dxWave * dzWave * wa * choppiness * sinPhase;
+            by += dzWave * wa * cosPhase;
+            bz += -q * dzWave * dzWave * wa * choppiness * sinPhase;
+        }
+        let nx = by * tz - bz * ty;
+        let ny = bz * tx - bx * tz;
+        let nz = bx * ty - by * tx;
+        const lengthSq = nx * nx + ny * ny + nz * nz;
+        if (lengthSq === 0) {
+            return [0, 1, 0];
+        }
+        const inv = 1 / Math.sqrt(lengthSq);
+        nx *= inv;
+        ny *= inv;
+        nz *= inv;
+        if (ny < 0) {
+            nx = -nx;
+            ny = -ny;
+            nz = -nz;
+        }
+        return [nx, ny, nz];
+    };
+    return { level, waves, height, normal, displace };
+}
+export function waterSurfaceFromDescriptor(descriptor, waves) {
+    return waterSurface({
+        level: descriptor.level,
+        waveHeight: descriptor.waveHeight,
+        waveScale: descriptor.waveScale,
+        waveSpeed: descriptor.waveSpeed,
+        ...(waves === undefined ? {} : { waves }),
+    });
+}

package/dist/world/weather.d.ts

@@ -0,0 +1,92 @@
+import type { WindVector } from "./wind.js";
+export type WeatherKind = string;
+export interface WeatherState {
+    /** Game-defined kind: "clear", "rain", "storm", "snow", "fog", "sandstorm". */
+    kind: WeatherKind;
+    /** 0..1 severity — scales every modifier. */
+    intensity: number;
+    wind?: WindVector;
+}
+/** Per-kind gameplay effect values at full intensity. Intensity interpolates from neutral. */
+export interface WeatherModifier {
+    /** Movement traction multiplier at full intensity — <1 = mud/ice slows, 1 = normal. */
+    grip?: number;
+    /** View distance multiplier at full intensity — 0..1, 1 = clear. */
+    visibility?: number;
+    /** Structure HP lost per game-second at full intensity (hail, storm). */
+    structureDamage?: number;
+    /** Temperature delta at full intensity (a blizzard chills). */
+    chill?: number;
+    /** Lightning ignition chance per game-second at full intensity. */
+    ignition?: number;
+    /** Fire spread-rate multiplier at full intensity — rain suppresses (<1). Default neutral 1. */
+    spread?: number;
+}
+export type WeatherModifierTable = Record<WeatherKind, WeatherModifier>;
+export interface ResolvedWeather {
+    grip: number;
+    visibility: number;
+    structureDamage: number;
+    chill: number;
+    ignition: number;
+    spread: number;
+}
+/**
+ * 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 declare function resolveWeather(state: WeatherState, table: WeatherModifierTable): ResolvedWeather;
+export type FireCellState = "unburnt" | "burning" | "burnt";
+export interface FireCell {
+    fuel: number;
+    heat: number;
+    state: FireCellState;
+}
+export interface FireGridConfig {
+    cols: number;
+    rows: number;
+    cellSize: number;
+    /** World x,z of the center of cell (0,0). Default [0,0]. */
+    origin?: readonly [number, number];
+    /** Initial fuel 0..1 per cell; default 1 everywhere. */
+    fuelAt?: (col: number, row: number) => number;
+    /** Accumulated heat needed to ignite a fuelled cell. Default 1. */
+    ignitionThreshold?: number;
+    /** Heat pushed to each neighbour per second from a burning cell. Default 0.6. */
+    spreadRate?: number;
+    /** Fuel consumed per second while burning. Default 0.25. */
+    burnRate?: number;
+    /** Prevailing wind biasing spread direction. */
+    wind?: WindVector;
+    /** How strongly wind biases downwind vs upwind spread, 0..1. Default 0.6. */
+    windBias?: number;
+}
+export interface FireStepOptions {
+    /** Global spread multiplier this step (rain suppression from resolveWeather().spread). Default 1. */
+    spread?: number;
+    /** Per-cell wetness 0..1 that resists ignition — from an environment field. */
+    wetnessAt?: (col: number, row: number) => number;
+}
+export interface FireGrid {
+    readonly cols: number;
+    readonly rows: number;
+    /** Advance the cellular propagation by game-time `dt`. */
+    step(dt: number, options?: FireStepOptions): void;
+    igniteCell(col: number, row: number): void;
+    /** Ignite the cell under a world position; no-op if outside the grid. */
+    ignite(x: number, z: number): boolean;
+    cell(col: number, row: number): FireCell;
+    cellAt(x: number, z: number): FireCell | null;
+    cellCoord(x: number, z: number): {
+        col: number;
+        row: number;
+    } | null;
+    /** Count of currently burning cells. */
+    readonly burning: number;
+    /** Flat snapshot (row-major) for rendering. */
+    snapshot(): FireCell[];
+}
+export declare function createFireGrid(config: FireGridConfig): FireGrid;

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 }));
+        },
+    };
+}