@jgengine/core 0.5.0 → 0.7.0

package/dist/world/scatterItems.js

@@ -0,0 +1,85 @@
+function hash(ix, iz, salt) {
+    let h = salt | 0;
+    h = Math.imul(h ^ (ix | 0), 0x27d4eb2d);
+    h = Math.imul(h ^ (iz | 0), 0x85ebca6b);
+    h ^= h >>> 15;
+    h = Math.imul(h, 0x2c1b3c6d);
+    h ^= h >>> 12;
+    return (h >>> 0) / 4294967295;
+}
+const DEFAULT_MAX_SLOPE = 0.55;
+/**
+ * Deterministically place opaque items across `area`, grounded on a region field.
+ * For each grid cell it asks `layersFor` which items may appear in that region and
+ * rolls one against their densities. The engine never interprets `item` — a game
+ * maps it to a mesh or entity. Content scatter (region-driven density) as opposed to
+ * `scatter` in `./scatter`, which is renderer-free geometric point distribution.
+ */
+export function scatterItems(field, area, layersFor, options = {}) {
+    const cell = options.cell ?? 5;
+    const max = options.max ?? 1400;
+    const salt = field.seed ^ (options.saltKey ?? 0x5f3a);
+    const out = [];
+    for (let gx = Math.floor(area.minX / cell); gx <= Math.ceil(area.maxX / cell); gx += 1) {
+        for (let gz = Math.floor(area.minZ / cell); gz <= Math.ceil(area.maxZ / cell); gz += 1) {
+            const roll = hash(gx, gz, salt);
+            const x = (gx + hash(gx, gz, salt ^ 0x11)) * cell;
+            const z = (gz + hash(gx, gz, salt ^ 0x22)) * cell;
+            const y = field.sampleHeight(x, z);
+            const sample = field.sampleRegion(x, z);
+            const layers = layersFor(sample);
+            if (layers.length === 0)
+                continue;
+            let total = 0;
+            for (const layer of layers)
+                total += layer.density;
+            if (roll > total)
+                continue;
+            let acc = 0;
+            let chosen = layers[0];
+            for (const layer of layers) {
+                acc += layer.density;
+                if (roll <= acc) {
+                    chosen = layer;
+                    break;
+                }
+            }
+            if ((chosen.aboveWaterOnly ?? true) && y < field.seaLevel + 0.1)
+                continue;
+            if (1 - field.sampleNormal(x, z)[1] > (chosen.maxSlope ?? DEFAULT_MAX_SLOPE))
+                continue;
+            const scaleRoll = hash(gx, gz, salt ^ 0x99);
+            const min = chosen.minScale ?? 0.8;
+            const maxScale = chosen.maxScale ?? 1.2;
+            out.push({
+                id: `${gx}:${gz}`,
+                item: chosen.item,
+                x,
+                z,
+                y,
+                scale: min + scaleRoll * (maxScale - min),
+                rotation: hash(gx, gz, salt ^ 0xabcd) * Math.PI * 2,
+                regionId: sample.region.id,
+            });
+            if (out.length >= max)
+                return out;
+        }
+    }
+    return out;
+}
+/** Weighted pick from opaque entries; `roll` in [0, 1). Returns null when empty. */
+export function pickWeighted(entries, roll) {
+    if (entries.length === 0)
+        return null;
+    let total = 0;
+    for (const entry of entries)
+        total += entry.weight;
+    const pick = roll * total;
+    let acc = 0;
+    for (const entry of entries) {
+        acc += entry.weight;
+        if (pick <= acc)
+            return entry.value;
+    }
+    return entries[entries.length - 1].value;
+}

package/dist/world/support.d.ts

