@jgengine/core 0.5.0 → 0.7.0

package/dist/world/carve.js

@@ -0,0 +1,175 @@
+import { withNormal } from "./terrain.js";
+export const EMPTY_VOXEL = 0;
+/**
+ * A runtime-editable dense voxel grid — the carve/deposit op behind destructible dig worlds (Deep
+ * Rock Galactic tunnels, Astroneer terrain). Cells hold a material id (0 = empty); `carve` clears a
+ * sphere of solid cells that a tool is strong enough to break and returns how many it removed (feed
+ * that to a loot roll), `deposit` fills a sphere with a material. World↔cell mapping is `origin`+`scale`.
+ */
+export class VoxelVolume {
+    nx;
+    ny;
+    nz;
+    scale;
+    origin;
+    cells;
+    materials;
+    solidCount = 0;
+    constructor(config) {
+        this.nx = Math.max(1, Math.floor(config.dims[0]));
+        this.ny = Math.max(1, Math.floor(config.dims[1]));
+        this.nz = Math.max(1, Math.floor(config.dims[2]));
+        this.scale = config.scale ?? 1;
+        this.origin = config.origin ?? [0, 0, 0];
+        this.materials = config.materials ?? {};
+        this.cells = new Uint16Array(this.nx * this.ny * this.nz);
+        const fill = config.fill ?? 1;
+        if (fill !== EMPTY_VOXEL) {
+            this.cells.fill(fill);
+            this.solidCount = this.cells.length;
+        }
+    }
+    get solid() {
+        return this.solidCount;
+    }
+    index(ix, iy, iz) {
+        return (iz * this.ny + iy) * this.nx + ix;
+    }
+    inBounds(ix, iy, iz) {
+        return ix >= 0 && ix < this.nx && iy >= 0 && iy < this.ny && iz >= 0 && iz < this.nz;
+    }
+    get(ix, iy, iz) {
+        if (!this.inBounds(ix, iy, iz))
+            return EMPTY_VOXEL;
+        return this.cells[this.index(ix, iy, iz)];
+    }
+    set(ix, iy, iz, material) {
+        if (!this.inBounds(ix, iy, iz))
+            return;
+        const at = this.index(ix, iy, iz);
+        const prev = this.cells[at];
+        if (prev === material)
+            return;
+        if (prev === EMPTY_VOXEL)
+            this.solidCount += 1;
+        else if (material === EMPTY_VOXEL)
+            this.solidCount -= 1;
+        this.cells[at] = material;
+    }
+    worldToCell(x, y, z) {
+        return [
+            Math.floor((x - this.origin[0]) / this.scale),
+            Math.floor((y - this.origin[1]) / this.scale),
+            Math.floor((z - this.origin[2]) / this.scale),
+        ];
+    }
+    solidAtWorld(x, y, z) {
+        const [ix, iy, iz] = this.worldToCell(x, y, z);
+        return this.get(ix, iy, iz) !== EMPTY_VOXEL;
+    }
+    strengthOf(material) {
+        return this.materials[material]?.strength ?? 0;
+    }
+    forEachCellInSphere(center, radius, visit) {
+        const s = this.scale;
+        const [cx, cy, cz] = this.worldToCell(center[0], center[1], center[2]);
+        const reach = Math.ceil(radius / s) + 1;
+        const r2 = radius * radius;
+        for (let iz = cz - reach; iz <= cz + reach; iz += 1) {
+            for (let iy = cy - reach; iy <= cy + reach; iy += 1) {
+                for (let ix = cx - reach; ix <= cx + reach; ix += 1) {
+                    if (!this.inBounds(ix, iy, iz))
+                        continue;
+                    const wx = this.origin[0] + (ix + 0.5) * s;
+                    const wy = this.origin[1] + (iy + 0.5) * s;
+                    const wz = this.origin[2] + (iz + 0.5) * s;
+                    const dx = wx - center[0];
+                    const dy = wy - center[1];
+                    const dz = wz - center[2];
+                    if (dx * dx + dy * dy + dz * dz <= r2)
+                        visit(ix, iy, iz);
+                }
+            }
+        }
+    }
+    /** Clear every solid cell in the sphere the tool can break; returns the number removed. */
+    carve(op) {
+        const tool = op.toolStrength ?? Number.POSITIVE_INFINITY;
+        let removed = 0;
+        this.forEachCellInSphere(op.center, op.radius, (ix, iy, iz) => {
+            const m = this.get(ix, iy, iz);
+            if (m === EMPTY_VOXEL)
+                return;
+            if (this.strengthOf(m) > tool)
+                return;
+            this.set(ix, iy, iz, EMPTY_VOXEL);
+            removed += 1;
+        });
+        return removed;
+    }
+    /** Fill every empty cell in the sphere with `material`; returns the number filled. */
+    deposit(op) {
+        let filled = 0;
+        this.forEachCellInSphere(op.center, op.radius, (ix, iy, iz) => {
+            if (this.get(ix, iy, iz) !== EMPTY_VOXEL)
+                return;
+            this.set(ix, iy, iz, op.material);
+            filled += 1;
+        });
+        return filled;
+    }
+}
+function bowl(t) {
+    const s = t * t * (3 - 2 * t);
+    return s;
+}
+/**
+ * A `TerrainField` you can write craters and mounds into at runtime — the height-field side of
+ * destructible terrain (Helldivers 2 explosion craters, engineer-deposited berms). Wraps a base field
+ * and layers smooth radial deformations on top, so `sampleHeight` (and therefore ground-snap,
+ * collision, and the shell's terrain mesh) all read the deformed surface. `carve` digs a bowl,
+ * `deposit` raises a mound.
+ */
+export class CarvableField {
+    bounds;
+    waterLevel;
+    sampleNormal;
+    base;
+    edits = [];
+    constructor(base) {
+        this.base = base;
+        if (base.bounds !== undefined)
+            this.bounds = base.bounds;
+        if (base.waterLevel !== undefined)
+            this.waterLevel = base.waterLevel;
+        this.sampleNormal = withNormal((x, z) => this.sampleHeight(x, z));
+    }
+    get editCount() {
+        return this.edits.length;
+    }
+    sampleHeight(x, z) {
+        let h = this.base.sampleHeight(x, z);
+        for (let i = 0; i < this.edits.length; i += 1) {
+            const e = this.edits[i];
+            const dx = x - e.x;
+            const dz = z - e.z;
+            const d = Math.sqrt(dx * dx + dz * dz);
+            if (d >= e.radius)
+                continue;
+            h += e.delta * bowl(1 - d / e.radius);
+        }
+        return h;
+    }
+    carve(op) {
+        this.edits.push({ x: op.x, z: op.z, radius: op.radius, delta: -op.depth });
+    }
+    deposit(op) {
+        this.edits.push({ x: op.x, z: op.z, radius: op.radius, delta: op.height });
+    }
+    clear() {
+        this.edits.length = 0;
+    }
+}
+export function carvableTerrain(base) {
+    return new CarvableField(base);
+}

