@jgengine/core 0.4.0 → 0.6.0

package/dist/world/regions.js

@@ -0,0 +1,158 @@
+import { fractalNoise, withNormal, } from "./terrain.js";
+function toRgb(color, fallback) {
+    if (color === undefined)
+        return fallback;
+    if (typeof color !== "string")
+        return color;
+    const value = color.startsWith("#") ? color.slice(1) : color;
+    const int = Number.parseInt(value, 16);
+    return [((int >> 16) & 255) / 255, ((int >> 8) & 255) / 255, (int & 255) / 255];
+}
+function clamp01(value) {
+    return value < 0 ? 0 : value > 1 ? 1 : value;
+}
+function selectorNoise(x, z, seed, frequency) {
+    const config = { seed, frequency, octaves: 3, lacunarity: 2, persistence: 0.5, ridged: false };
+    return clamp01(0.5 + fractalNoise(x, z, config) * 0.9);
+}
+const DEFAULT_SELECTOR_FREQUENCY = 0.004;
+const DEFAULT_SHARPNESS = 6;
+export function createRegionField(config) {
+    if (config.regions.length === 0)
+        throw new Error("createRegionField: regions must be non-empty");
+    const seed = config.seed ?? 1337;
+    const regions = config.regions;
+    const seaLevel = config.seaLevel ?? 0;
+    const axes = regions[0].selector.length;
+    const sharpness = config.sharpness ?? DEFAULT_SHARPNESS;
+    const warp = config.warp ?? 40;
+    const heightConfigs = regions.map((region) => ({
+        seed: seed ^ hashId(region.id),
+        frequency: region.height.frequency,
+        octaves: region.height.octaves ?? 4,
+        lacunarity: region.height.lacunarity ?? 2,
+        persistence: region.height.persistence ?? 0.5,
+        ridged: region.height.ridged ?? false,
+    }));
+    const tints = regions.map((region) => toRgb(region.tint, [0.4, 0.42, 0.38]));
+    const steeps = regions.map((region, index) => toRgb(region.steepTint, tints[index]));
+    const waters = regions.map((region) => (region.water !== undefined ? toRgb(region.water, [0, 0, 0]) : null));
+    const fogs = regions.map((region) => (region.fog !== undefined ? toRgb(region.fog, [0, 0, 0]) : null));
+    const axisSeeds = Array.from({ length: axes }, (_, axis) => seed ^ (0x1111 * (axis + 1)));
+    const axisFrequencies = Array.from({ length: axes }, (_, axis) => config.selectorFrequencies?.[axis] ?? DEFAULT_SELECTOR_FREQUENCY);
+    const axisWeights = Array.from({ length: axes }, (_, axis) => config.axisWeights?.[axis] ?? 1);
+    const warpConfig = { seed: seed ^ 0x9e3779b1, frequency: 0.006, octaves: 2, lacunarity: 2, persistence: 0.5, ridged: false };
+    const sampleSelector = (x, z) => {
+        const wx = warp === 0 ? x : x + fractalNoise(x, z, warpConfig) * warp;
+        const wz = warp === 0 ? z : z + fractalNoise(z, x, warpConfig) * warp;
+        const values = new Array(axes);
+        for (let axis = 0; axis < axes; axis += 1) {
+            values[axis] = selectorNoise(wx, wz, axisSeeds[axis], axisFrequencies[axis]);
+        }
+        return values;
+    };
+    const weightsFor = (selector) => {
+        const raw = new Array(regions.length);
+        let total = 0;
+        for (let index = 0; index < regions.length; index += 1) {
+            const center = regions[index].selector;
+            let distanceSq = 0;
+            for (let axis = 0; axis < axes; axis += 1) {
+                const delta = (selector[axis] - center[axis]) * axisWeights[axis];
+                distanceSq += delta * delta;
+            }
+            const weight = Math.exp(-distanceSq * sharpness * regions.length);
+            raw[index] = weight;
+            total += weight;
+        }
+        if (total > 0)
+            for (let index = 0; index < raw.length; index += 1)
+                raw[index] /= total;
+        return raw;
+    };
+    const regionHeight = (index, x, z) => regions[index].height.baseHeight + regions[index].height.amplitude * fractalNoise(x, z, heightConfigs[index]);
+    const sampleHeight = (x, z) => {
+        const weights = weightsFor(sampleSelector(x, z));
+        let height = 0;
+        for (let index = 0; index < weights.length; index += 1) {
+            if (weights[index] < 0.01)
+                continue;
+            height += weights[index] * regionHeight(index, x, z);
+        }
+        return height;
+    };
+    const sampleRegion = (x, z) => {
+        const selector = sampleSelector(x, z);
+        const weights = weightsFor(selector);
+        let dominant = 0;
+        const tint = [0, 0, 0];
+        const steep = [0, 0, 0];
+        const water = [0, 0, 0];
+        let waterWeight = 0;
+        const fog = [0, 0, 0];
+        let fogWeight = 0;
+        let fogDensity = 0;
+        let speed = 0;
+        let speedWeight = 0;
+        for (let index = 0; index < weights.length; index += 1) {
+            const weight = weights[index];
+            if (weight > weights[dominant])
+                dominant = index;
+            if (weight < 0.01)
+                continue;
+            for (let channel = 0; channel < 3; channel += 1) {
+                tint[channel] += tints[index][channel] * weight;
+                steep[channel] += steeps[index][channel] * weight;
+            }
+            const w = waters[index];
+            if (w !== null) {
+                for (let channel = 0; channel < 3; channel += 1)
+                    water[channel] += w[channel] * weight;
+                waterWeight += weight;
+            }
+            const f = fogs[index];
+            if (f !== null) {
+                for (let channel = 0; channel < 3; channel += 1)
+                    fog[channel] += f[channel] * weight;
+                fogWeight += weight;
+                fogDensity += (regions[index].fogDensity ?? 0) * weight;
+            }
+            speed += (regions[index].speedMultiplier ?? 1) * weight;
+            speedWeight += weight;
+        }
+        const normalize = (rgb, weight) => weight > 0 ? [rgb[0] / weight, rgb[1] / weight, rgb[2] / weight] : rgb;
+        return {
+            region: regions[dominant],
+            weight: weights[dominant],
+            selector,
+            tint,
+            steepTint: steep,
+            water: waterWeight > 0.05 ? normalize(water, waterWeight) : null,
+            fog: fogWeight > 0.05 ? normalize(fog, fogWeight) : null,
+            fogDensity: fogWeight > 0.05 ? fogDensity / fogWeight : 0,
+            speedMultiplier: speedWeight > 0 ? speed / speedWeight : 1,
+            data: regions[dominant].data,
+        };
+    };
+    return {
+        sampleHeight,
+        sampleNormal: withNormal(sampleHeight),
+        sampleRegion,
+        regions,
+        seaLevel,
+        seed,
+        waterLevel: seaLevel,
+        bounds: config.bounds,
+    };
+}
+function hashId(id) {
+    let hash = 2166136261;
+    for (let index = 0; index < id.length; index += 1) {
+        hash ^= id.charCodeAt(index);
+        hash = Math.imul(hash, 16777619);
+    }
+    return hash | 0;
+}
+export function isRegionField(field) {
+    return "sampleRegion" in field;
+}

