@v12-engine/engine 0.1.1 → 0.4.0

package/dist/terrainSave.js

@@ -0,0 +1,74 @@
+import { Terrain } from "./terrain.js";
+import { packArray, packBytes, unpackBytes } from "./bytes.js";
+//#region src/terrainSave.ts
+/**
+* A terrain as plain data and back: in a save (`save.ts`), in a map's ground (`ground.ts`), and sent to a remote player
+* as the game starts. Of nothing but the terrain and its bytes, so that what keeps a terrain loads nothing of a save
+*/
+/** The one value every element of a layer holds, or nothing when they are not all the same */
+function uniform(layer) {
+	const first = layer[0] ?? 0;
+	for (let i = 1; i < layer.length; i++) if (layer[i] !== first) return void 0;
+	return first;
+}
+var packLayer = (layer) => uniform(layer) ?? (layer instanceof Float32Array ? packArray(layer) : packBytes(layer));
+/**
+* A terrain as plain data, see `TerrainSave`
+*
+* @internal
+*/
+function saveTerrain(terrain) {
+	return {
+		width: terrain.width,
+		depth: terrain.depth,
+		heights: packLayer(terrain.heights),
+		levels: packLayer(terrain.levels),
+		water: packLayer(terrain.water),
+		waterHeights: packLayer(terrain.waterHeights),
+		tiles: packLayer(terrain.tiles),
+		blocked: packLayer(terrain.blocked),
+		...Object.keys(terrain.cells).length && { cells: Object.fromEntries(Object.entries(terrain.cells).map(([id, layer]) => [id, packLayer(layer)])) },
+		...terrain.bounds && { bounds: { ...terrain.bounds } }
+	};
+}
+/**
+* A terrain back from `saveTerrain`
+*
+* @internal
+*/
+function loadTerrain(save) {
+	const { width, depth } = save;
+	const cells = width * depth;
+	const verts = (width + 1) * (depth + 1);
+	const packed = (key, length) => {
+		const unpacked = unpackBytes(save[key], length);
+		if (!unpacked) throw new Error(`Save: the ${key} of the terrain is not the size of it`);
+		return unpacked;
+	};
+	const bytes = (key, length) => {
+		const value = save[key];
+		return typeof value === "number" ? new Uint8Array(length).fill(value) : packed(key, length);
+	};
+	const floats = (key) => {
+		const value = save[key];
+		return typeof value === "number" ? new Float32Array(verts).fill(value) : new Float32Array(packed(key, verts * 4).buffer);
+	};
+	const terrain = new Terrain(width, depth, floats("heights"), bytes("levels", cells), {
+		water: bytes("water", cells),
+		waterHeights: floats("waterHeights"),
+		tiles: bytes("tiles", cells),
+		blocked: save.blocked === void 0 ? void 0 : bytes("blocked", cells),
+		cells: Object.fromEntries(Object.entries(save.cells ?? {}).map(([id, value]) => {
+			if (typeof value === "number") return [id, new Uint8Array(cells).fill(value)];
+			const unpacked = unpackBytes(value, cells);
+			if (!unpacked) throw new Error(`Save: the cells of ${id} are not the size of the terrain`);
+			return [id, unpacked];
+		}))
+	});
+	if (save.bounds) terrain.bounds = { ...save.bounds };
+	return terrain;
+}
+//#endregion
+export { loadTerrain, saveTerrain };
+
+//# sourceMappingURL=terrainSave.js.map