package/dist/world/connectors.d.ts

@@ -0,0 +1,40 @@
+export type ConnectorVec3 = readonly [number, number, number];
+export interface ConnectorSocket {
+    id: string;
+    type: string;
+    offset: ConnectorVec3;
+    accepts?: readonly string[];
+}
+export interface ConnectorPieceDef {
+    kind: string;
+    sockets: readonly ConnectorSocket[];
+}
+export interface PlacedPiece {
+    id: string;
+    kind: string;
+    position: ConnectorVec3;
+    rotationY: number;
+}
+export interface WorldSocket {
+    pieceId: string;
+    socket: ConnectorSocket;
+    position: ConnectorVec3;
+}
+export interface SnapResult {
+    socketId: string;
+    targetPieceId: string;
+    targetSocketId: string;
+    position: ConnectorVec3;
+    rotationY: number;
+    distance: number;
+}
+export interface SnapOptions {
+    snapDistance?: number;
+    rotationY?: number;
+}
+export declare function socketsCompatible(a: ConnectorSocket, b: ConnectorSocket): boolean;
+export declare function socketWorldPosition(socket: ConnectorSocket, origin: ConnectorVec3, rotationY: number): ConnectorVec3;
+export declare function worldSockets(def: ConnectorPieceDef, piece: PlacedPiece): WorldSocket[];
+export type ConnectorRegistry = (kind: string) => ConnectorPieceDef | null;
+export declare function collectWorldSockets(registry: ConnectorRegistry, pieces: readonly PlacedPiece[]): WorldSocket[];
+export declare function snapToNearest(registry: ConnectorRegistry, placed: readonly PlacedPiece[], movingDef: ConnectorPieceDef, cursor: ConnectorVec3, options?: SnapOptions): SnapResult | null;