@@ -0,0 +1,27 @@
+import type { AddBodyOptions } from "../physics/physicsWorld.js";
+import type { ConnectorVec3 } from "./connectors.js";
+export interface SupportPiece {
+    id: string;
+    grounded?: boolean;
+    position?: ConnectorVec3;
+    halfExtents?: ConnectorVec3;
+    mass?: number;
+}
+export interface SupportLink {
+    a: string;
+    b: string;
+}
+export interface SupportConfig {
+    maxDistance?: number;
+}
+export interface SupportResult {
+    supported: readonly string[];
+    unsupported: readonly string[];
+    distance: Readonly<Record<string, number>>;
+}
+export declare function solveSupport(pieces: readonly SupportPiece[], links: readonly SupportLink[], config?: SupportConfig): SupportResult;
+export interface DebrisOptions {
+    scatter?: number;
+    seed?: number;
+}
+export declare function toDebrisBodies(pieces: readonly SupportPiece[], collapsedIds: readonly string[], options?: DebrisOptions): AddBodyOptions[];

package/dist/world/support.js

@@ -0,0 +1,75 @@
+export function solveSupport(pieces, links, config = {}) {
+    const maxDistance = config.maxDistance ?? Infinity;
+    const ids = new Set(pieces.map((piece) => piece.id));
+    const adjacency = new Map();
+    for (const id of ids)
+        adjacency.set(id, []);
+    for (const link of links) {
+        if (!ids.has(link.a) || !ids.has(link.b))
+            continue;
+        adjacency.get(link.a).push(link.b);
+        adjacency.get(link.b).push(link.a);
+    }
+    const distance = {};
+    const queue = [];
+    for (const piece of pieces) {
+        if (piece.grounded === true) {
+            distance[piece.id] = 0;
+            queue.push(piece.id);
+        }
+    }
+    let head = 0;
+    while (head < queue.length) {
+        const current = queue[head];
+        head += 1;
+        const currentDistance = distance[current];
+        if (currentDistance >= maxDistance)
+            continue;
+        for (const neighbor of adjacency.get(current) ?? []) {
+            const next = currentDistance + 1;
+            if (distance[neighbor] === undefined || next < distance[neighbor]) {
+                distance[neighbor] = next;
+                queue.push(neighbor);
+            }
+        }
+    }
+    const supported = [];
+    const unsupported = [];
+    for (const piece of pieces) {
+        const d = distance[piece.id];
+        if (d !== undefined && d <= maxDistance)
+            supported.push(piece.id);
+        else
+            unsupported.push(piece.id);
+    }
+    return { supported, unsupported, distance };
+}
+function scatterHash(seed, index) {
+    let h = (seed ^ Math.imul(index + 1, 0x9e3779b1)) >>> 0;
+    h = Math.imul(h ^ (h >>> 15), 0x85ebca6b);
+    h ^= h >>> 13;
+    return ((h >>> 0) / 4294967295) * 2 - 1;
+}
+export function toDebrisBodies(pieces, collapsedIds, options = {}) {
+    const scatter = options.scatter ?? 1.5;
+    const seed = options.seed ?? 1;
+    const collapse = new Set(collapsedIds);
+    const bodies = [];
+    let index = 0;
+    for (const piece of pieces) {
+        if (!collapse.has(piece.id))
+            continue;
+        const position = piece.position ?? [0, 0, 0];
+        const halfExtents = piece.halfExtents ?? [0.5, 0.5, 0.5];
+        const vx = scatterHash(seed, index) * scatter;
+        const vz = scatterHash(seed, index + 977) * scatter;
+        bodies.push({
+            position,
+            halfExtents,
+            velocity: [vx, 0, vz],
+            ...(piece.mass === undefined ? {} : { mass: piece.mass }),
+        });
+        index += 1;
+    }
+    return bodies;
+}

package/dist/world/terraform.d.ts

