@v12-engine/engine 0.1.1 → 0.4.0

package/dist/map/look.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"look.js","names":[],"sources":["../../src/map/look.ts"],"sourcesContent":["/*\n * What a map looks like beyond its ground, as data the engine carries and never reads: light, fog, sky, water, weather, tiles' looks (design review E8a: `map.ts` in parts)\n */\nimport { environmentChanged } from '#engine/engineEvents'\nimport { replicateEvent } from '../replication'\nimport { MAX_TILES } from '../tiles'\n\n/**\n * What a map looks like beyond its ground (design review E8c): the engine carries it (in the map, its file, a save,\n * what players are told as it changes: `world.setEnvironment`) and reads none of it but the map's own tiles, which are\n * paint like the game's. An open interface: the client adds what it draws by (its water, light, sky, fog, weather,\n * lights and the rest), as a game adds its commands (`Commands`)\n *\n * @public\n */\nexport interface MapEnvironment {\n\t/** Ground of the map's own to paint with, past the game's tiles (see `MapTile`): the rules' paint, by id */\n\ttiles?: MapTile[]\n}\n\n/**\n * A ground of a map's own, to paint with as a game's tiles are (`MapEnvironment.tiles`): to the rules, paint by its id.\n * An open interface: the client adds its look (its picture, colour, pattern)\n *\n * @beta\n */\nexport interface MapTile {\n\t/** Its id in the map's paint (`GameMap.tileset`): none of the game's tiles' */\n\tid: string\n\t/** What the editor's palette calls it */\n\tname: string\n}\n\n/**\n * The ids of a map's own tiles (`MapEnvironment.tiles`)\n *\n * @beta\n */\nexport const mapTileIds = (environment: MapEnvironment | undefined): string[] => (environment?.tiles ?? []).map((tile) => tile.id)\n\n/**\n * The tiles a world from a map is painted with: the game's, then the map's own that are none of them, as many as a map\n * can hold. The order a played ground's paint is in, and its looks\n *\n * @beta\n */\nexport function playTileset(gameTiles: readonly string[], environment: MapEnvironment | undefined): string[] {\n\tconst own = mapTileIds(environment).filter((id) => !gameTiles.includes(id))\n\treturn [...gameTiles, ...own].slice(0, MAX_TILES)\n}\n\n/** The map's light, fog and sky changed (`world.setEnvironment`): to everyone */\nexport const toldEnvironment = replicateEvent(environmentChanged, 'environment', ({ environment, over }) => ({\n\ttype: 'environment',\n\tenvironment: structuredClone(environment),\n\t...(over && { over })\n}))\n\n/**\n * The light a doodad carries (`MapDoodad.light`), over the one its kind of doodad gives: an open interface the client\n * fills in with what a light of the map is (`MapLightSource`, less where it stands and its name)\n *\n * @beta\n */\n// eslint-disable-next-line @typescript-eslint/no-empty-object-type\nexport interface MapDoodadLight {}\n"],"mappings":";;;;;;;;;AAsCA,IAAa,cAAc,iBAAuD,aAAa,SAAS,CAAC,EAAA,CAAG,KAAK,SAAS,KAAK,EAAE;;;;;;;AAQjI,SAAgB,YAAY,WAA8B,aAAmD;CAC5G,MAAM,MAAM,WAAW,WAAW,CAAC,CAAC,QAAQ,OAAO,CAAC,UAAU,SAAS,EAAE,CAAC;CAC1E,OAAO,CAAC,GAAG,WAAW,GAAG,GAAG,CAAC,CAAC,MAAM,GAAA,GAAY;AACjD;;AAGA,IAAa,kBAAkB,eAAe,oBAAoB,gBAAgB,EAAE,aAAa,YAAY;CAC5G,MAAM;CACN,aAAa,gBAAgB,WAAW;CACxC,GAAI,QAAQ,EAAE,KAAK;AACpB,EAAE"}

package/dist/map/pathProfile.js