package/dist/world/scatter.d.ts

@@ -0,0 +1,24 @@
+import { type Aabb, type Vec2 } from "./geometry.js";
+export interface ScatterArea {
+    w: number;
+    d: number;
+    center?: Vec2;
+}
+export interface ScatterConfig {
+    area: ScatterArea | Aabb;
+    count?: number;
+    density?: number;
+    seed?: string | number;
+    minDistance?: number;
+    avoid?: readonly Aabb[];
+    avoidMargin?: number;
+    jitter?: number;
+    maxAttempts?: number;
+}
+export interface ScatterPoint {
+    x: number;
+    z: number;
+    index: number;
+}
+export declare function scatterAabb(area: ScatterArea | Aabb): Aabb;
+export declare function scatter(config: ScatterConfig): ScatterPoint[];

package/dist/world/scatter.js

@@ -0,0 +1,126 @@
+import { expandAabb, pointInAabb } from "./geometry.js";
+function isAabb(area) {
+    return (typeof area.minX === "number" &&
+        typeof area.minZ === "number" &&
+        typeof area.maxX === "number" &&
+        typeof area.maxZ === "number");
+}
+export function scatterAabb(area) {
+    if (isAabb(area)) {
+        return { minX: area.minX, minZ: area.minZ, maxX: area.maxX, maxZ: area.maxZ };
+    }
+    const cx = area.center ? area.center[0] : 0;
+    const cz = area.center ? area.center[1] : 0;
+    const halfW = area.w / 2;
+    const halfD = area.d / 2;
+    return { minX: cx - halfW, minZ: cz - halfD, maxX: cx + halfW, maxZ: cz + halfD };
+}
+function hashSeed(seed) {
+    const text = typeof seed === "number" ? seed.toString() : seed;
+    let h = 2166136261 >>> 0;
+    for (let i = 0; i < text.length; i++) {
+        h ^= text.charCodeAt(i);
+        h = Math.imul(h, 16777619);
+    }
+    return h >>> 0;
+}
+function mulberry32(state) {
+    let a = state >>> 0;
+    return () => {
+        a = (a + 0x6d2b79f5) >>> 0;
+        let t = a;
+        t = Math.imul(t ^ (t >>> 15), t | 1);
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+export function scatter(config) {
+    const aabb = scatterAabb(config.area);
+    const width = aabb.maxX - aabb.minX;
+    const depth = aabb.maxZ - aabb.minZ;
+    const density = config.density ?? 0.01;
+    const target = config.count ?? Math.max(0, Math.floor(width * depth * density));
+    if (target <= 0 || width <= 0 || depth <= 0)
+        return [];
+    const minDistance = config.minDistance ?? 0;
+    const avoidMargin = config.avoidMargin ?? 0;
+    const jitter = config.jitter ?? 1;
+    const maxAttempts = config.maxAttempts ?? target * 30;
+    const avoid = (config.avoid ?? []).map((a) => (avoidMargin !== 0 ? expandAabb(a, avoidMargin) : a));
+    const rng = mulberry32(hashSeed(config.seed ?? "scatter"));
+    const useDistance = minDistance > 0;
+    const buckets = new Map();
+    const bucketKey = (x, z) => `${Math.floor(x / minDistance)}:${Math.floor(z / minDistance)}`;
+    const rejectedByAvoid = (point) => {
+        for (const a of avoid)
+            if (pointInAabb(point, a))
+                return true;
+        return false;
+    };
+    const rejectedByDistance = (point) => {
+        if (!useDistance)
+            return false;
+        const cx = Math.floor(point[0] / minDistance);
+        const cz = Math.floor(point[1] / minDistance);
+        const minSq = minDistance * minDistance;
+        for (let dx = -1; dx <= 1; dx++) {
+            for (let dz = -1; dz <= 1; dz++) {
+                const nearby = buckets.get(`${cx + dx}:${cz + dz}`);
+                if (!nearby)
+                    continue;
+                for (const other of nearby) {
+                    const ex = other[0] - point[0];
+                    const ez = other[1] - point[1];
+                    if (ex * ex + ez * ez < minSq)
+                        return true;
+                }
+            }
+        }
+        return false;
+    };
+    const accepted = [];
+    const commit = (point) => {
+        accepted.push({ x: point[0], z: point[1], index: accepted.length });
+        if (useDistance) {
+            const key = bucketKey(point[0], point[1]);
+            const bucket = buckets.get(key);
+            if (bucket)
+                bucket.push(point);
+            else
+                buckets.set(key, [point]);
+        }
+    };
+    const cols = Math.max(1, Math.ceil(Math.sqrt(target * (width / depth))));
+    const rows = Math.max(1, Math.ceil(target / cols));
+    const cellW = width / cols;
+    const cellD = depth / rows;
+    for (let row = 0; row < rows && accepted.length < target; row++) {
+        for (let col = 0; col < cols && accepted.length < target; col++) {
+            const baseX = aabb.minX + (col + 0.5) * cellW;
+            const baseZ = aabb.minZ + (row + 0.5) * cellD;
+            const x = baseX + jitter * (rng() - 0.5) * cellW;
+            const z = baseZ + jitter * (rng() - 0.5) * cellD;
+            const point = [x, z];
+            if (!pointInAabb(point, aabb))
+                continue;
+            if (rejectedByAvoid(point))
+                continue;
+            if (rejectedByDistance(point))
+                continue;
+            commit(point);
+        }
+    }
+    let attempts = 0;
+    while (accepted.length < target && attempts < maxAttempts) {
+        attempts++;
+        const x = aabb.minX + rng() * width;
+        const z = aabb.minZ + rng() * depth;
+        const point = [x, z];
+        if (rejectedByAvoid(point))
+            continue;
+        if (rejectedByDistance(point))
+            continue;
+        commit(point);
+    }
+    return accepted;
+}

package/dist/world/scatterItems.d.ts

@@ -0,0 +1,38 @@
+import type { Aabb } from "./geometry.js";
+import type { RegionField, RegionSample } from "./regions.js";
+/** One placeable class. `item` is an opaque id the caller maps to a mesh/entity. */
+export interface ScatterLayer {
+    item: string;
+    density: number;
+    minScale?: number;
+    maxScale?: number;
+    maxSlope?: number;
+    aboveWaterOnly?: boolean;
+}
+export interface ScatterInstance {
+    id: string;
+    item: string;
+    x: number;
+    z: number;
+    y: number;
+    scale: number;
+    rotation: number;
+    regionId: string;
+}
+/**
+ * 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 declare function scatterItems<T>(field: RegionField<T>, area: Aabb, layersFor: (sample: RegionSample<T>) => readonly ScatterLayer[], options?: {
+    cell?: number;
+    max?: number;
+    saltKey?: number;
+}): ScatterInstance[];
+/** Weighted pick from opaque entries; `roll` in [0, 1). Returns null when empty. */
+export declare function pickWeighted<T>(entries: readonly {
+    value: T;
+    weight: number;
+}[], roll: number): T | null;

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