@@ -0,0 +1,54 @@
+import type { Aabb, Vec2 } from "./geometry.js";
+import { type TerrainField } from "./terrain.js";
+export type TerraformMode = "raise" | "lower" | "flatten" | "paint";
+export type TerraformFalloff = "smooth" | "linear" | "none";
+export interface TerraformEdit {
+    mode: TerraformMode;
+    center: Vec2;
+    radius: number;
+    strength?: number;
+    target?: number;
+    surface?: string;
+    falloff?: TerraformFalloff;
+}
+export interface EditableTerrainConfig {
+    bounds: Aabb;
+    base?: TerrainField;
+    cellSize?: number;
+}
+export interface TerraformSnapshot {
+    bounds: Aabb;
+    cellSize: number;
+    cols: number;
+    rows: number;
+    offsets: readonly number[];
+    surfaces: readonly (string | null)[];
+}
+export interface EditableTerrain extends TerrainField {
+    apply(edit: TerraformEdit): number;
+    heightOffsetAt(x: number, z: number): number;
+    surfaceAt(x: number, z: number): string | null;
+    reset(): void;
+    snapshot(): TerraformSnapshot;
+    restore(snapshot: TerraformSnapshot): void;
+}
+export declare function brushWeight(distance: number, radius: number, falloff: TerraformFalloff): number;
+export declare function createEditableTerrain(config: EditableTerrainConfig): EditableTerrain;
+export interface TerraformBrushConfig {
+    radius?: number;
+    strength?: number;
+    falloff?: TerraformFalloff;
+    surface?: string;
+}
+export interface TerraformBrush {
+    raise(center: Vec2): number;
+    lower(center: Vec2): number;
+    flatten(center: Vec2, target?: number): number;
+    paint(center: Vec2, surface?: string): number;
+    setRadius(radius: number): void;
+    setStrength(strength: number): void;
+    config(): Required<Omit<TerraformBrushConfig, "surface">> & {
+        surface: string | undefined;
+    };
+}
+export declare function createTerraformBrush(terrain: Pick<EditableTerrain, "apply">, config?: TerraformBrushConfig): TerraformBrush;

package/dist/world/terraform.js