@@ -0,0 +1,183 @@
+import { hypot } from "../exactMath.js";
+import { clamp, smoothstep } from "../math.js";
+import "../terrain.js";
+//#region src/map/pathProfile.ts
+/**
+* How deep the ground is under water, by its kind (none, shallow, deep)
+*
+* @internal
+*/
+var WATER_DEPTH = [
+	0,
+	.45,
+	1.6
+];
+/**
+* How far along a path its land is averaged each way, in cells: what makes a road as smooth along it as a road is
+*
+* @beta
+*/
+var PROFILE_SMOOTH = 4;
+/**
+* How far a path's profile reaches from its line, in cells: half its bed and its banks
+*
+* @beta
+*/
+function profileReach(path) {
+	const profile = path.profile ?? {};
+	return Math.max(profile.width ?? path.width, 1) / 2 + Math.max(profile.banks ?? 2, 0);
+}
+/** How deep the water in a profile's bed is */
+var waterOf = (profile) => !profile.water ? 0 : (profile.depth ?? 0) >= 1 ? 2 : 1;
+/** How far the land along a path is read, in cells: every half a cell from each point */
+var STEP = .5;
+/** The map's own land at a point, between its corners: the heights a carve starts from */
+function landAt(map, x, z) {
+	const vx = map.width + 1;
+	const fx = clamp(x, 0, map.width);
+	const fz = clamp(z, 0, map.depth);
+	const ix = Math.min(Math.floor(fx), map.width - 1);
+	const iz = Math.min(Math.floor(fz), map.depth - 1);
+	const tx = fx - ix;
+	const tz = fz - iz;
+	const g = map.ground;
+	const a = g[iz * vx + ix] + (g[iz * vx + ix + 1] - g[iz * vx + ix]) * tx;
+	return a + (g[(iz + 1) * vx + ix] + (g[(iz + 1) * vx + ix + 1] - g[(iz + 1) * vx + ix]) * tx - a) * tz;
+}
+function lineOf(map, path) {
+	const { points } = path;
+	const starts = [0];
+	const along = [];
+	const raw = [];
+	for (let i = 0; i < points.length - 1; i++) {
+		const a = points[i];
+		const b = points[i + 1];
+		const length = hypot(b.x - a.x, b.z - a.z);
+		starts.push(starts[i] + length);
+		for (let d = 0; d < length; d += STEP) {
+			const t = d / length;
+			along.push(starts[i] + d);
+			raw.push(landAt(map, a.x + (b.x - a.x) * t, a.z + (b.z - a.z) * t));
+		}
+	}
+	const last = points[points.length - 1];
+	along.push(starts[starts.length - 1]);
+	raw.push(landAt(map, last.x, last.z));
+	const height = new Array(raw.length);
+	let from = 0;
+	let to = 0;
+	let sum = 0;
+	for (let k = 0; k < raw.length; k++) {
+		while (to < raw.length && along[to] <= along[k] + 4) sum += raw[to++];
+		while (along[from] < along[k] - 4) sum -= raw[from++];
+		height[k] = sum / (to - from);
+	}
+	return {
+		points,
+		starts,
+		along,
+		height
+	};
+}
+/** The smoothed land at a distance along a line */
+function heightAlong(line, at) {
+	const { along, height } = line;
+	if (at <= along[0]) return height[0];
+	if (at >= along[along.length - 1]) return height[height.length - 1];
+	let lo = 0;
+	let hi = along.length - 1;
+	while (hi - lo > 1) {
+		const mid = lo + hi >> 1;
+		if (along[mid] <= at) lo = mid;
+		else hi = mid;
+	}
+	const span = along[hi] - along[lo] || 1;
+	return height[lo] + (height[hi] - height[lo]) * ((at - along[lo]) / span);
+}
+/** The nearest point of a line to a point within `reach`: how far, and how far along; nothing beyond `reach` */
+function nearest(line, x, z, reach) {
+	let best = reach;
+	let along = -1;
+	const { points, starts } = line;
+	for (let i = 0; i < points.length - 1; i++) {
+		const a = points[i];
+		const b = points[i + 1];
+		if (x < Math.min(a.x, b.x) - best || x > Math.max(a.x, b.x) + best || z < Math.min(a.z, b.z) - best || z > Math.max(a.z, b.z) + best) continue;
+		const dx = b.x - a.x;
+		const dz = b.z - a.z;
+		const span = dx * dx + dz * dz;
+		const t = span ? clamp(((x - a.x) * dx + (z - a.z) * dz) / span, 0, 1) : 0;
+		const d = hypot(x - (a.x + dx * t), z - (a.z + dz * t));
+		if (d <= best) {
+			best = d;
+			along = starts[i] + t * (starts[i + 1] - starts[i]);
+		}
+	}
+	return along < 0 ? void 0 : {
+		distance: best,
+		along
+	};
+}
+/**
+* The ground the paths with a profile carve, for the corners `x0..x1` × `z0..z1` (row by row), and the water they put
+* in the cells `x0 - 1..x1` × `z0 - 1..z1` (row by row; 0 where they put none): nothing where no profile reaches
+*
+* @internal
+*/
+function profiledGround(map, x0, z0, x1, z1) {
+	const profiled = map.paths.filter((path) => path.profile && path.points.length > 1);
+	if (!profiled.length) return void 0;
+	const vx = map.width + 1;
+	const row = x1 - x0 + 1;
+	let ground;
+	let water;
+	const cellRow = x1 - x0 + 2;
+	/** The corners as the map has them, the first time a profile reaches one */
+	const corners = () => {
+		if (ground) return ground;
+		ground = new Float64Array(row * (z1 - z0 + 1));
+		for (let z = z0; z <= z1; z++) for (let x = x0; x <= x1; x++) ground[(z - z0) * row + (x - x0)] = map.ground[z * vx + x];
+		return ground;
+	};
+	for (const path of profiled) {
+		const profile = path.profile;
+		const reach = profileReach(path);
+		const xs = path.points.map((p) => p.x);
+		const zs = path.points.map((p) => p.z);
+		if (Math.max(...xs) + reach < x0 - 1 || Math.min(...xs) - reach > x1 || Math.max(...zs) + reach < z0 - 1 || Math.min(...zs) - reach > z1) continue;
+		const line = lineOf(map, path);
+		const half = Math.max(profile.width ?? path.width, 1) / 2;
+		const banks = Math.max(profile.banks ?? 2, 0);
+		const kind = waterOf(profile);
+		const lowered = Math.max((profile.depth ?? 0) - WATER_DEPTH[kind], 0);
+		const vx0 = Math.max(Math.floor(Math.min(...xs) - reach), x0);
+		const vz0 = Math.max(Math.floor(Math.min(...zs) - reach), z0);
+		const vx1 = Math.min(Math.ceil(Math.max(...xs) + reach), x1);
+		const vz1 = Math.min(Math.ceil(Math.max(...zs) + reach), z1);
+		for (let iz = vz0; iz <= vz1; iz++) for (let ix = vx0; ix <= vx1; ix++) {
+			const near = nearest(line, ix, iz, reach);
+			if (!near) continue;
+			const carved = corners();
+			const weight = near.distance <= half ? 1 : 1 - smoothstep(0, 1, (near.distance - half) / (banks || 1));
+			const at = (iz - z0) * row + (ix - x0);
+			const bed = heightAlong(line, near.along) - lowered;
+			carved[at] += (bed - carved[at]) * weight;
+		}
+		if (!kind) continue;
+		for (let cz = Math.max(vz0 - 1, z0 - 1, 0); cz <= Math.min(vz1, z1, map.depth - 1); cz++) for (let cx = Math.max(vx0 - 1, x0 - 1, 0); cx <= Math.min(vx1, x1, map.width - 1); cx++) {
+			if (!nearest(line, cx + .5, cz + .5, half)) continue;
+			corners();
+			water ??= new Uint8Array(cellRow * (z1 - z0 + 2));
+			const at = (cz - z0 + 1) * cellRow + (cx - x0 + 1);
+			water[at] = Math.max(water[at], kind);
+		}
+	}
+	return ground && {
+		ground,
+		water
+	};
+}
+//#endregion
+export { PROFILE_SMOOTH, WATER_DEPTH, profileReach, profiledGround };
+
+//# sourceMappingURL=pathProfile.js.map