package/dist/terrainSave.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"terrainSave.js","names":[],"sources":["../src/terrainSave.ts"],"sourcesContent":["/**\n * A terrain as plain data and back: in a save (`save.ts`), in a map's ground (`ground.ts`), and sent to a remote player\n * as the game starts. Of nothing but the terrain and its bytes, so that what keeps a terrain loads nothing of a save\n */\nimport { packArray, packBytes, unpackBytes } from './bytes'\nimport { Terrain } from './terrain'\n\n/**\n * A terrain as plain data: in a save, and sent to a remote player as the game starts\n *\n * @beta\n */\nexport interface TerrainSave {\n\t/** Cells across the map */\n\twidth: number\n\t/** Cells along the map */\n\tdepth: number\n\t/**\n\t * Each layer as packed bytes (see `packBytes`), or, where every cell holds the same, that value: a map without water\n\t * or cliffs, of one ground, says so in a few characters rather than a few hundred thousand\n\t */\n\theights: string | number\n\t/** The cliff level per cell, packed or as the one value every cell holds */\n\tlevels: string | number\n\t/** The `WATER_*` value per cell, packed or as the one value every cell holds */\n\twater: string | number\n\t/** The height of the water's surface per vertex, packed or as the one value every vertex holds */\n\twaterHeights: string | number\n\t/** The paint per cell, packed or as the one value every cell holds */\n\ttiles: string | number\n\t/** What scenery keeps off each cell. Left out by saves from before there was any */\n\tblocked?: string | number\n\t/** The game's layers of cells (`Terrain.cells`), by id, as the other layers. Left out when there are none */\n\tcells?: Record<string, string | number>\n\t/** The part of the map play happens in, when it is not all of it */\n\tbounds?: { x: number; z: number; width: number; depth: number }\n}\n\n/** The one value every element of a layer holds, or nothing when they are not all the same */\nfunction uniform(layer: Float32Array | Uint8Array): number | undefined {\n\tconst first = layer[0] ?? 0\n\tfor (let i = 1; i < layer.length; i++) if (layer[i] !== first) return undefined\n\treturn first\n}\n\nconst packLayer = (layer: Float32Array | Uint8Array): string | number =>\n\tuniform(layer) ?? (layer instanceof Float32Array ? packArray(layer) : packBytes(layer))\n\n/**\n * A terrain as plain data, see `TerrainSave`\n *\n * @internal\n */\nexport function saveTerrain(terrain: Terrain): TerrainSave {\n\treturn {\n\t\twidth: terrain.width,\n\t\tdepth: terrain.depth,\n\t\theights: packLayer(terrain.heights),\n\t\tlevels: packLayer(terrain.levels),\n\t\twater: packLayer(terrain.water),\n\t\twaterHeights: packLayer(terrain.waterHeights),\n\t\ttiles: packLayer(terrain.tiles),\n\t\tblocked: packLayer(terrain.blocked),\n\t\t...(Object.keys(terrain.cells).length && {\n\t\t\tcells: Object.fromEntries(Object.entries(terrain.cells).map(([id, layer]) => [id, packLayer(layer)]))\n\t\t}),\n\t\t...(terrain.bounds && { bounds: { ...terrain.bounds } })\n\t}\n}\n\n/**\n * A terrain back from `saveTerrain`\n *\n * @internal\n */\nexport function loadTerrain(save: TerrainSave): Terrain {\n\tconst { width, depth } = save\n\tconst cells = width * depth\n\tconst verts = (width + 1) * (depth + 1)\n\tconst packed = (key: keyof TerrainSave, length: number) => {\n\t\tconst unpacked = unpackBytes(save[key] as string, length)\n\t\tif (!unpacked) throw new Error(`Save: the ${key} of the terrain is not the size of it`)\n\t\treturn unpacked\n\t}\n\t// a layer of one value is that value in every cell\n\tconst bytes = (key: keyof TerrainSave, length: number) => {\n\t\tconst value = save[key]\n\t\treturn typeof value === 'number' ? new Uint8Array(length).fill(value) : packed(key, length)\n\t}\n\tconst floats = (key: keyof TerrainSave) => {\n\t\tconst value = save[key]\n\t\treturn typeof value === 'number' ? new Float32Array(verts).fill(value) : new Float32Array(packed(key, verts * 4).buffer)\n\t}\n\tconst terrain = new Terrain(width, depth, floats('heights'), bytes('levels', cells), {\n\t\twater: bytes('water', cells),\n\t\twaterHeights: floats('waterHeights'),\n\t\ttiles: bytes('tiles', cells),\n\t\tblocked: save.blocked === undefined ? undefined : bytes('blocked', cells),\n\t\tcells: Object.fromEntries(\n\t\t\tObject.entries(save.cells ?? {}).map(([id, value]) => {\n\t\t\t\tif (typeof value === 'number') return [id, new Uint8Array(cells).fill(value)]\n\t\t\t\tconst unpacked = unpackBytes(value, cells)\n\t\t\t\tif (!unpacked) throw new Error(`Save: the cells of ${id} are not the size of the terrain`)\n\t\t\t\treturn [id, unpacked]\n\t\t\t})\n\t\t)\n\t})\n\tif (save.bounds) terrain.bounds = { ...save.bounds }\n\treturn terrain\n}\n"],"mappings":";;;;;;;;AAuCA,SAAS,QAAQ,OAAsD;CACtE,MAAM,QAAQ,MAAM,MAAM;CAC1B,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK,IAAI,MAAM,OAAO,OAAO,OAAO,KAAA;CACtE,OAAO;AACR;AAEA,IAAM,aAAa,UAClB,QAAQ,KAAK,MAAM,iBAAiB,eAAe,UAAU,KAAK,IAAI,UAAU,KAAK;;;;;;AAOtF,SAAgB,YAAY,SAA+B;CAC1D,OAAO;EACN,OAAO,QAAQ;EACf,OAAO,QAAQ;EACf,SAAS,UAAU,QAAQ,OAAO;EAClC,QAAQ,UAAU,QAAQ,MAAM;EAChC,OAAO,UAAU,QAAQ,KAAK;EAC9B,cAAc,UAAU,QAAQ,YAAY;EAC5C,OAAO,UAAU,QAAQ,KAAK;EAC9B,SAAS,UAAU,QAAQ,OAAO;EAClC,GAAI,OAAO,KAAK,QAAQ,KAAK,CAAC,CAAC,UAAU,EACxC,OAAO,OAAO,YAAY,OAAO,QAAQ,QAAQ,KAAK,CAAC,CAAC,KAAK,CAAC,IAAI,WAAW,CAAC,IAAI,UAAU,KAAK,CAAC,CAAC,CAAC,EACrG;EACA,GAAI,QAAQ,UAAU,EAAE,QAAQ,EAAE,GAAG,QAAQ,OAAO,EAAE;CACvD;AACD;;;;;;AAOA,SAAgB,YAAY,MAA4B;CACvD,MAAM,EAAE,OAAO,UAAU;CACzB,MAAM,QAAQ,QAAQ;CACtB,MAAM,SAAS,QAAQ,MAAM,QAAQ;CACrC,MAAM,UAAU,KAAwB,WAAmB;EAC1D,MAAM,WAAW,YAAY,KAAK,MAAgB,MAAM;EACxD,IAAI,CAAC,UAAU,MAAM,IAAI,MAAM,aAAa,IAAI,sCAAsC;EACtF,OAAO;CACR;CAEA,MAAM,SAAS,KAAwB,WAAmB;EACzD,MAAM,QAAQ,KAAK;EACnB,OAAO,OAAO,UAAU,WAAW,IAAI,WAAW,MAAM,CAAC,CAAC,KAAK,KAAK,IAAI,OAAO,KAAK,MAAM;CAC3F;CACA,MAAM,UAAU,QAA2B;EAC1C,MAAM,QAAQ,KAAK;EACnB,OAAO,OAAO,UAAU,WAAW,IAAI,aAAa,KAAK,CAAC,CAAC,KAAK,KAAK,IAAI,IAAI,aAAa,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM;CACxH;CACA,MAAM,UAAU,IAAI,QAAQ,OAAO,OAAO,OAAO,SAAS,GAAG,MAAM,UAAU,KAAK,GAAG;EACpF,OAAO,MAAM,SAAS,KAAK;EAC3B,cAAc,OAAO,cAAc;EACnC,OAAO,MAAM,SAAS,KAAK;EAC3B,SAAS,KAAK,YAAY,KAAA,IAAY,KAAA,IAAY,MAAM,WAAW,KAAK;EACxE,OAAO,OAAO,YACb,OAAO,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,WAAW;GACrD,IAAI,OAAO,UAAU,UAAU,OAAO,CAAC,IAAI,IAAI,WAAW,KAAK,CAAC,CAAC,KAAK,KAAK,CAAC;GAC5E,MAAM,WAAW,YAAY,OAAO,KAAK;GACzC,IAAI,CAAC,UAAU,MAAM,IAAI,MAAM,sBAAsB,GAAG,iCAAiC;GACzF,OAAO,CAAC,IAAI,QAAQ;EACrB,CAAC,CACF;CACD,CAAC;CACD,IAAI,KAAK,QAAQ,QAAQ,SAAS,EAAE,GAAG,KAAK,OAAO;CACnD,OAAO;AACR"}