@@ -0,0 +1,186 @@
+import { FLAT_FIELD, withNormal } from "./terrain.js";
+export function brushWeight(distance, radius, falloff) {
+    if (radius <= 0)
+        return distance <= 0 ? 1 : 0;
+    const t = distance / radius;
+    if (t >= 1)
+        return 0;
+    if (falloff === "none")
+        return 1;
+    if (falloff === "linear")
+        return 1 - t;
+    const s = 1 - t;
+    return s * s * (3 - 2 * s);
+}
+function clampIndex(value, max) {
+    return value < 0 ? 0 : value > max ? max : value;
+}
+export function createEditableTerrain(config) {
+    const base = config.base ?? FLAT_FIELD;
+    const bounds = config.bounds;
+    const cellSize = config.cellSize && config.cellSize > 0 ? config.cellSize : 1;
+    const spanX = Math.max(bounds.maxX - bounds.minX, cellSize);
+    const spanZ = Math.max(bounds.maxZ - bounds.minZ, cellSize);
+    const cols = Math.max(1, Math.round(spanX / cellSize));
+    const rows = Math.max(1, Math.round(spanZ / cellSize));
+    const vertsX = cols + 1;
+    const vertsZ = rows + 1;
+    const offsets = new Float32Array(vertsX * vertsZ);
+    const surfaces = new Array(cols * rows).fill(null);
+    function gridX(x) {
+        return ((x - bounds.minX) / spanX) * cols;
+    }
+    function gridZ(z) {
+        return ((z - bounds.minZ) / spanZ) * rows;
+    }
+    function heightOffsetAt(x, z) {
+        const fx = gridX(x);
+        const fz = gridZ(z);
+        const x0 = clampIndex(Math.floor(fx), cols);
+        const z0 = clampIndex(Math.floor(fz), rows);
+        const x1 = clampIndex(x0 + 1, cols);
+        const z1 = clampIndex(z0 + 1, rows);
+        const tx = fx - x0 < 0 ? 0 : fx - x0 > 1 ? 1 : fx - x0;
+        const tz = fz - z0 < 0 ? 0 : fz - z0 > 1 ? 1 : fz - z0;
+        const v00 = offsets[z0 * vertsX + x0];
+        const v10 = offsets[z0 * vertsX + x1];
+        const v01 = offsets[z1 * vertsX + x0];
+        const v11 = offsets[z1 * vertsX + x1];
+        const top = v00 + (v10 - v00) * tx;
+        const bottom = v01 + (v11 - v01) * tx;
+        return top + (bottom - top) * tz;
+    }
+    const sampleHeight = (x, z) => base.sampleHeight(x, z) + heightOffsetAt(x, z);
+    const sampleNormal = withNormal(sampleHeight);
+    function editHeight(edit) {
+        const falloff = edit.falloff ?? "smooth";
+        const strength = edit.strength ?? 1;
+        const target = edit.mode === "flatten" ? edit.target ?? sampleHeight(edit.center[0], edit.center[1]) : 0;
+        const rCells = Math.ceil(edit.radius / cellSize) + 1;
+        const cx = gridX(edit.center[0]);
+        const cz = gridZ(edit.center[1]);
+        let changed = 0;
+        for (let iz = -rCells; iz <= rCells; iz += 1) {
+            const gz = Math.round(cz) + iz;
+            if (gz < 0 || gz >= vertsZ)
+                continue;
+            for (let ix = -rCells; ix <= rCells; ix += 1) {
+                const gx = Math.round(cx) + ix;
+                if (gx < 0 || gx >= vertsX)
+                    continue;
+                const wx = bounds.minX + (gx / cols) * spanX;
+                const wz = bounds.minZ + (gz / rows) * spanZ;
+                const dist = Math.hypot(wx - edit.center[0], wz - edit.center[1]);
+                const weight = brushWeight(dist, edit.radius, falloff);
+                if (weight <= 0)
+                    continue;
+                const index = gz * vertsX + gx;
+                if (edit.mode === "raise")
+                    offsets[index] += strength * weight;
+                else if (edit.mode === "lower")
+                    offsets[index] -= strength * weight;
+                else {
+                    const current = base.sampleHeight(wx, wz) + offsets[index];
+                    offsets[index] += (target - current) * weight * strength;
+                }
+                changed += 1;
+            }
+        }
+        return changed;
+    }
+    function paintSurface(edit) {
+        const surface = edit.surface ?? null;
+        const rCells = Math.ceil(edit.radius / cellSize) + 1;
+        const cx = gridX(edit.center[0]);
+        const cz = gridZ(edit.center[1]);
+        let painted = 0;
+        for (let iz = -rCells; iz <= rCells; iz += 1) {
+            const gz = Math.floor(cz) + iz;
+            if (gz < 0 || gz >= rows)
+                continue;
+            for (let ix = -rCells; ix <= rCells; ix += 1) {
+                const gx = Math.floor(cx) + ix;
+                if (gx < 0 || gx >= cols)
+                    continue;
+                const wx = bounds.minX + ((gx + 0.5) / cols) * spanX;
+                const wz = bounds.minZ + ((gz + 0.5) / rows) * spanZ;
+                if (Math.hypot(wx - edit.center[0], wz - edit.center[1]) > edit.radius)
+                    continue;
+                surfaces[gz * cols + gx] = surface;
+                painted += 1;
+            }
+        }
+        return painted;
+    }
+    function surfaceAt(x, z) {
+        const gx = Math.floor(gridX(x));
+        const gz = Math.floor(gridZ(z));
+        if (gx < 0 || gx >= cols || gz < 0 || gz >= rows)
+            return null;
+        return surfaces[gz * cols + gx] ?? null;
+    }
+    const field = {
+        sampleHeight,
+        sampleNormal,
+        ...(base.bounds === undefined ? {} : { bounds: base.bounds }),
+        ...(base.waterLevel === undefined ? {} : { waterLevel: base.waterLevel }),
+        apply(edit) {
+            return edit.mode === "paint" ? paintSurface(edit) : editHeight(edit);
+        },
+        heightOffsetAt,
+        surfaceAt,
+        reset() {
+            offsets.fill(0);
+            surfaces.fill(null);
+        },
+        snapshot() {
+            return {
+                bounds: { ...bounds },
+                cellSize,
+                cols,
+                rows,
+                offsets: Array.from(offsets),
+                surfaces: surfaces.slice(),
+            };
+        },
+        restore(snapshot) {
+            const count = Math.min(offsets.length, snapshot.offsets.length);
+            for (let index = 0; index < count; index += 1)
+                offsets[index] = snapshot.offsets[index];
+            const surfaceCount = Math.min(surfaces.length, snapshot.surfaces.length);
+            for (let index = 0; index < surfaceCount; index += 1)
+                surfaces[index] = snapshot.surfaces[index] ?? null;
+        },
+    };
+    return field;
+}
+export function createTerraformBrush(terrain, config = {}) {
+    let radius = config.radius ?? 3;
+    let strength = config.strength ?? 0.5;
+    const falloff = config.falloff ?? "smooth";
+    const surface = config.surface;
+    return {
+        raise(center) {
+            return terrain.apply({ mode: "raise", center, radius, strength, falloff });
+        },
+        lower(center) {
+            return terrain.apply({ mode: "lower", center, radius, strength, falloff });
+        },
+        flatten(center, target) {
+            return terrain.apply({ mode: "flatten", center, radius, strength, falloff, ...(target === undefined ? {} : { target }) });
+        },
+        paint(center, paintSurface) {
+            const chosen = paintSurface ?? surface;
+            return terrain.apply({ mode: "paint", center, radius, ...(chosen === undefined ? {} : { surface: chosen }) });
+        },
+        setRadius(next) {
+            radius = next;
+        },
+        setStrength(next) {
+            strength = next;
+        },
+        config() {
+            return { radius, strength, falloff, surface };
+        },
+    };
+}