package/dist/world/connectors.js

@@ -0,0 +1,67 @@
+export function socketsCompatible(a, b) {
+    const aAccepts = a.accepts ?? [a.type];
+    const bAccepts = b.accepts ?? [b.type];
+    return aAccepts.includes(b.type) && bAccepts.includes(a.type);
+}
+function rotateY(offset, rotationY) {
+    if (rotationY === 0)
+        return offset;
+    const cos = Math.cos(rotationY);
+    const sin = Math.sin(rotationY);
+    return [offset[0] * cos + offset[2] * sin, offset[1], -offset[0] * sin + offset[2] * cos];
+}
+export function socketWorldPosition(socket, origin, rotationY) {
+    const rotated = rotateY(socket.offset, rotationY);
+    return [origin[0] + rotated[0], origin[1] + rotated[1], origin[2] + rotated[2]];
+}
+export function worldSockets(def, piece) {
+    return def.sockets.map((socket) => ({
+        pieceId: piece.id,
+        socket,
+        position: socketWorldPosition(socket, piece.position, piece.rotationY),
+    }));
+}
+export function collectWorldSockets(registry, pieces) {
+    const out = [];
+    for (const piece of pieces) {
+        const def = registry(piece.kind);
+        if (def === null)
+            continue;
+        for (const world of worldSockets(def, piece))
+            out.push(world);
+    }
+    return out;
+}
+export function snapToNearest(registry, placed, movingDef, cursor, options = {}) {
+    const snapDistance = options.snapDistance ?? 1.5;
+    const rotationY = options.rotationY ?? 0;
+    const targets = collectWorldSockets(registry, placed);
+    let best = null;
+    for (const socket of movingDef.sockets) {
+        const socketWorld = socketWorldPosition(socket, cursor, rotationY);
+        for (const target of targets) {
+            if (!socketsCompatible(socket, target.socket))
+                continue;
+            const distance = Math.hypot(socketWorld[0] - target.position[0], socketWorld[1] - target.position[1], socketWorld[2] - target.position[2]);
+            if (distance > snapDistance)
+                continue;
+            if (best !== null && distance >= best.distance)
+                continue;
+            const localRotated = rotateY(socket.offset, rotationY);
+            const position = [
+                target.position[0] - localRotated[0],
+                target.position[1] - localRotated[1],
+                target.position[2] - localRotated[2],
+            ];
+            best = {
+                socketId: socket.id,
+                targetPieceId: target.pieceId,
+                targetSocketId: target.socket.id,
+                position,
+                rotationY,
+                distance,
+            };
+        }
+    }
+    return best;
+}

package/dist/world/envField.d.ts