package/dist/testing.d.ts

@@ -9,7 +9,8 @@
  *     run(world, 5, () => knight.pos.x > 29)
  */
 import type { Entity } from './entity';
-import { type GameModule } from './game';
+import { type Rules } from './game';
+import { type Game } from './createGame';
 import type { PlayerInit } from './player';
 import type { Logger } from './log';
 import type { OrderInit } from './registry';
@@ -28,12 +29,12 @@ export declare const flatTerrain: (size?: number) => Terrain;
  */
 export declare const TEST_PLAYERS: PlayerInit[];
 /**
- * A small world of a game for a test: flat ground, a neutral player and two enemies (`TEST_PLAYERS`), the same every
+ * A small world of a game for a test (the game, `createGame`, or its module, `Rules`): flat ground, a neutral player and two enemies (`TEST_PLAYERS`), the same every
  * time (seed 7). Each of them is the test's to say otherwise
  *
- * @beta
+ * @public
  */
-export declare function testWorld(game: GameModule, options?: {
+export declare function testWorld(game: Game<unknown> | Rules, options?: {
     terrain?: Terrain;
     size?: number;
     players?: PlayerInit[];
@@ -43,16 +44,16 @@ export declare function testWorld(game: GameModule, options?: {
 /**
  * Steps the world for up to `seconds`, stopping early once `until` holds. Returns the time that went by in it
  *
- * @beta
+ * @public
  */
 export declare function run(world: World, seconds: number, until?: () => boolean): number;
 /**
  * Gives units an order, as their owner would: taken up at the next tick. `queue` adds it after what they are doing
  *
- * @beta
+ * @public
  */
 export declare const order: (world: World, entities: Entity[], init: OrderInit, queue?: boolean) => void;
 export { fixtureGame, fixtureMap } from './fixture';
-export { type BrainResults, type ComputerMeasures, defineSimulation, playGame, type Counted, type SimulatedGame, type SimulateOptions, simulate, type Simulation, winRates } from './simulate';
+export { type BrainResults, type ComputerMeasures, playGame, type Counted, type SimulatedGame, type SimulateOptions, simulate, type Simulation, winRates } from './simulate';
 export { brainOf, checkComputerSave, type ComputerWatch, type DecisionRecorder, type DecisionsApart, expectDecision, type FairPlay, fairPlay, type RecordedDecision, recordDecisions, thinkOnce, watchComputer, type WatchOptions } from './aiTesting';
 export { type Apart, checkDeterminism, type DeterminismOptions, type DeterminismReport, type Difference, firstDifference, worldFingerprint, worldHash, worldState } from './determinism';