package/dist/world/terrain.d.ts

@@ -0,0 +1,54 @@
+import type { TerrainEnvironmentDescriptor, WorldBounds } from "./features.js";
+export type TerrainNormal = readonly [number, number, number];
+export interface TerrainField {
+    sampleHeight(x: number, z: number): number;
+    sampleNormal(x: number, z: number): TerrainNormal;
+    readonly bounds?: WorldBounds;
+    readonly waterLevel?: number;
+}
+export declare function valueNoise(x: number, z: number, seed: number): number;
+export interface FractalNoiseConfig {
+    seed: number;
+    frequency: number;
+    octaves: number;
+    lacunarity: number;
+    persistence: number;
+    ridged: boolean;
+}
+export declare function fractalNoise(x: number, z: number, config: FractalNoiseConfig): number;
+export declare function seedFrom(value: string | number | undefined, fallback: number): number;
+export declare function withNormal(sampleHeight: (x: number, z: number) => number): TerrainField["sampleNormal"];
+export declare const FLAT_FIELD: TerrainField;
+export declare function flatField(): TerrainField;
+export interface NoiseFieldConfig {
+    seed?: string | number;
+    amplitude?: number;
+    frequency?: number;
+    octaves?: number;
+    lacunarity?: number;
+    persistence?: number;
+    baseHeight?: number;
+    ridged?: boolean;
+    bounds?: WorldBounds;
+    waterLevel?: number;
+}
+export declare function noiseField(config?: NoiseFieldConfig): TerrainField;
+export interface RollingFieldConfig {
+    seed?: string | number;
+    amplitude?: number;
+    frequency?: number;
+    bounds?: WorldBounds;
+}
+export declare function rollingField(config?: RollingFieldConfig): TerrainField;
+export interface ArenaFieldConfig {
+    seed?: string | number;
+    bounds?: WorldBounds;
+}
+export declare const ARENA_WATER_LEVEL = -0.9;
+export declare function arenaField(config?: ArenaFieldConfig): TerrainField;
+export declare function resolveTerrainField(descriptor?: TerrainEnvironmentDescriptor): TerrainField;
+export declare const DEFAULT_MAX_WALK_SLOPE = 0.6;
+export declare function resolveGroundStep(field: TerrainField, x: number, z: number, stepX: number, stepZ: number, maxSlope?: number): {
+    stepX: number;
+    stepZ: number;
+};