@@ -0,0 +1,71 @@
+import type { TerrainField } from "./terrain.js";
+/** A sky-occluding footprint — a roof, dense canopy, a cave mouth. `shade` 0..1 = fraction of sky blocked. */
+export interface OccluderRect {
+    x: number;
+    z: number;
+    w: number;
+    d: number;
+    shade?: number;
+}
+/** A localized warmth source — campfire, forge, geothermal vent. */
+export interface HeatSource {
+    x: number;
+    z: number;
+    radius: number;
+    /** Degrees added at the center, falling to 0 at `radius`. */
+    strength: number;
+}
+export type ShadeProvider = readonly OccluderRect[] | ((x: number, z: number) => number);
+export type ScalarField = number | ((x: number, z: number, time: number) => number);
+export interface EnvironmentFieldConfig {
+    /** Game-seconds per day; drives the sun-elevation cycle. Default matches the sim clock day. */
+    dayLength?: number;
+    /** Temperature at sea level under a noon sun with no weather. Default 20. */
+    baseTemperature?: number;
+    /** Degrees colder at deep night vs noon. Default 12. */
+    nightDrop?: number;
+    /** Degrees lost per world-height unit above `seaLevel` (altitude lapse). Default 0. */
+    altitudeLapse?: number;
+    seaLevel?: number;
+    /** Terrain field used to look up ground altitude when a caller omits `y`. */
+    terrain?: TerrainField;
+    /** Rain/precipitation intensity 0..1 at a position — from a weather state. Default 0. */
+    rain?: ScalarField;
+    /** Sky occluders (structures, canopy) that block sun and shelter from rain. */
+    occluders?: ShadeProvider;
+    /** Campfires and other warmth emitters. */
+    heatSources?: readonly HeatSource[];
+    /** Minimum ambient light at night (moonlight floor), 0..1. Default 0.05. */
+    ambientFloor?: number;
+    /** Per-position base-temperature offset (biome map). Added to `baseTemperature`. */
+    temperatureAt?: (x: number, z: number) => number;
+}
+export interface EnvironmentSample {
+    /** Degrees (game units). */
+    temperature: number;
+    /** 0..1 surface wetness. */
+    wetness: number;
+    /** 0..1 direct sun/sky exposure — full sun open sky = 1, deep shade/night = 0. */
+    lightExposure: number;
+    /** 0..1 overall light level for spawn gating — includes ambient/moonlight. */
+    ambientLight: number;
+    /** Under an occluder (roof/canopy) enough to shelter from rain. */
+    sheltered: boolean;
+}
+export interface EnvironmentField {
+    sample(x: number, z: number, time: number, y?: number): EnvironmentSample;
+    temperature(x: number, z: number, time: number, y?: number): number;
+    wetness(x: number, z: number, time: number): number;
+    lightExposure(x: number, z: number, time: number): number;
+    ambientLight(x: number, z: number, time: number): number;
+    /** Sun elevation -1..1 (1 = noon overhead, 0 = horizon, negative = night). */
+    sunElevation(time: number): number;
+}
+/**
+ * A sampleable environment field: read temperature, wetness, sun/sky exposure, and
+ * ambient light at any world position and time. Built on the same renderer-free footing
+ * as terrain/wind/water so meters, spawn gating, and damage-in-sunlight read the world
+ * the shell renders — no three.js. Instantaneous and pure (no accumulation); stateful
+ * build-up belongs to a decay meter reading this field.
+ */
+export declare function createEnvironmentField(config?: EnvironmentFieldConfig): EnvironmentField;

package/dist/world/envField.js