package/dist/map/pathProfile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pathProfile.js","names":[],"sources":["../../src/map/pathProfile.ts"],"sourcesContent":["import { hypot } from '../exactMath'\nimport { clamp, smoothstep } from '../math'\nimport { WATER_DEEP, WATER_SHALLOW } from '../terrain'\nimport type { GameMap, MapPath, PathProfile } from './types'\n\n/*\n * Roads and rivers carved as the terrain is worked out (EQ19): a path with a profile (`MapPath.profile`) lowers and\n * levels the ground under it from the map's own land, which stays as it is painted, so the bed follows the path's\n * points wherever they go, and an edit of a few cells works out a few cells again (`updateMapTerrain`'s area). The same\n * in every engine: square roots, sums and smoothsteps, no sines.\n */\n\n/**\n * How deep the ground is under water, by its kind (none, shallow, deep)\n *\n * @internal\n */\nexport const WATER_DEPTH = [0, 0.45, 1.6]\n\n/**\n * How far along a path its land is averaged each way, in cells: what makes a road as smooth along it as a road is\n *\n * @beta\n */\nexport const PROFILE_SMOOTH = 4\n\n/**\n * How far a path's profile reaches from its line, in cells: half its bed and its banks\n *\n * @beta\n */\nexport function profileReach(path: Pick<MapPath, 'width' | 'profile'>): number {\n\tconst profile = path.profile ?? {}\n\treturn Math.max(profile.width ?? path.width, 1) / 2 + Math.max(profile.banks ?? 2, 0)\n}\n\n/** How deep the water in a profile's bed is */\nconst waterOf = (profile: PathProfile) => (!profile.water ? 0 : (profile.depth ?? 0) >= 1 ? WATER_DEEP : WATER_SHALLOW)\n\n/** How far the land along a path is read, in cells: every half a cell from each point */\nconst STEP = 0.5\n\n/**\n * A path's line as the carve reads it: its segments, how far along each begins, and its land along it smoothed (from\n * each point every half a cell, so a moved point changes the samples of its own two segments alone)\n */\ninterface Line {\n\tpoints: { x: number; z: number }[]\n\tstarts: number[]\n\talong: number[]\n\theight: number[]\n}\n\n/** The map's own land at a point, between its corners: the heights a carve starts from */\nfunction landAt(map: GameMap, x: number, z: number): number {\n\tconst vx = map.width + 1\n\tconst fx = clamp(x, 0, map.width)\n\tconst fz = clamp(z, 0, map.depth)\n\tconst ix = Math.min(Math.floor(fx), map.width - 1)\n\tconst iz = Math.min(Math.floor(fz), map.depth - 1)\n\tconst tx = fx - ix\n\tconst tz = fz - iz\n\tconst g = map.ground\n\tconst a = g[iz * vx + ix] + (g[iz * vx + ix + 1] - g[iz * vx + ix]) * tx\n\tconst b = g[(iz + 1) * vx + ix] + (g[(iz + 1) * vx + ix + 1] - g[(iz + 1) * vx + ix]) * tx\n\treturn a + (b - a) * tz\n}\n\nfunction lineOf(map: GameMap, path: MapPath): Line {\n\tconst { points } = path\n\tconst starts = [0]\n\tconst along: number[] = []\n\tconst raw: number[] = []\n\tfor (let i = 0; i < points.length - 1; i++) {\n\t\tconst a = points[i]\n\t\tconst b = points[i + 1]\n\t\tconst length = hypot(b.x - a.x, b.z - a.z)\n\t\tstarts.push(starts[i] + length)\n\t\tfor (let d = 0; d < length; d += STEP) {\n\t\t\tconst t = d / length\n\t\t\talong.push(starts[i] + d)\n\t\t\traw.push(landAt(map, a.x + (b.x - a.x) * t, a.z + (b.z - a.z) * t))\n\t\t}\n\t}\n\tconst last = points[points.length - 1]\n\talong.push(starts[starts.length - 1])\n\traw.push(landAt(map, last.x, last.z))\n\t// each sample the mean of those within PROFILE_SMOOTH of it along the path\n\tconst height = new Array<number>(raw.length)\n\tlet from = 0\n\tlet to = 0\n\tlet sum = 0\n\tfor (let k = 0; k < raw.length; k++) {\n\t\twhile (to < raw.length && along[to] <= along[k] + PROFILE_SMOOTH) sum += raw[to++]\n\t\twhile (along[from] < along[k] - PROFILE_SMOOTH) sum -= raw[from++]\n\t\theight[k] = sum / (to - from)\n\t}\n\treturn { points, starts, along, height }\n}\n\n/** The smoothed land at a distance along a line */\nfunction heightAlong(line: Line, at: number): number {\n\tconst { along, height } = line\n\tif (at <= along[0]) return height[0]\n\tif (at >= along[along.length - 1]) return height[height.length - 1]\n\tlet lo = 0\n\tlet hi = along.length - 1\n\twhile (hi - lo > 1) {\n\t\tconst mid = (lo + hi) >> 1\n\t\tif (along[mid] <= at) lo = mid\n\t\telse hi = mid\n\t}\n\tconst span = along[hi] - along[lo] || 1\n\treturn height[lo] + (height[hi] - height[lo]) * ((at - along[lo]) / span)\n}\n\n/** The nearest point of a line to a point within `reach`: how far, and how far along; nothing beyond `reach` */\nfunction nearest(line: Line, x: number, z: number, reach: number): { distance: number; along: number } | undefined {\n\tlet best = reach\n\tlet along = -1\n\tconst { points, starts } = line\n\tfor (let i = 0; i < points.length - 1; i++) {\n\t\tconst a = points[i]\n\t\tconst b = points[i + 1]\n\t\t// (a segment whose box is out of reach is not looked at)\n\t\tif (x < Math.min(a.x, b.x) - best || x > Math.max(a.x, b.x) + best || z < Math.min(a.z, b.z) - best || z > Math.max(a.z, b.z) + best) continue\n\t\tconst dx = b.x - a.x\n\t\tconst dz = b.z - a.z\n\t\tconst span = dx * dx + dz * dz\n\t\tconst t = span ? clamp(((x - a.x) * dx + (z - a.z) * dz) / span, 0, 1) : 0\n\t\tconst d = hypot(x - (a.x + dx * t), z - (a.z + dz * t))\n\t\tif (d <= best) {\n\t\t\tbest = d\n\t\t\talong = starts[i] + t * (starts[i + 1] - starts[i])\n\t\t}\n\t}\n\treturn along < 0 ? undefined : { distance: best, along }\n}\n\n/**\n * The ground the paths with a profile carve, for the corners `x0..x1` × `z0..z1` (row by row), and the water they put\n * in the cells `x0 - 1..x1` × `z0 - 1..z1` (row by row; 0 where they put none): nothing where no profile reaches\n *\n * @internal\n */\nexport function profiledGround(\n\tmap: GameMap,\n\tx0: number,\n\tz0: number,\n\tx1: number,\n\tz1: number\n): { ground: Float64Array; water: Uint8Array | undefined } | undefined {\n\tconst profiled = map.paths.filter((path) => path.profile && path.points.length > 1)\n\tif (!profiled.length) return undefined\n\tconst vx = map.width + 1\n\tconst row = x1 - x0 + 1\n\tlet ground: Float64Array | undefined\n\tlet water: Uint8Array | undefined\n\tconst cellRow = x1 - x0 + 2\n\t/** The corners as the map has them, the first time a profile reaches one */\n\tconst corners = (): Float64Array => {\n\t\tif (ground) return ground\n\t\tground = new Float64Array(row * (z1 - z0 + 1))\n\t\tfor (let z = z0; z <= z1; z++) for (let x = x0; x <= x1; x++) ground[(z - z0) * row + (x - x0)] = map.ground[z * vx + x]\n\t\treturn ground\n\t}\n\tfor (const path of profiled) {\n\t\tconst profile = path.profile!\n\t\tconst reach = profileReach(path)\n\t\tconst xs = path.points.map((p) => p.x)\n\t\tconst zs = path.points.map((p) => p.z)\n\t\tif (Math.max(...xs) + reach < x0 - 1 || Math.min(...xs) - reach > x1 || Math.max(...zs) + reach < z0 - 1 || Math.min(...zs) - reach > z1) continue\n\t\tconst line = lineOf(map, path)\n\t\tconst half = Math.max(profile.width ?? path.width, 1) / 2\n\t\tconst banks = Math.max(profile.banks ?? 2, 0)\n\t\tconst kind = waterOf(profile)\n\t\t// with water in it, the water is part of the depth: the bed is lowered by the rest\n\t\tconst lowered = Math.max((profile.depth ?? 0) - WATER_DEPTH[kind], 0)\n\t\tconst vx0 = Math.max(Math.floor(Math.min(...xs) - reach), x0)\n\t\tconst vz0 = Math.max(Math.floor(Math.min(...zs) - reach), z0)\n\t\tconst vx1 = Math.min(Math.ceil(Math.max(...xs) + reach), x1)\n\t\tconst vz1 = Math.min(Math.ceil(Math.max(...zs) + reach), z1)\n\t\tfor (let iz = vz0; iz <= vz1; iz++) {\n\t\t\tfor (let ix = vx0; ix <= vx1; ix++) {\n\t\t\t\tconst near = nearest(line, ix, iz, reach)\n\t\t\t\tif (!near) continue\n\t\t\t\tconst carved = corners()\n\t\t\t\t// on the bed all of it; over the banks less and less, eased\n\t\t\t\tconst weight = near.distance <= half ? 1 : 1 - smoothstep(0, 1, (near.distance - half) / (banks || 1))\n\t\t\t\tconst at = (iz - z0) * row + (ix - x0)\n\t\t\t\tconst bed = heightAlong(line, near.along) - lowered\n\t\t\t\tcarved[at] += (bed - carved[at]) * weight\n\t\t\t}\n\t\t}\n\t\tif (!kind) continue\n\t\tfor (let cz = Math.max(vz0 - 1, z0 - 1, 0); cz <= Math.min(vz1, z1, map.depth - 1); cz++) {\n\t\t\tfor (let cx = Math.max(vx0 - 1, x0 - 1, 0); cx <= Math.min(vx1, x1, map.width - 1); cx++) {\n\t\t\t\tconst near = nearest(line, cx + 0.5, cz + 0.5, half)\n\t\t\t\tif (!near) continue\n\t\t\t\tcorners()\n\t\t\t\twater ??= new Uint8Array(cellRow * (z1 - z0 + 2))\n\t\t\t\tconst at = (cz - z0 + 1) * cellRow + (cx - x0 + 1)\n\t\t\t\twater[at] = Math.max(water[at], kind)\n\t\t\t}\n\t\t}\n\t}\n\treturn ground && { ground, water }\n}\n"],"mappings":"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"}

package/dist/map/resize.d.ts

@@ -9,9 +9,11 @@ import { type GameMap } from './types';
 export interface MapSides {
     /** Towards x 0, and towards x of the width */
     left: number;
+    /** Cells gained on the right, towards x of the width; less than 0 cuts them */
     right: number;
     /** Towards z 0, and towards z of the depth */
     top: number;
+    /** Cells gained on the bottom, towards z of the depth; less than 0 cuts them */
     bottom: number;
 }
 /**
@@ -21,9 +23,11 @@ export interface MapSides {
  * @beta
  */
 export interface MapResize {
+    /** The sides the map is grown or cut on */
     readonly sides: MapSides;
     /** The new size, in cells */
     readonly width: number;
+    /** The new depth of the map in cells */
     readonly depth: number;
     /** A place where it is on the grown map (the old place, moved by the cells gained on the left and the top) */
     moved<P extends Vec2>(place: P): P;

package/dist/map/resize.js

@@ -0,0 +1,136 @@
+import { clamp } from "../math.js";
+import "./types.js";
+import { fieldsOf } from "./schema.js";
+import { cloneMap } from "./file.js";
+//#region src/map/resize.ts
+/**
+* A map grown or cut on any side: the ground, cliffs, water and paint go on as they were at the old edge where it
+* grows; everything on it moves along, and what is no longer on the map is gone. The map itself is left as it was.
+* What the engine keeps moves (objects, camps, regions, points, paths, doodads, cameras, the players' starts, the bounds,
+* the game's own kinds' things in `data`); what others keep moves with the `resizers` given (the client's looks:
+* `mapLooksResizer`)
+*
+* @beta
+*/
+function resizeMap(map, sides, resizers = []) {
+	const { left, right, top, bottom } = sides;
+	const width = map.width + left + right;
+	const depth = map.depth + top + bottom;
+	if (width < 8 || depth < 8 || width > 512 || depth > 512) throw new Error(`A map is between 8 and 512 cells each way, not ${width} × ${depth}`);
+	const copy = cloneMap(map);
+	const layer = (old, oldRow, oldColumn, row, column) => {
+		const out = new old.constructor(row * column);
+		for (let z = 0; z < column; z++) {
+			const from = clamp(z - top, 0, oldColumn - 1) * oldRow;
+			for (let x = 0; x < row; x++) out[z * row + x] = old[from + clamp(x - left, 0, oldRow - 1)];
+		}
+		return out;
+	};
+	copy.width = width;
+	copy.depth = depth;
+	const grown = (old, perVertex = false) => perVertex ? layer(old, map.width + 1, map.depth + 1, width + 1, depth + 1) : layer(old, map.width, map.depth, width, depth);
+	const into = copy;
+	for (const field of fieldsOf("layer", "mask", "layers")) {
+		const value = map[field.key];
+		if (!value) continue;
+		into[field.key] = field.kind === "layers" ? Object.fromEntries(Object.entries(value).map(([id, cells]) => [id, grown(cells)])) : grown(value, field.perVertex);
+	}
+	const on = (p) => p.x >= 0 && p.z >= 0 && p.x <= width && p.z <= depth;
+	const moved = (p) => ({
+		...p,
+		x: p.x + left,
+		z: p.z + top
+	});
+	const inside = (p) => ({
+		...p,
+		x: clamp(p.x, 0, width),
+		z: clamp(p.z, 0, depth)
+	});
+	const shape = (shape) => {
+		if (shape.kind !== "rect") {
+			const center = moved(shape);
+			return on(center) ? center : void 0;
+		}
+		const x0 = Math.max(shape.x - shape.width / 2 + left, 0);
+		const z0 = Math.max(shape.z - shape.depth / 2 + top, 0);
+		const x1 = Math.min(shape.x + shape.width / 2 + left, width);
+		const z1 = Math.min(shape.z + shape.depth / 2 + top, depth);
+		return x1 > x0 && z1 > z0 ? {
+			...shape,
+			x: (x0 + x1) / 2,
+			z: (z0 + z1) / 2,
+			width: x1 - x0,
+			depth: z1 - z0
+		} : void 0;
+	};
+	copy.objects = copy.objects.map((object) => ({
+		...object,
+		...moved(object)
+	})).filter(on);
+	copy.camps = copy.camps.map((camp) => ({
+		...camp,
+		...moved(camp)
+	})).filter(on);
+	copy.points = copy.points.map((point) => ({
+		...point,
+		...moved(point)
+	})).filter(on);
+	copy.doodads = copy.doodads.map((doodad) => ({
+		...doodad,
+		...moved(doodad)
+	})).filter(on);
+	copy.cameras = copy.cameras.map((camera) => ({
+		...camera,
+		...inside(moved(camera))
+	}));
+	copy.paths = copy.paths.map((path) => ({
+		...path,
+		points: path.points.map((p) => inside(moved(p)))
+	}));
+	copy.players = copy.players.map((player) => {
+		if (!player.start) return player;
+		const start = moved(player.start);
+		const { start: _, ...rest } = player;
+		return on(start) ? {
+			...player,
+			start
+		} : rest;
+	});
+	copy.regions = copy.regions.flatMap((region) => {
+		const moved = shape(region.shape);
+		return moved ? [{
+			...region,
+			shape: moved
+		}] : [];
+	});
+	for (const [kind, kept] of Object.entries(copy.data)) if (Array.isArray(kept) && kept.length && kept.every(isThing)) copy.data[kind] = kept.map((thing) => moved(thing)).filter(on);
+	if (map.bounds) {
+		const x = Math.max(map.bounds.x + left, 0);
+		const z = Math.max(map.bounds.z + top, 0);
+		const bounds = {
+			x,
+			z,
+			width: Math.min(map.bounds.x + left + map.bounds.width, width) - x,
+			depth: Math.min(map.bounds.z + top + map.bounds.depth, depth) - z
+		};
+		if (bounds.width > 0 && bounds.depth > 0) copy.bounds = bounds;
+		else delete copy.bounds;
+	}
+	const resize = {
+		sides,
+		width,
+		depth,
+		moved,
+		on,
+		inside,
+		shape
+	};
+	for (const resizer of resizers) resizer(copy, resize);
+	return copy;
+}
+/** A thing of a game's own kind, as `mapThings` reads one: an id, and a place */
+var isThing = (thing) => typeof thing === "object" && thing !== null && Number.isInteger(thing.id) && Number.isFinite(thing.x) && Number.isFinite(thing.z);
+//#endregion
+export { resizeMap };
+
+//# sourceMappingURL=resize.js.map

package/dist/map/resize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resize.js","names":[],"sources":["../../src/map/resize.ts"],"sourcesContent":["/*\n * A map grown or cut on its sides (design review E8a: `map.ts` in parts)\n */\nimport type { AreaShape } from '../areas'\nimport { clamp, type Vec2 } from '../math'\nimport { cloneMap } from './file'\nimport { fieldsOf } from './schema'\nimport type { MapThing } from '../mapFields'\nimport { type GameMap, type MapRegion, MAX_MAP_SIZE, MIN_MAP_SIZE } from './types'\n\n/**\n * How many cells a map gains on each side, or loses where it is less than 0 (see `resizeMap`)\n *\n * @beta\n */\nexport interface MapSides {\n\t/** Towards x 0, and towards x of the width */\n\tleft: number\n\t/** Cells gained on the right, towards x of the width; less than 0 cuts them */\n\tright: number\n\t/** Towards z 0, and towards z of the depth */\n\ttop: number\n\t/** Cells gained on the bottom, towards z of the depth; less than 0 cuts them */\n\tbottom: number\n}\n\n/**\n * How a map is being grown or cut (`resizeMap`), for what moves along with it: where a place goes, whether it is\n * still on the map, and a shape moved and cut to the map\n *\n * @beta\n */\nexport interface MapResize {\n\t/** The sides the map is grown or cut on */\n\treadonly sides: MapSides\n\t/** The new size, in cells */\n\treadonly width: number\n\t/** The new depth of the map in cells */\n\treadonly depth: number\n\t/** A place where it is on the grown map (the old place, moved by the cells gained on the left and the top) */\n\tmoved<P extends Vec2>(place: P): P\n\t/** Whether a place is on the grown map */\n\ton(place: Vec2): boolean\n\t/** A place kept on the grown map: at its edge where it is past it */\n\tinside<P extends Vec2>(place: P): P\n\t/** A shape moved: a circle while its middle is on the map, what is left of a rectangle on it; none when it is gone */\n\tshape<S extends AreaShape>(shape: S): S | undefined\n}\n\n/**\n * What moves along with a map grown or cut, of what others than the engine keep with it (`resizeMap`): the client's\n * looks under `map.environment` (`mapLooksResizer` of `@v12-engine/client`), the editor's own. Changes the copy it is\n * given, as `resizeMap` hands it on\n *\n * @beta\n */\nexport type MapResizer = (map: GameMap, resize: MapResize) => void\n\n/**\n * A map grown or cut on any side: the ground, cliffs, water and paint go on as they were at the old edge where it\n * grows; everything on it moves along, and what is no longer on the map is gone. The map itself is left as it was.\n * What the engine keeps moves (objects, camps, regions, points, paths, doodads, cameras, the players' starts, the bounds,\n * the game's own kinds' things in `data`); what others keep moves with the `resizers` given (the client's looks:\n * `mapLooksResizer`)\n *\n * @beta\n */\nexport function resizeMap(map: GameMap, sides: MapSides, resizers: readonly MapResizer[] = []): GameMap {\n\tconst { left, right, top, bottom } = sides\n\tconst width = map.width + left + right\n\tconst depth = map.depth + top + bottom\n\tif (width < MIN_MAP_SIZE || depth < MIN_MAP_SIZE || width > MAX_MAP_SIZE || depth > MAX_MAP_SIZE)\n\t\tthrow new Error(`A map is between ${MIN_MAP_SIZE} and ${MAX_MAP_SIZE} cells each way, not ${width} × ${depth}`)\n\tconst copy = cloneMap(map)\n\t// each new cell, or corner of the ground, takes what is nearest to it on the old map\n\tconst layer = <T extends Float32Array | Uint8Array>(old: T, oldRow: number, oldColumn: number, row: number, column: number): T => {\n\t\tconst out = new (old.constructor as new (length: number) => T)(row * column)\n\t\tfor (let z = 0; z < column; z++) {\n\t\t\tconst from = clamp(z - top, 0, oldColumn - 1) * oldRow\n\t\t\tfor (let x = 0; x < row; x++) out[z * row + x] = old[from + clamp(x - left, 0, oldRow - 1)]\n\t\t}\n\t\treturn out\n\t}\n\tcopy.width = width\n\tcopy.depth = depth\n\t// every layer the map's table has (`MAP_FIELDS`): by corner for the heights, by cell for the rest\n\tconst grown = <T extends Float32Array | Uint8Array>(old: T, perVertex = false): T =>\n\t\tperVertex ? layer(old, map.width + 1, map.depth + 1, width + 1, depth + 1) : layer(old, map.width, map.depth, width, depth)\n\tconst into = copy as unknown as Record<string, unknown>\n\tfor (const field of fieldsOf('layer', 'mask', 'layers')) {\n\t\tconst value = map[field.key] as Float32Array | Uint8Array | Record<string, Uint8Array> | undefined\n\t\tif (!value) continue\n\t\tinto[field.key] =\n\t\t\tfield.kind === 'layers'\n\t\t\t\t? Object.fromEntries(Object.entries(value as Record<string, Uint8Array>).map(([id, cells]) => [id, grown(cells)]))\n\t\t\t\t: grown(value as Float32Array | Uint8Array, field.perVertex)\n\t}\n\tconst on = (p: Vec2) => p.x >= 0 && p.z >= 0 && p.x <= width && p.z <= depth\n\tconst moved = <P extends Vec2>(p: P): P => ({ ...p, x: p.x + left, z: p.z + top })\n\tconst inside = <P extends Vec2>(p: P): P => ({ ...p, x: clamp(p.x, 0, width), z: clamp(p.z, 0, depth) })\n\tconst shape = <S extends AreaShape>(shape: S): S | undefined => {\n\t\t// a circle, and a polygon (by its corners round its middle): where its middle is\n\t\tif (shape.kind !== 'rect') {\n\t\t\tconst center = moved(shape)\n\t\t\treturn on(center) ? center : undefined\n\t\t}\n\t\t// a rectangle is by its middle: what is left of it on the map, and its middle again\n\t\tconst x0 = Math.max(shape.x - shape.width / 2 + left, 0)\n\t\tconst z0 = Math.max(shape.z - shape.depth / 2 + top, 0)\n\t\tconst x1 = Math.min(shape.x + shape.width / 2 + left, width)\n\t\tconst z1 = Math.min(shape.z + shape.depth / 2 + top, depth)\n\t\treturn x1 > x0 && z1 > z0 ? { ...shape, x: (x0 + x1) / 2, z: (z0 + z1) / 2, width: x1 - x0, depth: z1 - z0 } : undefined\n\t}\n\tcopy.objects = copy.objects.map((object) => ({ ...object, ...moved(object) })).filter(on)\n\tcopy.camps = copy.camps.map((camp) => ({ ...camp, ...moved(camp) })).filter(on)\n\tcopy.points = copy.points.map((point) => ({ ...point, ...moved(point) })).filter(on)\n\tcopy.doodads = copy.doodads.map((doodad) => ({ ...doodad, ...moved(doodad) })).filter(on)\n\tcopy.cameras = copy.cameras.map((camera) => ({ ...camera, ...inside(moved(camera)) }))\n\tcopy.paths = copy.paths.map((path) => ({ ...path, points: path.points.map((p) => inside(moved(p))) }))\n\tcopy.players = copy.players.map((player) => {\n\t\tif (!player.start) return player\n\t\tconst start = moved(player.start)\n\t\tconst { start: _, ...rest } = player\n\t\treturn on(start) ? { ...player, start } : rest\n\t})\n\tcopy.regions = copy.regions.flatMap((region): MapRegion[] => {\n\t\tconst moved = shape(region.shape)\n\t\treturn moved ? [{ ...region, shape: moved }] : []\n\t})\n\t// the game's own kinds' things (`MapThing`, kept in `data` under each kind): a list of them moves as the engine's do\n\tfor (const [kind, kept] of Object.entries(copy.data)) {\n\t\tif (Array.isArray(kept) && kept.length && kept.every(isThing)) copy.data[kind] = kept.map((thing) => moved(thing)).filter(on)\n\t}\n\tif (map.bounds) {\n\t\tconst x = Math.max(map.bounds.x + left, 0)\n\t\tconst z = Math.max(map.bounds.z + top, 0)\n\t\tconst bounds = {\n\t\t\tx,\n\t\t\tz,\n\t\t\twidth: Math.min(map.bounds.x + left + map.bounds.width, width) - x,\n\t\t\tdepth: Math.min(map.bounds.z + top + map.bounds.depth, depth) - z\n\t\t}\n\t\tif (bounds.width > 0 && bounds.depth > 0) copy.bounds = bounds\n\t\telse delete copy.bounds\n\t}\n\tconst resize: MapResize = { sides, width, depth, moved, on, inside, shape }\n\tfor (const resizer of resizers) resizer(copy, resize)\n\treturn copy\n}\n\n/** A thing of a game's own kind, as `mapThings` reads one: an id, and a place */\nconst isThing = (thing: unknown): thing is MapThing =>\n\ttypeof thing === 'object' &&\n\tthing !== null &&\n\tNumber.isInteger((thing as MapThing).id) &&\n\tNumber.isFinite((thing as MapThing).x) &&\n\tNumber.isFinite((thing as MapThing).z)\n"],"mappings":"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"}

package/dist/map/schema.js

@@ -0,0 +1,257 @@
+//#region src/map/schema.ts
+/**
+* Every field of a map, in the order its file has them (`format` before them, what the reader does not know of the
+* file before that). `satisfies` checks that none of `GameMap` is left out
+*
+* @internal
+*/
+var MAP_FIELDS = [
+	{
+		key: "name",
+		kind: "text",
+		written: "always",
+		empty: () => "Untitled"
+	},
+	{
+		key: "description",
+		kind: "text",
+		written: "always",
+		empty: () => ""
+	},
+	{
+		key: "game",
+		kind: "text",
+		written: "defined"
+	},
+	{
+		key: "width",
+		kind: "number",
+		written: "always",
+		required: true
+	},
+	{
+		key: "depth",
+		kind: "number",
+		written: "always",
+		required: true
+	},
+	{
+		key: "cliffHeight",
+		kind: "number",
+		written: "always",
+		empty: () => 3
+	},
+	{
+		key: "ground",
+		kind: "layer",
+		written: "always",
+		required: true,
+		perVertex: true,
+		what: "the ground"
+	},
+	{
+		key: "levels",
+		kind: "layer",
+		written: "always",
+		required: true,
+		what: "the levels"
+	},
+	{
+		key: "ramps",
+		kind: "layer",
+		written: "always",
+		required: true,
+		what: "the ramps"
+	},
+	{
+		key: "water",
+		kind: "layer",
+		written: "always",
+		required: true,
+		what: "the water"
+	},
+	{
+		key: "tiles",
+		kind: "layer",
+		written: "always",
+		required: true,
+		what: "the paint"
+	},
+	{
+		key: "cells",
+		kind: "layers",
+		written: "filled"
+	},
+	{
+		key: "pathing",
+		kind: "mask",
+		written: "filled",
+		what: "what is kept off cells"
+	},
+	{
+		key: "tileset",
+		kind: "names",
+		written: "always",
+		required: true,
+		what: "the tileset"
+	},
+	{
+		key: "players",
+		kind: "list",
+		written: "always",
+		required: true,
+		byId: true
+	},
+	{
+		key: "objects",
+		kind: "list",
+		written: "always",
+		required: true,
+		byId: true
+	},
+	{
+		key: "camps",
+		kind: "list",
+		written: "always",
+		required: true,
+		byId: true
+	},
+	{
+		key: "regions",
+		kind: "list",
+		written: "filled",
+		byId: true,
+		empty: () => []
+	},
+	{
+		key: "points",
+		kind: "list",
+		written: "filled",
+		byId: true,
+		empty: () => []
+	},
+	{
+		key: "paths",
+		kind: "list",
+		written: "filled",
+		byId: true,
+		empty: () => []
+	},
+	{
+		key: "doodads",
+		kind: "list",
+		written: "filled",
+		byId: true,
+		empty: () => []
+	},
+	{
+		key: "cameras",
+		kind: "list",
+		written: "filled",
+		byId: true,
+		empty: () => []
+	},
+	{
+		key: "randomGroups",
+		kind: "list",
+		written: "filled"
+	},
+	{
+		key: "itemTables",
+		kind: "list",
+		written: "filled"
+	},
+	{
+		key: "forces",
+		kind: "list",
+		written: "filled"
+	},
+	{
+		key: "races",
+		kind: "names",
+		written: "filled"
+	},
+	{
+		key: "author",
+		kind: "text",
+		written: "filled"
+	},
+	{
+		key: "silence",
+		kind: "names",
+		written: "filled"
+	},
+	{
+		key: "meantFor",
+		kind: "text",
+		written: "filled"
+	},
+	{
+		key: "explored",
+		kind: "boolean",
+		written: "defined"
+	},
+	{
+		key: "loading",
+		kind: "text",
+		written: "filled"
+	},
+	{
+		key: "preview",
+		kind: "text",
+		written: "filled"
+	},
+	{
+		key: "environment",
+		kind: "object",
+		written: "filled"
+	},
+	{
+		key: "definitions",
+		kind: "object",
+		written: "filled",
+		plain: true
+	},
+	{
+		key: "generated",
+		kind: "object",
+		written: "defined"
+	},
+	{
+		key: "day",
+		kind: "object",
+		written: "filled"
+	},
+	{
+		key: "bounds",
+		kind: "object",
+		written: "defined"
+	},
+	{
+		key: "data",
+		kind: "object",
+		written: "filled",
+		empty: () => ({}),
+		plain: true
+	},
+	{
+		key: "editor",
+		kind: "object",
+		written: "filled",
+		plain: true
+	}
+];
+/** The fields as specs, for what walks them */
+var MAP_FIELD_SPECS = MAP_FIELDS;
+/** What a reader of this format knows in a file: `format` and every field. The rest is carried along (`GameMap.extra`) */
+var KNOWN = /* @__PURE__ */ new Set(["format", ...MAP_FIELDS.map((field) => field.key)]);
+/** The fields of a kind */
+var fieldsOf = (...kinds) => MAP_FIELD_SPECS.filter((field) => kinds.includes(field.kind));
+/** The lists of things with ids: merged thing by thing (`mergeMaps`), an entry to a line (`mapText`) */
+var BY_ID = MAP_FIELD_SPECS.filter((field) => field.byId).map((field) => field.key);
+/** The layers of the ground every map has: merged cell by cell (`mergeMaps`), a row to a line (`mapText`) */
+var LAYERS = fieldsOf("layer").map((field) => field.key);
+//#endregion
+export { BY_ID, KNOWN, LAYERS, MAP_FIELDS, MAP_FIELD_SPECS, fieldsOf };
+
+//# sourceMappingURL=schema.js.map