package/dist/world/terrain.js

@@ -0,0 +1,181 @@
+function clamp01(value) {
+    return value < 0 ? 0 : value > 1 ? 1 : value;
+}
+function lerp(a, b, t) {
+    return a + (b - a) * t;
+}
+function hash2(ix, iz, seed) {
+    let h = seed | 0;
+    h = Math.imul(h ^ (ix | 0), 0x27d4eb2d);
+    h = Math.imul(h ^ (iz | 0), 0x85ebca6b);
+    h ^= h >>> 15;
+    h = Math.imul(h, 0x2c1b3c6d);
+    h ^= h >>> 12;
+    return (h >>> 0) / 4294967295;
+}
+export function valueNoise(x, z, seed) {
+    const x0 = Math.floor(x);
+    const z0 = Math.floor(z);
+    const fx = x - x0;
+    const fz = z - z0;
+    const v00 = hash2(x0, z0, seed);
+    const v10 = hash2(x0 + 1, z0, seed);
+    const v01 = hash2(x0, z0 + 1, seed);
+    const v11 = hash2(x0 + 1, z0 + 1, seed);
+    const sx = fx * fx * (3 - 2 * fx);
+    const sz = fz * fz * (3 - 2 * fz);
+    const top = lerp(v00, v10, sx);
+    const bottom = lerp(v01, v11, sx);
+    return lerp(top, bottom, sz) * 2 - 1;
+}
+export function fractalNoise(x, z, config) {
+    let amplitude = 1;
+    let frequency = config.frequency;
+    let sum = 0;
+    let norm = 0;
+    for (let octave = 0; octave < config.octaves; octave += 1) {
+        let sample = valueNoise(x * frequency, z * frequency, config.seed + octave * 1013);
+        if (config.ridged)
+            sample = 1 - 2 * Math.abs(sample);
+        sum += sample * amplitude;
+        norm += amplitude;
+        amplitude *= config.persistence;
+        frequency *= config.lacunarity;
+    }
+    return norm === 0 ? 0 : sum / norm;
+}
+export function seedFrom(value, fallback) {
+    if (typeof value === "number")
+        return value | 0;
+    if (typeof value === "string") {
+        let hash = 2166136261;
+        for (let index = 0; index < value.length; index += 1) {
+            hash ^= value.charCodeAt(index);
+            hash = Math.imul(hash, 16777619);
+        }
+        return hash | 0;
+    }
+    return fallback;
+}
+export function withNormal(sampleHeight) {
+    const epsilon = 0.75;
+    return (x, z) => {
+        const hx = sampleHeight(x + epsilon, z) - sampleHeight(x - epsilon, z);
+        const hz = sampleHeight(x, z + epsilon) - sampleHeight(x, z - epsilon);
+        const nx = -hx;
+        const nz = -hz;
+        const ny = 2 * epsilon;
+        const length = Math.hypot(nx, ny, nz) || 1;
+        return [nx / length, ny / length, nz / length];
+    };
+}
+function fieldFromHeight(sampleHeight, extra) {
+    return {
+        sampleHeight,
+        sampleNormal: withNormal(sampleHeight),
+        ...(extra?.bounds === undefined ? {} : { bounds: extra.bounds }),
+        ...(extra?.waterLevel === undefined ? {} : { waterLevel: extra.waterLevel }),
+    };
+}
+export const FLAT_FIELD = {
+    sampleHeight: () => 0,
+    sampleNormal: () => [0, 1, 0],
+};
+export function flatField() {
+    return FLAT_FIELD;
+}
+export function noiseField(config = {}) {
+    const fractal = {
+        seed: seedFrom(config.seed, 1337),
+        frequency: config.frequency ?? 0.03,
+        octaves: config.octaves ?? 4,
+        lacunarity: config.lacunarity ?? 2,
+        persistence: config.persistence ?? 0.5,
+        ridged: config.ridged ?? false,
+    };
+    const amplitude = config.amplitude ?? 1;
+    const baseHeight = config.baseHeight ?? 0;
+    return fieldFromHeight((x, z) => baseHeight + amplitude * fractalNoise(x, z, fractal), {
+        bounds: config.bounds,
+        waterLevel: config.waterLevel,
+    });
+}
+export function rollingField(config = {}) {
+    return noiseField({
+        seed: config.seed ?? "rolling",
+        amplitude: config.amplitude ?? 0.55,
+        frequency: config.frequency ?? 0.03,
+        octaves: 3,
+        persistence: 0.55,
+        bounds: config.bounds,
+    });
+}
+const ARENA_PLATEAU_HEIGHT = 6;
+const ARENA_HILL_HEIGHT = 4.2;
+const ARENA_BASIN_DEPTH = 2.6;
+export const ARENA_WATER_LEVEL = -0.9;
+function smoothstep(edge0, edge1, value) {
+    if (edge0 === edge1)
+        return value < edge0 ? 0 : 1;
+    const t = clamp01((value - edge0) / (edge1 - edge0));
+    return t * t * (3 - 2 * t);
+}
+export function arenaField(config = {}) {
+    const seed = seedFrom(config.seed ?? "arena", 7);
+    const rolling = {
+        seed,
+        frequency: 0.03,
+        octaves: 3,
+        lacunarity: 2,
+        persistence: 0.5,
+        ridged: false,
+    };
+    const sampleHeight = (x, z) => {
+        const distToSpawn = Math.hypot(x, z);
+        const spawn = 1 - smoothstep(14, 24, distToSpawn);
+        const undulation = 0.55 * fractalNoise(x, z, rolling);
+        const cliff = smoothstep(20, 27, z);
+        const ramp = smoothstep(16, 46, z);
+        const inRamp = 1 - clamp01(Math.abs(x) / 6);
+        const plateauExtent = 1 - smoothstep(30, 42, Math.abs(x));
+        const mesa = ARENA_PLATEAU_HEIGHT * plateauExtent * lerp(cliff, ramp, inRamp);
+        const hillDist = Math.hypot(x - 34, z + 8) / 18;
+        const hillFalloff = smoothstep(0, 1, 1 - hillDist);
+        const hill = ARENA_HILL_HEIGHT * hillFalloff;
+        const basinDist = Math.hypot(x + 40, z + 20) / 20;
+        const basin = -ARENA_BASIN_DEPTH * smoothstep(0, 1, 1 - basinDist);
+        return (undulation + mesa + hill + basin) * (1 - spawn);
+    };
+    return fieldFromHeight(sampleHeight, { bounds: config.bounds, waterLevel: ARENA_WATER_LEVEL });
+}
+export function resolveTerrainField(descriptor) {
+    if (descriptor === undefined)
+        return flatField();
+    return noiseField({
+        seed: descriptor.seed,
+        amplitude: descriptor.height,
+        frequency: descriptor.frequency,
+        octaves: descriptor.octaves,
+        ridged: descriptor.ridged,
+        baseHeight: descriptor.baseHeight,
+        waterLevel: descriptor.waterLevel,
+        bounds: descriptor.bounds,
+    });
+}
+export const DEFAULT_MAX_WALK_SLOPE = 0.6;
+export function resolveGroundStep(field, x, z, stepX, stepZ, maxSlope = DEFAULT_MAX_WALK_SLOPE) {
+    const baseHeight = field.sampleHeight(x, z);
+    const tooSteep = (dx, dz) => {
+        const distance = Math.hypot(dx, dz);
+        if (distance < 1e-6)
+            return false;
+        const rise = field.sampleHeight(x + dx, z + dz) - baseHeight;
+        return rise / distance > maxSlope;
+    };
+    if (!tooSteep(stepX, stepZ))
+        return { stepX, stepZ };
+    return {
+        stepX: tooSteep(stepX, 0) ? 0 : stepX,
+        stepZ: tooSteep(0, stepZ) ? 0 : stepZ,
+    };
+}