@@ -0,0 +1,96 @@
+import { SECONDS_PER_GAME_DAY } from "../time/gameClock.js";
+function clamp01(value) {
+    return value < 0 ? 0 : value > 1 ? 1 : value;
+}
+function resolveScalar(field, x, z, time) {
+    return typeof field === "function" ? field(x, z, time) : field;
+}
+function pointInRect(rect, x, z) {
+    return (x >= rect.x - rect.w / 2 &&
+        x <= rect.x + rect.w / 2 &&
+        z >= rect.z - rect.d / 2 &&
+        z <= rect.z + rect.d / 2);
+}
+function resolveShade(provider, x, z) {
+    if (provider === undefined)
+        return 0;
+    if (typeof provider === "function")
+        return clamp01(provider(x, z));
+    let shade = 0;
+    for (const rect of provider) {
+        if (pointInRect(rect, x, z))
+            shade = Math.max(shade, rect.shade ?? 1);
+    }
+    return shade;
+}
+/**
+ * A sampleable environment field: read temperature, wetness, sun/sky exposure, and
+ * ambient light at any world position and time. Built on the same renderer-free footing
+ * as terrain/wind/water so meters, spawn gating, and damage-in-sunlight read the world
+ * the shell renders — no three.js. Instantaneous and pure (no accumulation); stateful
+ * build-up belongs to a decay meter reading this field.
+ */
+export function createEnvironmentField(config = {}) {
+    const dayLength = config.dayLength !== undefined && config.dayLength > 0 ? config.dayLength : SECONDS_PER_GAME_DAY;
+    const baseTemperature = config.baseTemperature ?? 20;
+    const nightDrop = config.nightDrop ?? 12;
+    const altitudeLapse = config.altitudeLapse ?? 0;
+    const seaLevel = config.seaLevel ?? 0;
+    const ambientFloor = clamp01(config.ambientFloor ?? 0.05);
+    const heatSources = config.heatSources ?? [];
+    const sunElevation = (time) => {
+        const dayFraction = ((time % dayLength) + dayLength) % dayLength / dayLength;
+        return Math.sin((dayFraction - 0.25) * 2 * Math.PI);
+    };
+    const heatAt = (x, z) => {
+        let heat = 0;
+        for (const source of heatSources) {
+            const distance = Math.hypot(x - source.x, z - source.z);
+            if (distance >= source.radius)
+                continue;
+            heat += source.strength * (1 - distance / source.radius);
+        }
+        return heat;
+    };
+    const rainAt = (x, z, time) => config.rain === undefined ? 0 : clamp01(resolveScalar(config.rain, x, z, time));
+    const wetness = (x, z, time) => {
+        const shade = resolveShade(config.occluders, x, z);
+        return clamp01(rainAt(x, z, time) * (1 - shade));
+    };
+    const lightExposure = (x, z, time) => {
+        const shade = resolveShade(config.occluders, x, z);
+        const daylight = Math.max(0, sunElevation(time));
+        const cloud = 1 - rainAt(x, z, time) * 0.6;
+        return clamp01(daylight * cloud * (1 - shade));
+    };
+    const ambientLight = (x, z, time) => {
+        const shade = resolveShade(config.occluders, x, z);
+        const daylight = clamp01(sunElevation(time) * 0.5 + 0.5);
+        const sky = ambientFloor + (1 - ambientFloor) * daylight;
+        return clamp01(sky * (1 - shade * 0.75));
+    };
+    const temperature = (x, z, time, y) => {
+        const altitude = y ?? config.terrain?.sampleHeight(x, z) ?? seaLevel;
+        const daylight = clamp01(sunElevation(time) * 0.5 + 0.5);
+        const base = baseTemperature + (config.temperatureAt?.(x, z) ?? 0);
+        const lapse = altitudeLapse * Math.max(0, altitude - seaLevel);
+        const wetChill = wetness(x, z, time) * 4;
+        return base - nightDrop * (1 - daylight) - lapse - wetChill + heatAt(x, z);
+    };
+    return {
+        sample(x, z, time, y) {
+            return {
+                temperature: temperature(x, z, time, y),
+                wetness: wetness(x, z, time),
+                lightExposure: lightExposure(x, z, time),
+                ambientLight: ambientLight(x, z, time),
+                sheltered: resolveShade(config.occluders, x, z) >= 0.5,
+            };
+        },
+        temperature,
+        wetness,
+        lightExposure,
+        ambientLight,
+        sunElevation,
+    };
+}

package/dist/world/features.d.ts

@@ -2,6 +2,103 @@ export interface WorldBounds {
     w: number;
     d: number;
 }
