@v12-engine/engine 0.1.0 → 0.4.0

package/dist/terrain.d.ts

@@ -1,7 +1,13 @@
 import { type Vec2 } from './math';
-/** @beta */
+/**
+ * A triangle mesh of the ground: vertex positions and the triangles' indices
+ *
+ * @beta
+ */
 export interface TerrainMesh {
+    /** Vertex positions as x, y, z triples */
     positions: Float32Array;
+    /** Vertex indices, three to a triangle */
     indices: Uint32Array;
 }
 /**
@@ -10,9 +16,17 @@ export interface TerrainMesh {
  * @beta
  */
 export declare const WATER_NONE = 0;
-/** @beta */
+/**
+ * Water that can be waded through, a `Terrain.water` value
+ *
+ * @beta
+ */
 export declare const WATER_SHALLOW = 1;
-/** @beta */
+/**
+ * Water that nothing on foot crosses, a `Terrain.water` value
+ *
+ * @beta
+ */
 export declare const WATER_DEEP = 2;
 /**
  * Water and paint of a terrain, next to its shape. Left out for plain ground
@@ -31,6 +45,12 @@ export interface TerrainSurface {
     /** The game's own layers of cells (`CellLayerDef`), by id: a value per cell, row by row */
     cells?: Record<string, Uint8Array>;
 }