+export type EnvironmentVec2 = readonly [number, number];
+export interface EnvironmentArea extends WorldBounds {
+    h?: number;
+}
+export interface TerrainEnvironmentConfig {
+    bounds?: WorldBounds;
+    height?: number;
+    heightMap?: string;
+    material?: string;
+    seed?: string;
+    frequency?: number;
+    octaves?: number;
+    ridged?: boolean;
+    baseHeight?: number;
+    waterLevel?: number;
+}
+export interface RainEnvironmentConfig {
+    area?: EnvironmentArea;
+    density?: number;
+    speed?: number;
+    dropLength?: number;
+    wind?: EnvironmentVec2;
+    color?: string;
+}
+export interface SnowEnvironmentConfig {
+    area?: EnvironmentArea;
+    density?: number;
+    speed?: number;
+    flakeSize?: number;
+    drift?: number;
+    wind?: EnvironmentVec2;
+    color?: string;
+}
+export interface GrassEnvironmentConfig {
+    area?: WorldBounds;
+    density?: number;
+    bladeHeight?: readonly [number, number];
+    bladeWidth?: number;
+    windStrength?: number;
+    colors?: readonly string[];
+    seed?: string;
+}
+export interface OceanEnvironmentConfig {
+    bounds?: WorldBounds;
+    level?: number;
+    waveHeight?: number;
+    waveScale?: number;
+    waveSpeed?: number;
+    color?: string;
+}
+export interface BuildingEnvironmentConfig {
+    count?: number;
+    footprint?: WorldBounds;
+    stories?: readonly [number, number];
+    storyHeight?: number;
+    spacing?: number;
+    style?: string;
+    seed?: string;
+}
+export type TerrainEnvironmentDescriptor = {
+    kind: "terrain";
+} & Required<Pick<TerrainEnvironmentConfig, "bounds" | "height">> & Omit<TerrainEnvironmentConfig, "bounds" | "height">;
+export type RainEnvironmentDescriptor = {
+    kind: "rain";
+} & Required<Pick<RainEnvironmentConfig, "area" | "density" | "speed" | "dropLength" | "wind" | "color">>;
+export type SnowEnvironmentDescriptor = {
+    kind: "snow";
+} & Required<Pick<SnowEnvironmentConfig, "area" | "density" | "speed" | "flakeSize" | "drift" | "wind" | "color">>;
+export type GrassEnvironmentDescriptor = {
+    kind: "grass";
+} & Required<Pick<GrassEnvironmentConfig, "area" | "density" | "bladeHeight" | "bladeWidth" | "windStrength" | "colors">> & Pick<GrassEnvironmentConfig, "seed">;
+export type OceanEnvironmentDescriptor = {
+    kind: "ocean";
+} & Required<Pick<OceanEnvironmentConfig, "bounds" | "level" | "waveHeight" | "waveScale" | "waveSpeed" | "color">>;
+export type BuildingEnvironmentDescriptor = {
+    kind: "building";
+} & Required<Pick<BuildingEnvironmentConfig, "count" | "footprint" | "stories" | "storyHeight" | "spacing" | "style">> & Pick<BuildingEnvironmentConfig, "seed">;
+export type WeatherEnvironmentDescriptor = RainEnvironmentDescriptor | SnowEnvironmentDescriptor;
+export type VegetationEnvironmentDescriptor = GrassEnvironmentDescriptor;
+export type WaterEnvironmentDescriptor = OceanEnvironmentDescriptor;
+export type StructureEnvironmentDescriptor = BuildingEnvironmentDescriptor;
+export type EnvironmentDescriptorList<T> = T | readonly T[];
+export interface EnvironmentWorldConfig {
+    terrain?: TerrainEnvironmentDescriptor;
+    weather?: EnvironmentDescriptorList<WeatherEnvironmentDescriptor>;
+    vegetation?: EnvironmentDescriptorList<VegetationEnvironmentDescriptor>;
+    water?: EnvironmentDescriptorList<WaterEnvironmentDescriptor>;
+    structures?: EnvironmentDescriptorList<StructureEnvironmentDescriptor>;
+}
+export interface EnvironmentWorldFeature {
+    kind: "environment";
+    terrain?: TerrainEnvironmentDescriptor;
+    weather?: readonly WeatherEnvironmentDescriptor[];
+    vegetation?: readonly VegetationEnvironmentDescriptor[];
+    water?: readonly WaterEnvironmentDescriptor[];
+    structures?: readonly StructureEnvironmentDescriptor[];
+}
 export interface BiomesWorldConfig {
     map: string;
     zones: string;
@@ -29,9 +126,16 @@ export type WorldFeature = ({
     kind: "plots";
 } & PlotsWorldConfig) | ({
     kind: "tilemap";
-} & TilemapWorldConfig) | {
+} & TilemapWorldConfig) | EnvironmentWorldFeature | {
     kind: "flat";
 };
+export declare function environment(config?: EnvironmentWorldConfig): EnvironmentWorldFeature;
+export declare function terrain(config?: TerrainEnvironmentConfig): TerrainEnvironmentDescriptor;
+export declare function rain(config?: RainEnvironmentConfig): RainEnvironmentDescriptor;
+export declare function snow(config?: SnowEnvironmentConfig): SnowEnvironmentDescriptor;
+export declare function grass(config?: GrassEnvironmentConfig): GrassEnvironmentDescriptor;
+export declare function ocean(config?: OceanEnvironmentConfig): OceanEnvironmentDescriptor;
+export declare function building(config?: BuildingEnvironmentConfig): BuildingEnvironmentDescriptor;
 export declare function biomes(config: BiomesWorldConfig): WorldFeature;
 export declare function voxel(config: VoxelWorldConfig): WorldFeature;
 export declare function plots(config?: PlotsWorldConfig): WorldFeature;

package/dist/world/features.js

@@ -1,3 +1,98 @@
+function list(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    return Array.isArray(value) ? value : [value];
+}
+function withOptional(base, optional) {
+    return optional === undefined ? base : { ...base, ...optional };
+}
+export function environment(config = {}) {
+    const weather = list(config.weather);
+    const vegetation = list(config.vegetation);
+    const water = list(config.water);
+    const structures = list(config.structures);
+    return {
+        kind: "environment",
+        ...(config.terrain === undefined ? {} : { terrain: config.terrain }),
+        ...(weather === undefined ? {} : { weather }),
+        ...(vegetation === undefined ? {} : { vegetation }),
+        ...(water === undefined ? {} : { water }),
+        ...(structures === undefined ? {} : { structures }),
+    };
+}
+export function terrain(config = {}) {
+    return withOptional({
+        kind: "terrain",
+        bounds: config.bounds ?? { w: 512, d: 512 },
+        height: config.height ?? 0,
+    }, {
+        ...(config.heightMap === undefined ? {} : { heightMap: config.heightMap }),
+        ...(config.material === undefined ? {} : { material: config.material }),
+        ...(config.seed === undefined ? {} : { seed: config.seed }),
+        ...(config.frequency === undefined ? {} : { frequency: config.frequency }),
+        ...(config.octaves === undefined ? {} : { octaves: config.octaves }),
+        ...(config.ridged === undefined ? {} : { ridged: config.ridged }),
+        ...(config.baseHeight === undefined ? {} : { baseHeight: config.baseHeight }),
+        ...(config.waterLevel === undefined ? {} : { waterLevel: config.waterLevel }),
+    });
+}
+export function rain(config = {}) {
+    return {
+        kind: "rain",
+        area: config.area ?? { w: 256, d: 256, h: 80 },
+        density: config.density ?? 0.65,
+        speed: config.speed ?? 18,
+        dropLength: config.dropLength ?? 0.8,
+        wind: config.wind ?? [0, 0],
+        color: config.color ?? "#9ec8ff",
+    };
+}
+export function snow(config = {}) {
+    return {
+        kind: "snow",
+        area: config.area ?? { w: 256, d: 256, h: 80 },
+        density: config.density ?? 0.35,
+        speed: config.speed ?? 2.4,
+        flakeSize: config.flakeSize ?? 0.08,
+        drift: config.drift ?? 0.4,
+        wind: config.wind ?? [0, 0],
+        color: config.color ?? "#ffffff",
+    };
+}
+export function grass(config = {}) {
+    return withOptional({
+        kind: "grass",
+        area: config.area ?? { w: 128, d: 128 },
+        density: config.density ?? 4,
+        bladeHeight: config.bladeHeight ?? [0.25, 0.9],
+        bladeWidth: config.bladeWidth ?? 0.035,
+        windStrength: config.windStrength ?? 0.35,
+        colors: config.colors ?? ["#3f7d2d", "#66a83f"],
+    }, config.seed === undefined ? undefined : { seed: config.seed });
+}
+export function ocean(config = {}) {
+    return {
+        kind: "ocean",
+        bounds: config.bounds ?? { w: 1024, d: 1024 },
+        level: config.level ?? 0,
+        waveHeight: config.waveHeight ?? 1.2,
+        waveScale: config.waveScale ?? 18,
+        waveSpeed: config.waveSpeed ?? 0.55,
+        color: config.color ?? "#1d7fa3",
+    };
+}
+export function building(config = {}) {
+    return withOptional({
+        kind: "building",
+        count: config.count ?? 1,
+        footprint: config.footprint ?? { w: 8, d: 8 },
+        stories: config.stories ?? [1, 4],
+        storyHeight: config.storyHeight ?? 3,
+        spacing: config.spacing ?? 2,
+        style: config.style ?? "generic",
+    }, config.seed === undefined ? undefined : { seed: config.seed });
+}
 export function biomes(config) {
     return { kind: "biomes", ...config };
 }