+/**
+ * Whether one on foot may walk a cell, as the ground's walkable mesh has it (`Terrain.buildMesh(true)`): not deep
+ * water unless a bridge (3) crosses it, nothing that blocks walking (2), and in play. What the navigation's tiles
+ * cut alone are made of too (`RecastNavigation.groundChanged`)
+ */
+export declare function walkedCell(terrain: Terrain, ix: number, iz: number): boolean;
 /**
  * Heightfield ground. World space spans [0, width] x [0, depth] with one height sample per unit.
  * Rendering, navigation and the simulation all read from this same data.
@@ -42,10 +62,15 @@ export interface TerrainSurface {
  * @beta
  */
 export declare class Terrain {
+    /** Cells across the map, east-west */
     readonly width: number;
+    /** Cells along the map, north-south */
     readonly depth: number;
+    /** Height per vertex, row by row, (`width` + 1) by (`depth` + 1) */
     readonly heights: Float32Array;
+    /** Height samples across the map: `width` + 1 */
     readonly vertsX: number;
+    /** Height samples along the map: `depth` + 1 */
     readonly vertsZ: number;
     /** Level per cell, row by row. The fog works out what is seen from them once: `world.fog.levelsChanged()` after writing to them in a running world */
     readonly levels: Uint8Array;
@@ -72,7 +97,13 @@ export declare class Terrain {
         width: number;
         depth: number;
     };
-    constructor(width: number, depth: number, heights: Float32Array, levels?: Uint8Array, surface?: TerrainSurface);
+    constructor(
+    /** Cells across the map, east-west */
+    width: number, 
+    /** Cells along the map, north-south */
+    depth: number, 
+    /** Height per vertex, row by row, (`width` + 1) by (`depth` + 1) */
+    heights: Float32Array, levels?: Uint8Array, surface?: TerrainSurface);
     /** The value of a layer of cells (`cells`) at a point: 0 off the ground, or where the layer is not there */
     cellAt(layer: string, x: number, z: number): number;
     /** A layer of cells, made empty when it is not there yet */
@@ -86,9 +117,11 @@ export declare class Terrain {
     inPlay(cx: number, cz: number): boolean;
     /** `WATER_*` of the cell a point is in */
     waterAt(x: number, z: number): number;
+    /** The height at a vertex, its indices clamped to the map */
     vertexHeight(ix: number, iz: number): number;
     /** Level of the cell a point is in */
     levelAt(x: number, z: number): number;
+    /** Whether a point is inside the map */
     contains(x: number, z: number): boolean;
     /** Height at any point, interpolated over the same triangles `buildMesh` produces. */
     heightAt(x: number, z: number): number;
@@ -106,7 +139,11 @@ export declare class Terrain {
         y: number;
         z: number;
     } | null;
-    /** @param walkable leaves out what nothing on foot may cross, for the navigation */
+    /**
+     * Builds the triangle mesh of the ground; `walkable` leaves out what nothing on foot may cross
+     *
+     * @param walkable leaves out what nothing on foot may cross, for the navigation
+     */
     buildMesh(walkable?: boolean): TerrainMesh;
     /** Whether any cell is deep water: what boats go on */
     get hasDeepWater(): boolean;
@@ -135,17 +172,28 @@ export interface RampSpec {
  * @beta
  */
 export interface PlateauSpec {
+    /** East-west centre of the plateau, in world units */
     x: number;
+    /** North-south centre of the plateau, in world units */
     z: number;
+    /** How far the plateau reaches from its centre, in world units */
     radius: number;
     /** How many levels it rises above what is around it. One when left out */
     levels?: number;
+    /** The ramps that lead up to it; cliffs everywhere else */
     ramps?: RampSpec[];
 }
-/** @beta */
+/**
+ * What `generateTerrain` makes ground from: size, seed, hills, rocks, flats and plateaus
+ *
+ * @beta
+ */
 export interface TerrainGenOptions {
+    /** Cells across the map */
     width: number;
+    /** Cells along the map */
     depth: number;
+    /** Seed for the generator, so the same options make the same ground */
     seed: number;
     /** Height of the rolling hills */
     hillHeight?: number;
@@ -169,5 +217,9 @@ export interface TerrainGenOptions {
     /** How much higher one level stands than the one below */
     cliffHeight?: number;
 }
-/** @beta */
+/**
+ * Makes ground from the options: rolling hills, rocks, flat spots and plateaus, from their seed
+ *
+ * @beta
+ */
 export declare function generateTerrain(options: TerrainGenOptions): Terrain;

package/dist/terrain.js

@@ -0,0 +1,389 @@
+import { atan, atan2, cos, hypot, sin } from "./exactMath.js";
+import { TAU, clamp, smoothstep } from "./math.js";
+import { Rng } from "./rng.js";
+//#region src/terrain.ts
+/**
+* What covers a cell: nothing, water that can be waded through, or water nothing on foot crosses
+*
+* @beta
+*/
+var WATER_NONE = 0;
+/**
+* Water that can be waded through, a `Terrain.water` value
+*
+* @beta
+*/
+var WATER_SHALLOW = 1;
+/**
+* Water that nothing on foot crosses, a `Terrain.water` value
+*
+* @beta
+*/
+var WATER_DEEP = 2;
+/**
+* Whether one on foot may walk a cell, as the ground's walkable mesh has it (`Terrain.buildMesh(true)`): not deep
+* water unless a bridge (3) crosses it, nothing that blocks walking (2), and in play. What the navigation's tiles
+* cut alone are made of too (`RecastNavigation.groundChanged`)
+*/
+function walkedCell(terrain, ix, iz) {
+	const cell = iz * terrain.width + ix;
+	const blocked = terrain.blocked[cell];
+	return !(terrain.water[cell] === 2 && blocked !== 3 || blocked === 2 || !terrain.inPlay(ix, iz));
+}
+/**
+* Heightfield ground. World space spans [0, width] x [0, depth] with one height sample per unit.
+* Rendering, navigation and the simulation all read from this same data.
+*
+* Next to the height, every cell has a level: the ground floor is 0, each cliff up is one more. The height is
+* what things stand on and where the eye sees a cliff, the level is what the rules go by: who sees whom
+* and who shoots uphill. Ramps belong to the lower level until halfway up.
+*
+* @beta
+*/
+var Terrain = class {
+	width;
+	depth;
+	heights;
+	/** Height samples across the map: `width` + 1 */
+	vertsX;
+	/** Height samples along the map: `depth` + 1 */
+	vertsZ;
+	/** Level per cell, row by row. The fog works out what is seen from them once: `world.fog.levelsChanged()` after writing to them in a running world */
+	levels;
+	/** `WATER_*` per cell, row by row */
+	water;
+	/** Height of the surface of the water per vertex */
+	waterHeights;
+	/** Paint per cell, row by row */
+	tiles;
+	/** What scenery keeps off each cell, row by row: 1 building there, 2 walking and building (see `MapDoodad.blocks`) */
+	blocked;
+	/**
+	* The game's own layers of cells, by id (`CellLayerDef`): where the bushes are, what burns. A value per cell, row by
+	* row; a layer nobody has painted is not there, and reads 0 everywhere (`cellAt`)
+	*/
+	cells;
+	/**
+	* The part of the map play happens in, in cells, when it is not all of it (`GameMap.bounds`): nothing on foot goes
+	* outside it, nothing is built there, and the camera keeps to it. The edge beyond is scenery
+	*/
+	bounds;
+	constructor(width, depth, heights, levels, surface = {}) {
+		this.width = width;
+		this.depth = depth;
+		this.heights = heights;
+		this.vertsX = width + 1;
+		this.vertsZ = depth + 1;
+		const cells = width * depth;
+		if (heights.length !== this.vertsX * this.vertsZ) throw new Error("Terrain: heights do not match the size");
+		if (levels && levels.length !== cells) throw new Error("Terrain: levels do not match the size");
+		if (surface.water && surface.water.length !== cells) throw new Error("Terrain: water does not match the size");
+		if (surface.tiles && surface.tiles.length !== cells) throw new Error("Terrain: tiles do not match the size");
+		this.levels = levels ?? new Uint8Array(cells);
+		this.water = surface.water ?? new Uint8Array(cells);
+		this.waterHeights = surface.waterHeights ?? new Float32Array(heights.length);
+		this.tiles = surface.tiles ?? new Uint8Array(cells);
+		if (surface.blocked && surface.blocked.length !== cells) throw new Error("Terrain: what is blocked does not match the size");
+		this.blocked = surface.blocked ?? new Uint8Array(cells);
+		this.cells = {};
+		for (const [id, layer] of Object.entries(surface.cells ?? {})) {
+			if (layer.length !== cells) throw new Error(`Terrain: the cells of ${id} do not match the size`);
+			this.cells[id] = layer;
+		}
+	}
+	/** The value of a layer of cells (`cells`) at a point: 0 off the ground, or where the layer is not there */
+	cellAt(layer, x, z) {
+		const cells = this.cells[layer];
+		if (!cells || x < 0 || z < 0 || x >= this.width || z >= this.depth) return 0;
+		return cells[Math.floor(z) * this.width + Math.floor(x)];
+	}
+	/** A layer of cells, made empty when it is not there yet */
+	cellLayer(layer) {
+		return this.cells[layer] ??= new Uint8Array(this.width * this.depth);
+	}
+	/**
+	* Becomes another terrain, of whatever size, in place: what holds on to this one (the camera, what draws the ground)
+	* sees the new one. For the editor, when a map is resized
+	*/
+	replace(other) {
+		Object.assign(this, {
+			width: other.width,
+			depth: other.depth,
+			vertsX: other.vertsX,
+			vertsZ: other.vertsZ,
+			heights: other.heights,
+			levels: other.levels,
+			water: other.water,
+			waterHeights: other.waterHeights,
+			tiles: other.tiles,
+			blocked: other.blocked,
+			cells: other.cells,
+			bounds: other.bounds
+		});
+	}
+	/** Whether a cell is in the part of the map play happens in (`bounds`) */
+	inPlay(cx, cz) {
+		const { bounds } = this;
+		return !bounds || cx >= bounds.x && cz >= bounds.z && cx < bounds.x + bounds.width && cz < bounds.z + bounds.depth;
+	}
+	/** `WATER_*` of the cell a point is in */
+	waterAt(x, z) {
+		const cx = clamp(Math.floor(x), 0, this.width - 1);
+		const cz = clamp(Math.floor(z), 0, this.depth - 1);
+		return this.water[cz * this.width + cx];
+	}
+	/** The height at a vertex, its indices clamped to the map */
+	vertexHeight(ix, iz) {
+		return this.heights[clamp(iz, 0, this.depth) * this.vertsX + clamp(ix, 0, this.width)];
+	}
+	/** Level of the cell a point is in */
+	levelAt(x, z) {
+		const cx = clamp(Math.floor(x), 0, this.width - 1);
+		const cz = clamp(Math.floor(z), 0, this.depth - 1);
+		return this.levels[cz * this.width + cx];
+	}
+	/** Whether a point is inside the map */
+	contains(x, z) {
+		return x >= 0 && z >= 0 && x <= this.width && z <= this.depth;
+	}
+	/** Height at any point, interpolated over the same triangles `buildMesh` produces. */
+	heightAt(x, z) {
+		x = clamp(x, 0, this.width);
+		z = clamp(z, 0, this.depth);
+		const ix = Math.min(Math.floor(x), this.width - 1);
+		const iz = Math.min(Math.floor(z), this.depth - 1);
+		const fx = x - ix;
+		const fz = z - iz;
+		const i = iz * this.vertsX + ix;
+		const a = this.heights[i];
+		const b = this.heights[i + 1];
+		const c = this.heights[i + this.vertsX];
+		const d = this.heights[i + this.vertsX + 1];
+		if (fx + fz <= 1) return a + (b - a) * fx + (c - a) * fz;
+		return d + (c - d) * (1 - fx) + (b - d) * (1 - fz);
+	}
+	/** Surface normal (unnormalized y is always positive). */
+	normalAt(x, z, out) {
+		const e = .5;
+		const dx = this.heightAt(x + e, z) - this.heightAt(x - e, z);
+		const dz = this.heightAt(x, z + e) - this.heightAt(x, z - e);
+		const len = Math.sqrt(dx * dx + dz * dz + 1);
+		out.x = -dx / len;
+		out.y = 1 / len;
+		out.z = -dz / len;
+	}
+	/** Steepness in radians, 0 = flat. */
+	slopeAt(x, z) {
+		const e = .5;
+		const dx = this.heightAt(x + e, z) - this.heightAt(x - e, z);
+		const dz = this.heightAt(x, z + e) - this.heightAt(x, z - e);
+		return atan(Math.sqrt(dx * dx + dz * dz));
+	}
+	/** First intersection of a ray with the ground, or null. */
+	raycast(ox, oy, oz, dx, dy, dz, maxDist = 500) {
+		const step = .5;
+		let prevT = 0;
+		let prevAbove = oy - this.heightAt(ox, oz) > 0 || !this.contains(ox, oz);
+		for (let t = step; t <= maxDist; t += step) {
+			const x = ox + dx * t;
+			const z = oz + dz * t;
+			const above = !this.contains(x, z) || oy + dy * t > this.heightAt(x, z);
+			if (prevAbove && !above) {
+				let lo = prevT;
+				let hi = t;
+				for (let i = 0; i < 12; i++) {
+					const mid = (lo + hi) / 2;
+					const mx = ox + dx * mid;
+					const mz = oz + dz * mid;
+					if (oy + dy * mid > this.heightAt(mx, mz)) lo = mid;
+					else hi = mid;
+				}
+				const x2 = ox + dx * hi;
+				const z2 = oz + dz * hi;
+				return {
+					x: x2,
+					y: this.heightAt(x2, z2),
+					z: z2
+				};
+			}
+			prevAbove = above;
+			prevT = t;
+		}
+		return null;
+	}
+	/**
+	* Builds the triangle mesh of the ground; `walkable` leaves out what nothing on foot may cross
+	*
+	* @param walkable leaves out what nothing on foot may cross, for the navigation
+	*/
+	buildMesh(walkable = false) {
+		const { vertsX, vertsZ, width, depth } = this;
+		const positions = new Float32Array(vertsX * vertsZ * 3);
+		for (let iz = 0; iz < vertsZ; iz++) for (let ix = 0; ix < vertsX; ix++) {
+			const i = iz * vertsX + ix;
+			positions[i * 3] = ix;
+			positions[i * 3 + 1] = this.heights[i];
+			positions[i * 3 + 2] = iz;
+		}
+		const indices = new Uint32Array(width * depth * 6);
+		let n = 0;
+		for (let iz = 0; iz < depth; iz++) for (let ix = 0; ix < width; ix++) {
+			if (walkable && !walkedCell(this, ix, iz)) continue;
+			const a = iz * vertsX + ix;
+			const b = a + 1;
+			const c = a + vertsX;
+			const d = c + 1;
+			indices[n++] = a;
+			indices[n++] = c;
+			indices[n++] = b;
+			indices[n++] = b;
+			indices[n++] = c;
+			indices[n++] = d;
+		}
+		return {
+			positions,
+			indices: n === indices.length ? indices : indices.slice(0, n)
+		};
+	}
+	/** Whether any cell is deep water: what boats go on */
+	get hasDeepWater() {
+		return this.water.includes(2);
+	}
+	/**
+	* The deep water as a mesh, at its surface: where what goes on water can go (`UnitTypeDef.naval`). Under a bridge
+	* too. Empty where the map has no deep water
+	*/
+	buildWaterMesh() {
+		const { vertsX, vertsZ, width, depth } = this;
+		const positions = new Float32Array(vertsX * vertsZ * 3);
+		for (let iz = 0; iz < vertsZ; iz++) for (let ix = 0; ix < vertsX; ix++) {
+			const i = iz * vertsX + ix;
+			positions[i * 3] = ix;
+			positions[i * 3 + 1] = this.waterHeights[i];
+			positions[i * 3 + 2] = iz;
+		}
+		const indices = [];
+		for (let iz = 0; iz < depth; iz++) for (let ix = 0; ix < width; ix++) {
+			if (this.water[iz * width + ix] !== 2 || !this.inPlay(ix, iz)) continue;
+			const a = iz * vertsX + ix;
+			indices.push(a, a + vertsX, a + 1, a + 1, a + vertsX, a + vertsX + 1);
+		}
+		return {
+			positions,
+			indices: Uint32Array.from(indices)
+		};
+	}
+	/** The height of the water's surface at a point, over the same triangles as the ground */
+	waterHeightAt(x, z) {
+		x = clamp(x, 0, this.width);
+		z = clamp(z, 0, this.depth);
+		const ix = Math.min(Math.floor(x), this.width - 1);
+		const iz = Math.min(Math.floor(z), this.depth - 1);
+		const fx = x - ix;
+		const fz = z - iz;
+		const i = iz * this.vertsX + ix;
+		const a = this.waterHeights[i];
+		const b = this.waterHeights[i + 1];
+		const c = this.waterHeights[i + this.vertsX];
+		const d = this.waterHeights[i + this.vertsX + 1];
+		if (fx + fz <= 1) return a + (b - a) * fx + (c - a) * fz;
+		return d + (c - d) * (1 - fx) + (b - d) * (1 - fz);
+	}
+};
+/** A ramp is this many times as long as it is high. Gentle enough to walk, too steep to build on */
+var RAMP_SLOPE = 2.5;
+var RAMP_WIDTH = 6;
+/**
+* How far up the plateau a point is: 1 on top, 0 below, in between on a ramp.
+* The edge wobbles a little so plateaus are not perfect circles.
+*/
+function plateauShape(plateau, cliffHeight, rng) {
+	const { levels = 1 } = plateau;
+	const length = levels * cliffHeight * RAMP_SLOPE;
+	const wobble = [rng.next() * TAU, rng.next() * TAU];
+	const edgeAt = (angle) => plateau.radius * (1 + .05 * sin(3 * angle + wobble[0]) + .03 * sin(5 * angle + wobble[1]));
+	const ramps = (plateau.ramps ?? []).map((ramp) => {
+		const angle = atan2(ramp.towards.x - plateau.x, ramp.towards.z - plateau.z);
+		return {
+			sin: sin(angle),
+			cos: cos(angle),
+			halfWidth: (ramp.width ?? RAMP_WIDTH) / 2,
+			edge: edgeAt(angle)
+		};
+	});
+	return (x, z) => {
+		const dx = x - plateau.x;
+		const dz = z - plateau.z;
+		for (const ramp of ramps) {
+			const across = Math.abs(dx * ramp.cos - dz * ramp.sin);
+			const along = dx * ramp.sin + dz * ramp.cos;
+			const top = ramp.edge - length / 2;
+			if (across > ramp.halfWidth || along < top) continue;
+			return 1 - smoothstep(0, 1, (along - top) / length);
+		}
+		return hypot(dx, dz) < edgeAt(atan2(dx, dz)) ? 1 : 0;
+	};
+}
+/**
+* Makes ground from the options: rolling hills, rocks, flat spots and plateaus, from their seed
+*
+* @beta
+*/
+function generateTerrain(options) {
+	const { width, depth, seed, hillHeight = 2.5, hillScale = 28, rocks = [], flats = [], plateaus = [], cliffHeight = 3 } = options;
+	const rng = new Rng(seed);
+	const latticeSize = 64;
+	const lattice = /* @__PURE__ */ new Float32Array(4096);
+	for (let i = 0; i < lattice.length; i++) lattice[i] = rng.next();
+	const shapes = plateaus.map((plateau) => ({
+		levels: plateau.levels ?? 1,
+		shape: plateauShape(plateau, cliffHeight, rng)
+	}));
+	const latticeAt = (x, z) => lattice[(z % latticeSize + latticeSize) % latticeSize * latticeSize + (x % latticeSize + latticeSize) % latticeSize];
+	const noise = (x, z) => {
+		const ix = Math.floor(x);
+		const iz = Math.floor(z);
+		const fx = smoothstep(0, 1, x - ix);
+		const fz = smoothstep(0, 1, z - iz);
+		const top = latticeAt(ix, iz) + (latticeAt(ix + 1, iz) - latticeAt(ix, iz)) * fx;
+		return top + (latticeAt(ix, iz + 1) + (latticeAt(ix + 1, iz + 1) - latticeAt(ix, iz + 1)) * fx - top) * fz;
+	};
+	const vertsX = width + 1;
+	const heights = new Float32Array(vertsX * (depth + 1));
+	for (let iz = 0; iz <= depth; iz++) for (let ix = 0; ix <= width; ix++) {
+		let h = 0;
+		let amplitude = 1;
+		let frequency = 1 / hillScale;
+		let total = 0;
+		for (let octave = 0; octave < 3; octave++) {
+			h += noise(ix * frequency, iz * frequency) * amplitude;
+			total += amplitude;
+			amplitude *= .4;
+			frequency *= 2.3;
+		}
+		h = h / total * hillHeight;
+		for (const flat of flats) {
+			const d = hypot(ix - flat.x, iz - flat.z);
+			const flatHeight = hillHeight * .5;
+			const blend = smoothstep(0, 1, (d - flat.radius) / (flat.radius * .6));
+			h = flatHeight + (h - flatHeight) * blend;
+		}
+		for (const { levels, shape } of shapes) h += shape(ix, iz) * levels * cliffHeight;
+		for (const rock of rocks) {
+			const d = hypot(ix - rock.x, iz - rock.z);
+			if (d < rock.radius) h += rock.height * smoothstep(0, 1, 1 - d / rock.radius);
+		}
+		heights[iz * vertsX + ix] = h;
+	}
+	const levels = new Uint8Array(width * depth);
+	if (shapes.length) for (let cz = 0; cz < depth; cz++) for (let cx = 0; cx < width; cx++) {
+		let level = 0;
+		for (const shape of shapes) if (shape.shape(cx + .5, cz + .5) >= .5) level += shape.levels;
+		levels[cz * width + cx] = level;
+	}
+	return new Terrain(width, depth, heights, levels);
+}
+//#endregion
+export { Terrain, WATER_DEEP, WATER_NONE, WATER_SHALLOW, generateTerrain, walkedCell };
+
+//# sourceMappingURL=terrain.js.map

package/dist/terrain.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"terrain.js","names":[],"sources":["../src/terrain.ts"],"sourcesContent":["import { clamp, smoothstep, TAU, type Vec2 } from './math'\nimport { Rng } from './rng'\nimport { atan, atan2, cos, hypot, sin } from './exactMath'\n\n/**\n * A triangle mesh of the ground: vertex positions and the triangles' indices\n *\n * @beta\n */\nexport interface TerrainMesh {\n\t/** Vertex positions as x, y, z triples */\n\tpositions: Float32Array\n\t/** Vertex indices, three to a triangle */\n\tindices: Uint32Array\n}\n\n/**\n * What covers a cell: nothing, water that can be waded through, or water nothing on foot crosses\n *\n * @beta\n */\nexport const WATER_NONE = 0\n/**\n * Water that can be waded through, a `Terrain.water` value\n *\n * @beta\n */\nexport const WATER_SHALLOW = 1\n/**\n * Water that nothing on foot crosses, a `Terrain.water` value\n *\n * @beta\n */\nexport const WATER_DEEP = 2\n\n/**\n * Water and paint of a terrain, next to its shape. Left out for plain ground\n *\n * @beta\n */\nexport interface TerrainSurface {\n\t/** `WATER_*` per cell, row by row */\n\twater?: Uint8Array\n\t/** Height of the surface of the water per vertex, for drawing it. Only means something around wet cells */\n\twaterHeights?: Float32Array\n\t/** What the ground is painted with per cell, row by row. 0 is left to the slope, what the rest are is up to the client */\n\ttiles?: Uint8Array\n\t/** What scenery keeps off each cell (`BLOCKS_BUILD`, `BLOCKS_WALK`), row by row: see `MapDoodad.blocks` */\n\tblocked?: Uint8Array\n\t/** The game's own layers of cells (`CellLayerDef`), by id: a value per cell, row by row */\n\tcells?: Record<string, Uint8Array>\n}\n\n/**\n * Whether one on foot may walk a cell, as the ground's walkable mesh has it (`Terrain.buildMesh(true)`): not deep\n * water unless a bridge (3) crosses it, nothing that blocks walking (2), and in play. What the navigation's tiles\n * cut alone are made of too (`RecastNavigation.groundChanged`)\n */\nexport function walkedCell(terrain: Terrain, ix: number, iz: number): boolean {\n\tconst cell = iz * terrain.width + ix\n\tconst blocked = terrain.blocked[cell]\n\treturn !((terrain.water[cell] === WATER_DEEP && blocked !== 3) || blocked === 2 || !terrain.inPlay(ix, iz))\n}\n\n/**\n * Heightfield ground. World space spans [0, width] x [0, depth] with one height sample per unit.\n * Rendering, navigation and the simulation all read from this same data.\n *\n * Next to the height, every cell has a level: the ground floor is 0, each cliff up is one more. The height is\n * what things stand on and where the eye sees a cliff, the level is what the rules go by: who sees whom\n * and who shoots uphill. Ramps belong to the lower level until halfway up.\n *\n * @beta\n */\nexport class Terrain {\n\t/** Height samples across the map: `width` + 1 */\n\treadonly vertsX: number\n\t/** Height samples along the map: `depth` + 1 */\n\treadonly vertsZ: number\n\t/** Level per cell, row by row. The fog works out what is seen from them once: `world.fog.levelsChanged()` after writing to them in a running world */\n\treadonly levels: Uint8Array\n\t/** `WATER_*` per cell, row by row */\n\treadonly water: Uint8Array\n\t/** Height of the surface of the water per vertex */\n\treadonly waterHeights: Float32Array\n\t/** Paint per cell, row by row */\n\treadonly tiles: Uint8Array\n\t/** What scenery keeps off each cell, row by row: 1 building there, 2 walking and building (see `MapDoodad.blocks`) */\n\treadonly blocked: Uint8Array\n\t/**\n\t * The game's own layers of cells, by id (`CellLayerDef`): where the bushes are, what burns. A value per cell, row by\n\t * row; a layer nobody has painted is not there, and reads 0 everywhere (`cellAt`)\n\t */\n\treadonly cells: Record<string, Uint8Array>\n\t/**\n\t * The part of the map play happens in, in cells, when it is not all of it (`GameMap.bounds`): nothing on foot goes\n\t * outside it, nothing is built there, and the camera keeps to it. The edge beyond is scenery\n\t */\n\tbounds?: { x: number; z: number; width: number; depth: number }\n\n\tconstructor(\n\t\t/** Cells across the map, east-west */\n\t\treadonly width: number,\n\t\t/** Cells along the map, north-south */\n\t\treadonly depth: number,\n\t\t/** Height per vertex, row by row, (`width` + 1) by (`depth` + 1) */\n\t\treadonly heights: Float32Array,\n\t\tlevels?: Uint8Array,\n\t\tsurface: TerrainSurface = {}\n\t) {\n\t\tthis.vertsX = width + 1\n\t\tthis.vertsZ = depth + 1\n\t\tconst cells = width * depth\n\t\tif (heights.length !== this.vertsX * this.vertsZ) throw new Error('Terrain: heights do not match the size')\n\t\tif (levels && levels.length !== cells) throw new Error('Terrain: levels do not match the size')\n\t\tif (surface.water && surface.water.length !== cells) throw new Error('Terrain: water does not match the size')\n\t\tif (surface.tiles && surface.tiles.length !== cells) throw new Error('Terrain: tiles do not match the size')\n\t\tthis.levels = levels ?? new Uint8Array(cells)\n\t\tthis.water = surface.water ?? new Uint8Array(cells)\n\t\tthis.waterHeights = surface.waterHeights ?? new Float32Array(heights.length)\n\t\tthis.tiles = surface.tiles ?? new Uint8Array(cells)\n\t\tif (surface.blocked && surface.blocked.length !== cells) throw new Error('Terrain: what is blocked does not match the size')\n\t\tthis.blocked = surface.blocked ?? new Uint8Array(cells)\n\t\tthis.cells = {}\n\t\tfor (const [id, layer] of Object.entries(surface.cells ?? {})) {\n\t\t\tif (layer.length !== cells) throw new Error(`Terrain: the cells of ${id} do not match the size`)\n\t\t\tthis.cells[id] = layer\n\t\t}\n\t}\n\n\t/** The value of a layer of cells (`cells`) at a point: 0 off the ground, or where the layer is not there */\n\tcellAt(layer: string, x: number, z: number): number {\n\t\tconst cells = this.cells[layer]\n\t\tif (!cells || x < 0 || z < 0 || x >= this.width || z >= this.depth) return 0\n\t\treturn cells[Math.floor(z) * this.width + Math.floor(x)]\n\t}\n\n\t/** A layer of cells, made empty when it is not there yet */\n\tcellLayer(layer: string): Uint8Array {\n\t\treturn (this.cells[layer] ??= new Uint8Array(this.width * this.depth))\n\t}\n\n\t/**\n\t * Becomes another terrain, of whatever size, in place: what holds on to this one (the camera, what draws the ground)\n\t * sees the new one. For the editor, when a map is resized\n\t */\n\treplace(other: Terrain): void {\n\t\tObject.assign(this, {\n\t\t\twidth: other.width,\n\t\t\tdepth: other.depth,\n\t\t\tvertsX: other.vertsX,\n\t\t\tvertsZ: other.vertsZ,\n\t\t\theights: other.heights,\n\t\t\tlevels: other.levels,\n\t\t\twater: other.water,\n\t\t\twaterHeights: other.waterHeights,\n\t\t\ttiles: other.tiles,\n\t\t\tblocked: other.blocked,\n\t\t\tcells: other.cells,\n\t\t\tbounds: other.bounds\n\t\t})\n\t}\n\n\t/** Whether a cell is in the part of the map play happens in (`bounds`) */\n\tinPlay(cx: number, cz: number): boolean {\n\t\tconst { bounds } = this\n\t\treturn !bounds || (cx >= bounds.x && cz >= bounds.z && cx < bounds.x + bounds.width && cz < bounds.z + bounds.depth)\n\t}\n\n\t/** `WATER_*` of the cell a point is in */\n\twaterAt(x: number, z: number): number {\n\t\tconst cx = clamp(Math.floor(x), 0, this.width - 1)\n\t\tconst cz = clamp(Math.floor(z), 0, this.depth - 1)\n\t\treturn this.water[cz * this.width + cx]\n\t}\n\n\t/** The height at a vertex, its indices clamped to the map */\n\tvertexHeight(ix: number, iz: number): number {\n\t\treturn this.heights[clamp(iz, 0, this.depth) * this.vertsX + clamp(ix, 0, this.width)]\n\t}\n\n\t/** Level of the cell a point is in */\n\tlevelAt(x: number, z: number): number {\n\t\tconst cx = clamp(Math.floor(x), 0, this.width - 1)\n\t\tconst cz = clamp(Math.floor(z), 0, this.depth - 1)\n\t\treturn this.levels[cz * this.width + cx]\n\t}\n\n\t/** Whether a point is inside the map */\n\tcontains(x: number, z: number): boolean {\n\t\treturn x >= 0 && z >= 0 && x <= this.width && z <= this.depth\n\t}\n\n\t/** Height at any point, interpolated over the same triangles `buildMesh` produces. */\n\theightAt(x: number, z: number): number {\n\t\tx = clamp(x, 0, this.width)\n\t\tz = clamp(z, 0, this.depth)\n\t\tconst ix = Math.min(Math.floor(x), this.width - 1)\n\t\tconst iz = Math.min(Math.floor(z), this.depth - 1)\n\t\tconst fx = x - ix\n\t\tconst fz = z - iz\n\t\tconst i = iz * this.vertsX + ix\n\t\tconst a = this.heights[i]\n\t\tconst b = this.heights[i + 1]\n\t\tconst c = this.heights[i + this.vertsX]\n\t\tconst d = this.heights[i + this.vertsX + 1]\n\t\tif (fx + fz <= 1) return a + (b - a) * fx + (c - a) * fz\n\t\treturn d + (c - d) * (1 - fx) + (b - d) * (1 - fz)\n\t}\n\n\t/** Surface normal (unnormalized y is always positive). */\n\tnormalAt(x: number, z: number, out: { x: number; y: number; z: number }): void {\n\t\tconst e = 0.5\n\t\tconst dx = this.heightAt(x + e, z) - this.heightAt(x - e, z)\n\t\tconst dz = this.heightAt(x, z + e) - this.heightAt(x, z - e)\n\t\tconst len = Math.sqrt(dx * dx + dz * dz + 1)\n\t\tout.x = -dx / len\n\t\tout.y = 1 / len\n\t\tout.z = -dz / len\n\t}\n\n\t/** Steepness in radians, 0 = flat. */\n\tslopeAt(x: number, z: number): number {\n\t\tconst e = 0.5\n\t\tconst dx = this.heightAt(x + e, z) - this.heightAt(x - e, z)\n\t\tconst dz = this.heightAt(x, z + e) - this.heightAt(x, z - e)\n\t\treturn atan(Math.sqrt(dx * dx + dz * dz))\n\t}\n\n\t/** First intersection of a ray with the ground, or null. */\n\traycast(ox: number, oy: number, oz: number, dx: number, dy: number, dz: number, maxDist = 500): { x: number; y: number; z: number } | null {\n\t\tconst step = 0.5\n\t\tlet prevT = 0\n\t\tlet prevAbove = oy - this.heightAt(ox, oz) > 0 || !this.contains(ox, oz)\n\t\tfor (let t = step; t <= maxDist; t += step) {\n\t\t\tconst x = ox + dx * t\n\t\t\tconst z = oz + dz * t\n\t\t\tconst inside = this.contains(x, z)\n\t\t\tconst above = !inside || oy + dy * t > this.heightAt(x, z)\n\t\t\tif (prevAbove && !above) {\n\t\t\t\t// crossed the surface between prevT and t\n\t\t\t\tlet lo = prevT\n\t\t\t\tlet hi = t\n\t\t\t\tfor (let i = 0; i < 12; i++) {\n\t\t\t\t\tconst mid = (lo + hi) / 2\n\t\t\t\t\tconst mx = ox + dx * mid\n\t\t\t\t\tconst mz = oz + dz * mid\n\t\t\t\t\tif (oy + dy * mid > this.heightAt(mx, mz)) lo = mid\n\t\t\t\t\telse hi = mid\n\t\t\t\t}\n\t\t\t\tconst x2 = ox + dx * hi\n\t\t\t\tconst z2 = oz + dz * hi\n\t\t\t\treturn { x: x2, y: this.heightAt(x2, z2), z: z2 }\n\t\t\t}\n\t\t\tprevAbove = above\n\t\t\tprevT = t\n\t\t}\n\t\treturn null\n\t}\n\n\t/**\n\t * Builds the triangle mesh of the ground; `walkable` leaves out what nothing on foot may cross\n\t *\n\t * @param walkable leaves out what nothing on foot may cross, for the navigation\n\t */\n\tbuildMesh(walkable = false): TerrainMesh {\n\t\tconst { vertsX, vertsZ, width, depth } = this\n\t\tconst positions = new Float32Array(vertsX * vertsZ * 3)\n\t\tfor (let iz = 0; iz < vertsZ; iz++) {\n\t\t\tfor (let ix = 0; ix < vertsX; ix++) {\n\t\t\t\tconst i = iz * vertsX + ix\n\t\t\t\tpositions[i * 3] = ix\n\t\t\t\tpositions[i * 3 + 1] = this.heights[i]\n\t\t\t\tpositions[i * 3 + 2] = iz\n\t\t\t}\n\t\t}\n\t\tconst indices = new Uint32Array(width * depth * 6)\n\t\tlet n = 0\n\t\tfor (let iz = 0; iz < depth; iz++) {\n\t\t\tfor (let ix = 0; ix < width; ix++) {\n\t\t\t\tif (walkable && !walkedCell(this, ix, iz)) continue\n\t\t\t\tconst a = iz * vertsX + ix\n\t\t\t\tconst b = a + 1\n\t\t\t\tconst c = a + vertsX\n\t\t\t\tconst d = c + 1\n\t\t\t\tindices[n++] = a\n\t\t\t\tindices[n++] = c\n\t\t\t\tindices[n++] = b\n\t\t\t\tindices[n++] = b\n\t\t\t\tindices[n++] = c\n\t\t\t\tindices[n++] = d\n\t\t\t}\n\t\t}\n\t\treturn { positions, indices: n === indices.length ? indices : indices.slice(0, n) }\n\t}\n\n\t/** Whether any cell is deep water: what boats go on */\n\tget hasDeepWater(): boolean {\n\t\treturn this.water.includes(WATER_DEEP)\n\t}\n\n\t/**\n\t * The deep water as a mesh, at its surface: where what goes on water can go (`UnitTypeDef.naval`). Under a bridge\n\t * too. Empty where the map has no deep water\n\t */\n\tbuildWaterMesh(): TerrainMesh {\n\t\tconst { vertsX, vertsZ, width, depth } = this\n\t\tconst positions = new Float32Array(vertsX * vertsZ * 3)\n\t\tfor (let iz = 0; iz < vertsZ; iz++) {\n\t\t\tfor (let ix = 0; ix < vertsX; ix++) {\n\t\t\t\tconst i = iz * vertsX + ix\n\t\t\t\tpositions[i * 3] = ix\n\t\t\t\tpositions[i * 3 + 1] = this.waterHeights[i]\n\t\t\t\tpositions[i * 3 + 2] = iz\n\t\t\t}\n\t\t}\n\t\tconst indices: number[] = []\n\t\tfor (let iz = 0; iz < depth; iz++) {\n\t\t\tfor (let ix = 0; ix < width; ix++) {\n\t\t\t\tif (this.water[iz * width + ix] !== WATER_DEEP || !this.inPlay(ix, iz)) continue\n\t\t\t\tconst a = iz * vertsX + ix\n\t\t\t\tindices.push(a, a + vertsX, a + 1, a + 1, a + vertsX, a + vertsX + 1)\n\t\t\t}\n\t\t}\n\t\treturn { positions, indices: Uint32Array.from(indices) }\n\t}\n\n\t/** The height of the water's surface at a point, over the same triangles as the ground */\n\twaterHeightAt(x: number, z: number): number {\n\t\tx = clamp(x, 0, this.width)\n\t\tz = clamp(z, 0, this.depth)\n\t\tconst ix = Math.min(Math.floor(x), this.width - 1)\n\t\tconst iz = Math.min(Math.floor(z), this.depth - 1)\n\t\tconst fx = x - ix\n\t\tconst fz = z - iz\n\t\tconst i = iz * this.vertsX + ix\n\t\tconst a = this.waterHeights[i]\n\t\tconst b = this.waterHeights[i + 1]\n\t\tconst c = this.waterHeights[i + this.vertsX]\n\t\tconst d = this.waterHeights[i + this.vertsX + 1]\n\t\tif (fx + fz <= 1) return a + (b - a) * fx + (c - a) * fz\n\t\treturn d + (c - d) * (1 - fx) + (b - d) * (1 - fz)\n\t}\n}\n\n/**\n * A way up a plateau\n *\n * @beta\n */\nexport interface RampSpec {\n\t/** The ramp comes down on the side of the plateau that faces this point */\n\ttowards: Vec2\n\t/** How wide it is, in world units */\n\twidth?: number\n}\n\n/**\n * High ground: a roughly round area lifted by whole levels, with cliffs all around except where a ramp leads up\n *\n * @beta\n */\nexport interface PlateauSpec {\n\t/** East-west centre of the plateau, in world units */\n\tx: number\n\t/** North-south centre of the plateau, in world units */\n\tz: number\n\t/** How far the plateau reaches from its centre, in world units */\n\tradius: number\n\t/** How many levels it rises above what is around it. One when left out */\n\tlevels?: number\n\t/** The ramps that lead up to it; cliffs everywhere else */\n\tramps?: RampSpec[]\n}\n\n/**\n * What `generateTerrain` makes ground from: size, seed, hills, rocks, flats and plateaus\n *\n * @beta\n */\nexport interface TerrainGenOptions {\n\t/** Cells across the map */\n\twidth: number\n\t/** Cells along the map */\n\tdepth: number\n\t/** Seed for the generator, so the same options make the same ground */\n\tseed: number\n\t/** Height of the rolling hills */\n\thillHeight?: number\n\t/** Size of the hills in world units */\n\thillScale?: number\n\t/** Steep unwalkable rock formations */\n\trocks?: { x: number; z: number; radius: number; height: number }[]\n\t/** Areas levelled to a constant height, for bases */\n\tflats?: { x: number; z: number; radius: number }[]\n\t/** High ground with cliffs and ramps */\n\tplateaus?: PlateauSpec[]\n\t/** How much higher one level stands than the one below */\n\tcliffHeight?: number\n}\n\n/** A ramp is this many times as long as it is high. Gentle enough to walk, too steep to build on */\nconst RAMP_SLOPE = 2.5\nconst RAMP_WIDTH = 6\n\n/**\n * How far up the plateau a point is: 1 on top, 0 below, in between on a ramp.\n * The edge wobbles a little so plateaus are not perfect circles.\n */\nfunction plateauShape(plateau: PlateauSpec, cliffHeight: number, rng: Rng): (x: number, z: number) => number {\n\tconst { levels = 1 } = plateau\n\tconst length = levels * cliffHeight * RAMP_SLOPE\n\tconst wobble = [rng.next() * TAU, rng.next() * TAU]\n\tconst edgeAt = (angle: number) => plateau.radius * (1 + 0.05 * sin(3 * angle + wobble[0]) + 0.03 * sin(5 * angle + wobble[1]))\n\tconst ramps = (plateau.ramps ?? []).map((ramp) => {\n\t\tconst angle = atan2(ramp.towards.x - plateau.x, ramp.towards.z - plateau.z)\n\t\treturn { sin: sin(angle), cos: cos(angle), halfWidth: (ramp.width ?? RAMP_WIDTH) / 2, edge: edgeAt(angle) }\n\t})\n\treturn (x, z) => {\n\t\tconst dx = x - plateau.x\n\t\tconst dz = z - plateau.z\n\t\tfor (const ramp of ramps) {\n\t\t\tconst across = Math.abs(dx * ramp.cos - dz * ramp.sin)\n\t\t\tconst along = dx * ramp.sin + dz * ramp.cos\n\t\t\t// the ramp straddles the edge, half of it on top of the plateau and half below\n\t\t\tconst top = ramp.edge - length / 2\n\t\t\tif (across > ramp.halfWidth || along < top) continue\n\t\t\treturn 1 - smoothstep(0, 1, (along - top) / length)\n\t\t}\n\t\treturn hypot(dx, dz) < edgeAt(atan2(dx, dz)) ? 1 : 0\n\t}\n}\n\n/**\n * Makes ground from the options: rolling hills, rocks, flat spots and plateaus, from their seed\n *\n * @beta\n */\nexport function generateTerrain(options: TerrainGenOptions): Terrain {\n\tconst { width, depth, seed, hillHeight = 2.5, hillScale = 28, rocks = [], flats = [], plateaus = [], cliffHeight = 3 } = options\n\tconst rng = new Rng(seed)\n\n\tconst latticeSize = 64\n\tconst lattice = new Float32Array(latticeSize * latticeSize)\n\tfor (let i = 0; i < lattice.length; i++) lattice[i] = rng.next()\n\t// after the hills, so that adding a plateau leaves the rest of the map as it was\n\tconst shapes = plateaus.map((plateau) => ({ levels: plateau.levels ?? 1, shape: plateauShape(plateau, cliffHeight, rng) }))\n\tconst latticeAt = (x: number, z: number) =>\n\t\tlattice[(((z % latticeSize) + latticeSize) % latticeSize) * latticeSize + (((x % latticeSize) + latticeSize) % latticeSize)]\n\tconst noise = (x: number, z: number) => {\n\t\tconst ix = Math.floor(x)\n\t\tconst iz = Math.floor(z)\n\t\tconst fx = smoothstep(0, 1, x - ix)\n\t\tconst fz = smoothstep(0, 1, z - iz)\n\t\tconst top = latticeAt(ix, iz) + (latticeAt(ix + 1, iz) - latticeAt(ix, iz)) * fx\n\t\tconst bottom = latticeAt(ix, iz + 1) + (latticeAt(ix + 1, iz + 1) - latticeAt(ix, iz + 1)) * fx\n\t\treturn top + (bottom - top) * fz\n\t}\n\n\tconst vertsX = width + 1\n\tconst heights = new Float32Array(vertsX * (depth + 1))\n\tfor (let iz = 0; iz <= depth; iz++) {\n\t\tfor (let ix = 0; ix <= width; ix++) {\n\t\t\tlet h = 0\n\t\t\tlet amplitude = 1\n\t\t\tlet frequency = 1 / hillScale\n\t\t\tlet total = 0\n\t\t\tfor (let octave = 0; octave < 3; octave++) {\n\t\t\t\th += noise(ix * frequency, iz * frequency) * amplitude\n\t\t\t\ttotal += amplitude\n\t\t\t\tamplitude *= 0.4\n\t\t\t\tfrequency *= 2.3\n\t\t\t}\n\t\t\th = (h / total) * hillHeight\n\n\t\t\tfor (const flat of flats) {\n\t\t\t\tconst d = hypot(ix - flat.x, iz - flat.z)\n\t\t\t\tconst flatHeight = hillHeight * 0.5\n\t\t\t\tconst blend = smoothstep(0, 1, (d - flat.radius) / (flat.radius * 0.6))\n\t\t\t\th = flatHeight + (h - flatHeight) * blend\n\t\t\t}\n\t\t\t// the hills go on on top of the plateaus, which is why these come after the flats\n\t\t\tfor (const { levels, shape } of shapes) h += shape(ix, iz) * levels * cliffHeight\n\t\t\tfor (const rock of rocks) {\n\t\t\t\tconst d = hypot(ix - rock.x, iz - rock.z)\n\t\t\t\tif (d < rock.radius) h += rock.height * smoothstep(0, 1, 1 - d / rock.radius)\n\t\t\t}\n\t\t\theights[iz * vertsX + ix] = h\n\t\t}\n\t}\n\n\tconst levels = new Uint8Array(width * depth)\n\tif (shapes.length) {\n\t\tfor (let cz = 0; cz < depth; cz++) {\n\t\t\tfor (let cx = 0; cx < width; cx++) {\n\t\t\t\tlet level = 0\n\t\t\t\tfor (const shape of shapes) if (shape.shape(cx + 0.5, cz + 0.5) >= 0.5) level += shape.levels\n\t\t\t\tlevels[cz * width + cx] = level\n\t\t\t}\n\t\t}\n\t}\n\treturn new Terrain(width, depth, heights, levels)\n}\n"],"mappings":"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"}

package/dist/terrainSave.d.ts

@@ -4,16 +4,22 @@
  * @beta
  */
 export interface TerrainSave {
+    /** Cells across the map */
     width: number;
+    /** Cells along the map */
     depth: number;
     /**
      * Each layer as packed bytes (see `packBytes`), or, where every cell holds the same, that value: a map without water
      * or cliffs, of one ground, says so in a few characters rather than a few hundred thousand
      */
     heights: string | number;
+    /** The cliff level per cell, packed or as the one value every cell holds */
     levels: string | number;
+    /** The `WATER_*` value per cell, packed or as the one value every cell holds */
     water: string | number;
+    /** The height of the water's surface per vertex, packed or as the one value every vertex holds */
     waterHeights: string | number;
+    /** The paint per cell, packed or as the one value every cell holds */
     tiles: string | number;
     /** What scenery keeps off each cell. Left out by saves from before there was any */
     blocked?: string | number;