@v12-engine/engine 0.1.0 → 0.4.0

package/dist/debug2.js

@@ -0,0 +1,76 @@
+//#region src/debug.ts
+/** The process's: what a world that says nothing starts with */
+var debugChecks = {
+	/** `statsOf` adds the stats up from scratch on every call and compares them with what it had cached */
+	stats: false,
+	/** Every tick, scenery (see `isScenery`) is checked for having anything that per-tick systems would have to see to */
+	scenery: false,
+	/** Every tick, `World.index` is checked against the entities: whose they are, which are heroes, which are shops */
+	index: false,
+	/** Every snapshot a session puts together is checked to have in sight exactly what testing every entity of the world would give */
+	sight: false,
+	/** What a snapshot tells of an entity as it was told last time, in whole or in part, is checked against describing it anew */
+	snapshots: false,
+	/** What a game's replicated events say is checked to be plain data, which could cross a network */
+	events: false,
+	/** Every think of every computer player's brain is checked against the invariants of `ai/checks.ts`: the first broken one throws */
+	ai: false
+};
+/**
+* A world's checks, of what it was made with (`CreateWorldOptions.checks`): all on or off, some of them (the rest the
+* process's), or the process's (`setDebugChecks`) when nothing is said
+*/
+function checksOf(given) {
+	if (typeof given === "boolean") return {
+		stats: given,
+		scenery: given,
+		index: given,
+		sight: given,
+		snapshots: given,
+		events: given,
+		ai: given
+	};
+	return {
+		...debugChecks,
+		...given
+	};
+}
+/**
+* Turns every check on or off for the worlds made from now on that say nothing of their own (`CreateWorldOptions.checks`),
+* and for computer players' brains
+*
+* @beta
+*/
+function setDebugChecks(enabled) {
+	debugChecks.stats = enabled;
+	debugChecks.scenery = enabled;
+	debugChecks.index = enabled;
+	debugChecks.sight = enabled;
+	debugChecks.snapshots = enabled;
+	debugChecks.events = enabled;
+	debugChecks.ai = enabled;
+}
+/**
+* Throws when a value is not plain data: numbers, text, booleans, lists and plain objects of them. An entity, a
+* map or a function in an event would only work while the screen and the simulation share a page
+*/
+function assertPlainData(value, what, path = "") {
+	if (value === null || value === void 0) return;
+	const type = typeof value;
+	if (type === "number" || type === "string" || type === "boolean") return;
+	if (type !== "object") throw new Error(`${what}: ${path || "it"} is a ${type}, which is not plain data`);
+	if (Array.isArray(value)) {
+		value.forEach((item, index) => assertPlainData(item, what, `${path}[${index}]`));
+		return;
+	}
+	const proto = Object.getPrototypeOf(value);
+	if (proto !== Object.prototype && proto !== null) {
+		const name = value.constructor?.name ?? "object";
+		throw new Error(`${what}: ${path || "it"} is a ${name}, which is not plain data. Give entities by id`);
+	}
+	for (const [key, item] of Object.entries(value)) assertPlainData(item, what, path ? `${path}.${key}` : key);
+}
+//#endregion
+export { assertPlainData, checksOf, debugChecks, setDebugChecks };
+
+//# sourceMappingURL=debug2.js.map

package/dist/debug2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug2.js","names":[],"sources":["../src/debug.ts"],"sourcesContent":["/**\n * Checks the engine can run on itself, for tests and development. Each one redoes or re-verifies work\n * that the engine normally skips or caches, and throws as soon as the shortcut gave a different answer.\n * They are slow; a real game leaves them off. A world's are its own (`world.checks`, `CreateWorldOptions.checks`);\n * these are what a world that says nothing starts with (`setDebugChecks`), and what a computer player's brain, which\n * has no world, reads\n *\n * @beta\n */\nexport interface DebugChecks {\n\t/** Whether `statsOf` is checked against adding the stats up from scratch */\n\tstats: boolean\n\t/** Whether scenery is checked every tick for having nothing the per-tick systems should see to */\n\tscenery: boolean\n\t/** Whether `World.index` is checked every tick against the entities */\n\tindex: boolean\n\t/** Whether each snapshot's sight is checked against testing every entity of the world */\n\tsight: boolean\n\t/** Whether what a snapshot tells of an entity again from last time is checked against describing it anew */\n\tsnapshots: boolean\n\t/** Whether replicated events are checked to be plain data that could cross a network */\n\tevents: boolean\n\t/** Whether every think of every computer player's brain is checked against the invariants of `ai/checks.ts` */\n\tai: boolean\n}\n\n/** The process's: what a world that says nothing starts with */\nexport const debugChecks: DebugChecks = {\n\t/** `statsOf` adds the stats up from scratch on every call and compares them with what it had cached */\n\tstats: false,\n\t/** Every tick, scenery (see `isScenery`) is checked for having anything that per-tick systems would have to see to */\n\tscenery: false,\n\t/** Every tick, `World.index` is checked against the entities: whose they are, which are heroes, which are shops */\n\tindex: false,\n\t/** Every snapshot a session puts together is checked to have in sight exactly what testing every entity of the world would give */\n\tsight: false,\n\t/** What a snapshot tells of an entity as it was told last time, in whole or in part, is checked against describing it anew */\n\tsnapshots: false,\n\t/** What a game's replicated events say is checked to be plain data, which could cross a network */\n\tevents: false,\n\t/** Every think of every computer player's brain is checked against the invariants of `ai/checks.ts`: the first broken one throws */\n\tai: false\n}\n\n/**\n * A world's checks, of what it was made with (`CreateWorldOptions.checks`): all on or off, some of them (the rest the\n * process's), or the process's (`setDebugChecks`) when nothing is said\n */\nexport function checksOf(given: boolean | Partial<DebugChecks> | undefined): DebugChecks {\n\tif (typeof given === 'boolean') return { stats: given, scenery: given, index: given, sight: given, snapshots: given, events: given, ai: given }\n\treturn { ...debugChecks, ...given }\n}\n\n/**\n * Turns every check on or off for the worlds made from now on that say nothing of their own (`CreateWorldOptions.checks`),\n * and for computer players' brains\n *\n * @beta\n */\nexport function setDebugChecks(enabled: boolean): void {\n\tdebugChecks.stats = enabled\n\tdebugChecks.scenery = enabled\n\tdebugChecks.index = enabled\n\tdebugChecks.sight = enabled\n\tdebugChecks.snapshots = enabled\n\tdebugChecks.events = enabled\n\tdebugChecks.ai = enabled\n}\n\n/**\n * Throws when a value is not plain data: numbers, text, booleans, lists and plain objects of them. An entity, a\n * map or a function in an event would only work while the screen and the simulation share a page\n */\nexport function assertPlainData(value: unknown, what: string, path = ''): void {\n\tif (value === null || value === undefined) return\n\tconst type = typeof value\n\tif (type === 'number' || type === 'string' || type === 'boolean') return\n\tif (type !== 'object') throw new Error(`${what}: ${path || 'it'} is a ${type}, which is not plain data`)\n\tif (Array.isArray(value)) {\n\t\tvalue.forEach((item, index) => assertPlainData(item, what, `${path}[${index}]`))\n\t\treturn\n\t}\n\tconst proto = Object.getPrototypeOf(value)\n\tif (proto !== Object.prototype && proto !== null) {\n\t\tconst name = (value as object).constructor?.name ?? 'object'\n\t\tthrow new Error(`${what}: ${path || 'it'} is a ${name}, which is not plain data. Give entities by id`)\n\t}\n\tfor (const [key, item] of Object.entries(value)) assertPlainData(item, what, path ? `${path}.${key}` : key)\n}\n"],"mappings":";;AA2BA,IAAa,cAA2B;;CAEvC,OAAO;;CAEP,SAAS;;CAET,OAAO;;CAEP,OAAO;;CAEP,WAAW;;CAEX,QAAQ;;CAER,IAAI;AACL;;;;;AAMA,SAAgB,SAAS,OAAgE;CACxF,IAAI,OAAO,UAAU,WAAW,OAAO;EAAE,OAAO;EAAO,SAAS;EAAO,OAAO;EAAO,OAAO;EAAO,WAAW;EAAO,QAAQ;EAAO,IAAI;CAAM;CAC9I,OAAO;EAAE,GAAG;EAAa,GAAG;CAAM;AACnC;;;;;;;AAQA,SAAgB,eAAe,SAAwB;CACtD,YAAY,QAAQ;CACpB,YAAY,UAAU;CACtB,YAAY,QAAQ;CACpB,YAAY,QAAQ;CACpB,YAAY,YAAY;CACxB,YAAY,SAAS;CACrB,YAAY,KAAK;AAClB;;;;;AAMA,SAAgB,gBAAgB,OAAgB,MAAc,OAAO,IAAU;CAC9E,IAAI,UAAU,QAAQ,UAAU,KAAA,GAAW;CAC3C,MAAM,OAAO,OAAO;CACpB,IAAI,SAAS,YAAY,SAAS,YAAY,SAAS,WAAW;CAClE,IAAI,SAAS,UAAU,MAAM,IAAI,MAAM,GAAG,KAAK,IAAI,QAAQ,KAAK,QAAQ,KAAK,0BAA0B;CACvG,IAAI,MAAM,QAAQ,KAAK,GAAG;EACzB,MAAM,SAAS,MAAM,UAAU,gBAAgB,MAAM,MAAM,GAAG,KAAK,GAAG,MAAM,EAAE,CAAC;EAC/E;CACD;CACA,MAAM,QAAQ,OAAO,eAAe,KAAK;CACzC,IAAI,UAAU,OAAO,aAAa,UAAU,MAAM;EACjD,MAAM,OAAQ,MAAiB,aAAa,QAAQ;EACpD,MAAM,IAAI,MAAM,GAAG,KAAK,IAAI,QAAQ,KAAK,QAAQ,KAAK,+CAA+C;CACtG;CACA,KAAK,MAAM,CAAC,KAAK,SAAS,OAAO,QAAQ,KAAK,GAAG,gBAAgB,MAAM,MAAM,OAAO,GAAG,KAAK,GAAG,QAAQ,GAAG;AAC3G"}

package/dist/debugCommands.d.ts

@@ -40,7 +40,7 @@ export declare const revealCommand: DefinedCommand<"debug.reveal", {
     on: Check<boolean>;
 }>;
 /**
- * The whole map explored for everyone, as a map that starts explored has it (`FogRules.startExplored`): the fog stays,
+ * The whole map explored for everyone, as a map that starts explored has it (`FogSettings.startExplored`): the fog stays,
  * over what is not seen now, but the ground is dim, not black, and what stands on it and is no player's is known. Or no
  * longer: each team has explored what it sees now, and forgets what it does not
  *
@@ -148,7 +148,7 @@ export declare const killCommand: DefinedCommand<"debug.kill", {
 }>;
 /**
  * Changes a field of a definition while the game runs, as the editor's Data panel tries it: only one the game lets be
- * changed (`GameModule.editable`), and for players allowed the debug tools
+ * changed (`Rules.editable`), and for players allowed the debug tools
  *
  * @beta
  */
@@ -161,7 +161,7 @@ export declare const redefineCommand: DefinedCommand<"debug.redefine", {
 /**
  * An object placed on the map put in the world as the map's are as the world is made (`spawnMapObject`): its type,
  * owner, where it stands and how it is turned, and the rest the map says of it (its health, level, items, the game's
- * fields, its orders), kept as the entity of that object (`World.mapEntities`): what the editor's Play here sends as
+ * fields, its orders), kept as the entity of that object (`World.fromMap`): what the editor's Play here sends as
  * something is placed on the map while it plays (EQ10). A building where there is no room is refused, as `debug.spawn`
  * refuses it
  *
@@ -171,7 +171,7 @@ export declare const mapObjectCommand: DefinedCommand<"debug.mapObject", {
     object: Check<MapObject>;
 }>;
 /**
- * Moves what an object of the map became (`World.mapEntities`, by the object's id) where it stands on the map now,
+ * Moves what an object of the map became (`World.fromMap`, by the object's id) where it stands on the map now,
  * turned as it is: a unit is put there (`World.place`), the way there not its concern. A structure is not moved: the
  * editor takes it away and puts it down again
  *
@@ -183,7 +183,7 @@ export declare const placeCommand: DefinedCommand<"debug.place", {
     facing: Check<number | undefined>;
 }>;
 /**
- * Takes what objects of the map became (`World.mapEntities`, by the objects' ids) out of the world, whatever they
+ * Takes what objects of the map became (`World.fromMap`, by the objects' ids) out of the world, whatever they
  * are, scenery included: no corpse is left. What the editor's Play here sends as something is taken off the map
  *
  * @beta
@@ -210,4 +210,4 @@ export declare const toldGround: import("./replication").ReplicatedEvent;
  */
 export declare const debugCommands: CommandDef[];
 /** What a player who may use the debug commands is told of them (`Snapshot.debug`): the switches on, and whether the map started explored */
-export declare const debugPart: import("./replication").SnapshotPart<keyof import(".").Snapshot>;
+export declare const debugPart: import("./replication").SnapshotField<keyof import(".").Snapshot>;

package/dist/debugCommands.js

@@ -0,0 +1,537 @@
+import { hypot } from "./exactMath.js";
+import { footprintOf } from "./defs.js";
+import { gameOver, groundReshaped } from "./engineEvents.js";
+import { teamMemory } from "./session/memory.js";
+import { replicateEvent, snapshotField } from "./replication.js";
+import { earn } from "./player.js";
+import { grantXp, heroesOf, setHeroLevel } from "./hero.js";
+import { Invalid, bool, id, ids, isObject, number, object, oneOf, optional, point, string } from "./fields.js";
+import { createItem, giveItem } from "./items.js";
+import { defeat } from "./systems/victory.js";
+import { defineCommand } from "./commands.js";
+import { corpses } from "./summons.js";
+import { COPY_OF, DATA_KINDS, blankDefinition, definitionIn, editableFields, fitValue, nested, pathCheck, valueCheck } from "./gameData.js";
+import { terrainPatchProblem } from "./ground.js";
+import { giveMapOrders, spawnMapObject } from "./mapObjects.js";
+//#region src/debugCommands.ts
+/**
+* A debug command of a game's or a scene's own: one that goes through only for players allowed the debug tools
+* (`world.debugPlayers`), and tells others so. Otherwise like `defineCommand`
+*
+* @beta
+*/
+function defineDebugCommand(type, fields, execute) {
+	return defineCommand(type, fields, (world, player, command) => {
+		if (!world.debugPlayers.has(player)) {
+			world.message(player, { key: "debugNotAllowed" });
+			return;
+		}
+		execute(world, player, command);
+	});
+}
+/**
+* A prefab of the game's put down where it says, for the sender, turned as said: to try one out, and for the editor's Play
+*
+* @beta
+*/
+var spawnPrefabCommand = defineDebugCommand("debug.spawnPrefab", {
+	prefab: string,
+	at: point,
+	facing: optional(number)
+}, (world, player, command) => {
+	if (!world.registry.prefabs.has(command.prefab)) return world.message(player, {
+		key: "unknownPrefab",
+		params: { prefab: command.prefab }
+	});
+	world.spawnPrefab(command.prefab, {
+		at: command.at,
+		owner: player,
+		facing: command.facing
+	});
+});
+/**
+* A switch for trying things out: abilities used again at once, abilities that cost no mana, the units of those who may
+* use the debug tools unharmed (`World.cheats`)
+*
+* @beta
+*/
+var cheatCommand = defineDebugCommand("debug.cheat", {
+	cheat: oneOf("noCooldowns", "noManaCosts", "invulnerable"),
+	on: bool
+}, (world, _player, command) => {
+	world.cheats[command.cheat] = command.on;
+});
+/**
+* Lifts the fog for the sender's team, or puts it back: in the simulation itself, so that units react to what is shown
+*
+* @beta
+*/
+var revealCommand = defineDebugCommand("debug.reveal", { on: bool }, (world, player, command) => {
+	world.fog.setRevealed(world.player(player).team, command.on);
+});
+/**
+* The whole map explored for everyone, as a map that starts explored has it (`FogSettings.startExplored`): the fog stays,
+* over what is not seen now, but the ground is dim, not black, and what stands on it and is no player's is known. Or no
+* longer: each team has explored what it sees now, and forgets what it does not
+*
+* @beta
+*/
+var exploreCommand = defineDebugCommand("debug.explore", { on: bool }, (world, _player, command) => {
+	world.fog.exploreFromStart(command.on);
+	for (const [team, memory] of Object.entries(world.state(teamMemory))) {
+		memory.startKnown = false;
+		if (command.on) continue;
+		for (const [id, state] of Object.entries(memory.structures)) if (!world.fog.isVisible(Number(team), state.x, state.z)) delete memory.structures[Number(id)];
+	}
+});
+/**
+* The time of day, in a game with days and nights
+*
+* @beta
+*/
+var hourCommand = defineDebugCommand("debug.hour", { hour: number }, (world, _player, command) => {
+	if (world.registry.day) world.clock.setHour((command.hour % 24 + 24) % 24);
+});
+/**
+* How fast the game goes, 0 to pause, 8 at most: whoever runs it (a session in the page, a server) goes by it
+*
+* @beta
+*/
+var speedCommand = defineDebugCommand("debug.speed", { speed: number }, (world, _player, command) => {
+	world.cheats.speed = Math.min(Math.max(command.speed, 0), 8);
+});
+/**
+* Creates something at a point, for a player: a building or a resource where there is room, or a group of units
+* (`count`, 50 at most). `hidden`: what can be invisible is out of sight from the start
+*
+* @beta
+*/
+var spawnCommand = defineDebugCommand("debug.spawn", {
+	unitType: string,
+	owner: id,
+	point,
+	count: optional(number),
+	hidden: optional(bool)
+}, (world, player, command) => {
+	if (!world.registry.units.has(command.unitType) || !world.players.has(command.owner)) return;
+	const def = world.registry.unit(command.unitType);
+	const at = command.point;
+	if (def.kind !== "unit") {
+		const fp = footprintOf(def);
+		const cell = world.grid.cellFor(at.x, at.z, fp.w, fp.d);
+		if (!world.grid.canPlace(cell.x, cell.z, fp.w, fp.d)) world.message(player, { key: "noRoomHere" });
+		else world.spawn(def.id, command.owner, at);
+		return;
+	}
+	const count = Math.min(Math.max(Math.round(command.count ?? 1), 1), 50);
+	const columns = Math.ceil(Math.sqrt(count));
+	const spacing = def.radius * 2 + .4;
+	for (let i = 0; i < count; i++) {
+		const column = i % columns - (columns - 1) / 2;
+		const row = Math.floor(i / columns) - (Math.ceil(count / columns) - 1) / 2;
+		const entity = world.spawn(def.id, command.owner, {
+			x: at.x + column * spacing,
+			z: at.z - row * spacing
+		});
+		if (command.hidden && entity.unseenIn !== null) entity.unseenIn = 0;
+	}
+});
+/**
+* A brush: fills a circle with what stands on the grid (trees, rocks), thinner towards its edge, wherever there is room;
+* or, with `erase`, clears it of that type
+*
+* @beta
+*/
+var paintCommand = defineDebugCommand("debug.paint", {
+	unitType: string,
+	owner: id,
+	point,
+	radius: number,
+	erase: bool
+}, (world, _player, command) => {
+	if (!world.registry.units.has(command.unitType)) return;
+	const def = world.registry.unit(command.unitType);
+	const { point: at } = command;
+	const radius = Math.min(Math.max(command.radius, .5), 20);
+	if (command.erase) {
+		for (const entity of [...world.entities.values()]) if (entity.def.id === def.id && hypot(entity.pos.x - at.x, entity.pos.z - at.z) <= radius) world.kill(entity, void 0, false, "removed");
+		return;
+	}
+	if (def.kind === "unit" || !world.players.has(command.owner)) return;
+	const fp = footprintOf(def);
+	for (let z = Math.floor(at.z - radius); z <= at.z + radius; z += fp.d) for (let x = Math.floor(at.x - radius); x <= at.x + radius; x += fp.w) {
+		const centre = {
+			x: x + fp.w / 2,
+			z: z + fp.d / 2
+		};
+		const distance = hypot(centre.x - at.x, centre.z - at.z);
+		if (distance > radius) continue;
+		const chance = (x * 73856093 ^ z * 19349663) >>> 0;
+		if (distance > radius * .6 && chance % 100 < (distance / radius - .6) / .4 * 70) continue;
+		if (!world.grid.canPlace(x, z, fp.w, fp.d)) continue;
+		world.spawn(def.id, command.owner, centre);
+	}
+});
+/**
+* Gives the sender this much of every resource
+*
+* @beta
+*/
+var giveCommand = defineDebugCommand("debug.give", { amount: number }, (world, player, command) => {
+	for (const resource of world.registry.resources) earn(world.player(player).resources, resource.id, command.amount);
+});
+/**
+* Gives the sender's heroes this much experience
+*
+* @beta
+*/
+var experienceCommand = defineDebugCommand("debug.experience", { amount: number }, (world, player, command) => {
+	for (const hero of heroesOf(world, player)) if (hero.alive) grantXp(world, hero, command.amount);
+});
+/**
+* Puts units at a point, side by side, wherever they stood: structures stay where they were built. The way there is
+* not their concern (`World.place`)
+*
+* @internal
+*/
+var teleportCommand = defineDebugCommand("debug.teleport", {
+	entities: ids,
+	point
+}, (world, _player, command) => {
+	const units = command.entities.flatMap((entityId) => {
+		const entity = world.get(entityId);
+		return entity?.alive && entity.isUnit ? [entity] : [];
+	});
+	const columns = Math.ceil(Math.sqrt(units.length));
+	units.forEach((entity, i) => {
+		const spacing = entity.def.radius * 2 + .4;
+		const column = i % columns - (columns - 1) / 2;
+		const row = Math.floor(i / columns) - (Math.ceil(units.length / columns) - 1) / 2;
+		world.place(entity, {
+			x: command.point.x + column * spacing,
+			z: command.point.z - row * spacing
+		});
+	});
+});
+/**
+* Gives what it names to another player (`World.setOwner`): what it was doing is called off
+*
+* @internal
+*/
+var setOwnerCommand = defineDebugCommand("debug.setOwner", {
+	entities: ids,
+	owner: id
+}, (world, _player, command) => {
+	if (!world.players.has(command.owner)) return;
+	for (const entityId of command.entities) {
+		const entity = world.get(entityId);
+		if (entity?.alive) world.setOwner(entity, command.owner);
+	}
+});
+/**
+* Puts an item of the game's in the first free slot of what carries things
+*
+* @beta
+*/
+var giveItemCommand = defineDebugCommand("debug.giveItem", {
+	entity: id,
+	item: string
+}, (world, _player, command) => {
+	const entity = world.get(command.entity);
+	if (!entity?.alive || !world.registry.items.has(command.item)) return;
+	giveItem(world, entity, createItem(world, command.item));
+});
+/**
+* Researches an upgrade for the sender, to the level asked (its last when left out), at once and for nothing: what it
+* does to the units there are runs for each level it gains
+*
+* @internal
+*/
+var researchCommand = defineDebugCommand("debug.research", {
+	upgrade: string,
+	level: optional(number)
+}, (world, player, command) => {
+	if (!world.registry.upgrades.has(command.upgrade)) return;
+	const def = world.registry.upgrade(command.upgrade);
+	const who = world.player(player);
+	const to = Math.min(Math.max(Math.round(command.level ?? def.maxLevel ?? 1), 0), def.maxLevel ?? 1);
+	for (let level = (who.upgrades.get(command.upgrade) ?? 0) + 1; level <= to; level++) {
+		who.setUpgrade(command.upgrade, level);
+		if (def.apply) {
+			for (const entity of [...world.index.ownedBy(player)]) if (entity.alive) def.apply(world, entity, level);
+		}
+	}
+	who.researching.delete(command.upgrade);
+});
+/**
+* Raises heroes to a level (never down, and no further than they can go: `setHeroLevel`)
+*
+* @beta
+*/
+var setLevelCommand = defineDebugCommand("debug.setLevel", {
+	entities: ids,
+	level: number
+}, (world, _player, command) => {
+	for (const entityId of command.entities) {
+		const entity = world.get(entityId);
+		if (entity?.alive) setHeroLevel(world, entity, command.level);
+	}
+});
+/**
+* Wins the game for the sender's team: the others are out, and it is over. A game with a way to win of its own is
+* ended all the same
+*
+* @beta
+*/
+var winCommand = defineDebugCommand("debug.win", {}, (world, player) => {
+	if (world.winner !== null) return;
+	const team = world.player(player).team;
+	for (const other of world.players.values()) {
+		if (other.neutral || other.creeps) continue;
+		other.established = true;
+		if (other.team !== team && !other.defeated) defeat(world, other.id);
+	}
+	world.winner = team;
+	world.events.emit(gameOver, { winner: team });
+});
+/**
+* Puts the sender out of the game, as if beaten: the others play on, or win by the game's own rule
+*
+* @beta
+*/
+var loseCommand = defineDebugCommand("debug.lose", {}, (world, player) => {
+	const who = world.player(player);
+	if (who.neutral || who.creeps || who.defeated || world.winner !== null) return;
+	who.established = true;
+	defeat(world, player);
+});
+/**
+* Kills what it names, whoever's it is: what cannot be hurt included, but not scenery the map is made of
+*
+* @beta
+*/
+var killCommand = defineDebugCommand("debug.kill", { entities: ids }, (world, _player, command) => {
+	for (const entityId of command.entities) {
+		const entity = world.get(entityId);
+		if (entity?.alive && !entity.def.invulnerable) world.kill(entity, void 0, false, "removed");
+	}
+});
+/**
+* Changes a field of a definition while the game runs, as the editor's Data panel tries it: only one the game lets be
+* changed (`Rules.editable`), and for players allowed the debug tools
+*
+* @beta
+*/
+var redefineCommand = defineDebugCommand("debug.redefine", {
+	kind: oneOf(...DATA_KINDS),
+	id: string,
+	path: pathCheck,
+	value: valueCheck
+}, (world, player, command) => {
+	const def = definitionIn(world.registry, command.kind, command.id);
+	if (!def && command.path === "copyOf" && typeof command.value === "string") {
+		const base = definitionIn(world.registry, command.kind, command.value);
+		if (base && editableFields(world.registry.module, command.kind, base).length) world.redefine(command.kind, command.id, { [COPY_OF]: command.value });
+		return;
+	}
+	if (!def && command.path === "new" && command.value === true) {
+		if (editableFields(world.registry.module, command.kind, blankDefinition(command.kind, command.id)).length) world.redefine(command.kind, command.id, { ["new"]: true });
+		return;
+	}
+	if (!def) return;
+	const field = editableFields(world.registry.module, command.kind, def).find((each) => each.path === command.path);
+	const fit = field ? fitValue(field, command.value) : { error: `${command.path} cannot be changed` };
+	if ("error" in fit) world.message(player, {
+		key: "dataRefused",
+		params: { why: fit.error }
+	});
+	else world.redefine(command.kind, command.id, nested(command.path, fit.value));
+});
+/** The most of anything a value of a map's own may hold, and as deep: a field of the game's, not a file */
+var PLAIN_MOST = 1e4;
+var PLAIN_DEPTH = 16;
+/** What the map's own fields hold (`MapObject.data`): numbers, words, switches, lists and objects of them, and nothing else */
+var plain = (value, path) => {
+	let count = 0;
+	const copy = (each, at, depth) => {
+		if (++count > PLAIN_MOST || depth > PLAIN_DEPTH) throw new Invalid(`${path} is more than a field of the map holds`);
+		if (each === null || typeof each === "boolean" || typeof each === "string") return each;
+		if (typeof each === "number") return number(each, at);
+		if (Array.isArray(each)) return each.map((item, i) => copy(item, `${at}[${i}]`, depth + 1));
+		if (isObject(each)) return Object.fromEntries(Object.entries(each).map(([key, item]) => [key, copy(item, `${at}.${key}`, depth + 1)]));
+		throw new Invalid(`${at} is not a value of the map's`);
+	};
+	return copy(value, path, 0);
+};
+/** A list of what a check takes, so long at most */
+var listOf = (check, most) => (value, path) => {
+	if (!Array.isArray(value) || value.length > most) throw new Invalid(`${path} is a list of at most ${most}`);
+	return value.map((item, i) => check(item, `${path}[${i}]`));
+};
+/** What a cell of the ground holds: 0 to 255 */
+var byte = (value, path) => {
+	if (!Number.isInteger(value) || value < 0 || value > 255) throw new Invalid(`${path} is a whole number of 0 to 255`);
+	return value;
+};
+/** The most cells a patch of the ground has: a map of 2048 a side */
+var MOST_CELLS = 4198401;
+/** A patch of the ground (`TerrainPatch`), each layer the size the ground says, checked as it is put in */
+var terrainPatchCheck = (value, path) => {
+	return object({
+		x: id,
+		z: id,
+		width: id,
+		depth: id,
+		heights: listOf(number, MOST_CELLS),
+		waterHeights: listOf(number, MOST_CELLS),
+		levels: listOf(byte, MOST_CELLS),
+		water: listOf(byte, MOST_CELLS),
+		tiles: listOf(byte, MOST_CELLS),
+		blocked: listOf(byte, MOST_CELLS),
+		cells: optional((layers, at) => {
+			if (!isObject(layers)) throw new Invalid(`${at} is the layers of cells by id`);
+			return Object.fromEntries(Object.entries(layers).map(([layer, cells]) => [string(layer, at), listOf(byte, MOST_CELLS)(cells, `${at}.${layer}`)]));
+		})
+	})(value, path);
+};
+/** An object of the map (`MapObject`), as the editor has it: what of it the world reads, checked. Not turned, and as big as its type, when it does not say */
+var mapObjectCheck = (value, path) => ({
+	facing: 0,
+	scale: 1,
+	...object({
+		id,
+		type: string,
+		owner: id,
+		x: number,
+		z: number,
+		facing: optional(number),
+		scale: optional(number),
+		look: optional(string),
+		drops: optional(string),
+		name: optional(string),
+		health: optional(number),
+		mana: optional(number),
+		level: optional(number),
+		abilities: optional(plain),
+		items: optional(listOf(string, 100)),
+		amount: optional(number),
+		underConstruction: optional(bool),
+		lifetime: optional(number),
+		orders: optional(plain),
+		data: optional(plain)
+	})(value, path)
+});
+/**
+* An object placed on the map put in the world as the map's are as the world is made (`spawnMapObject`): its type,
+* owner, where it stands and how it is turned, and the rest the map says of it (its health, level, items, the game's
+* fields, its orders), kept as the entity of that object (`World.fromMap`): what the editor's Play here sends as
+* something is placed on the map while it plays (EQ10). A building where there is no room is refused, as `debug.spawn`
+* refuses it
+*
+* @beta
+*/
+var mapObjectCommand = defineDebugCommand("debug.mapObject", { object: mapObjectCheck }, (world, player, command) => {
+	const { object } = command;
+	if (!world.registry.units.has(object.type) || !world.players.has(object.owner)) return;
+	const def = world.registry.unit(object.type);
+	if (def.kind !== "unit") {
+		const fp = footprintOf(def);
+		const cell = world.grid.cellFor(object.x, object.z, fp.w, fp.d);
+		if (!world.grid.canPlace(cell.x, cell.z, fp.w, fp.d)) return world.message(player, { key: "noRoomHere" });
+	}
+	const entity = spawnMapObject(world, object);
+	if (Array.isArray(object.orders) && object.orders.length) giveMapOrders(world, entity, object.orders);
+});
+/**
+* Moves what an object of the map became (`World.fromMap`, by the object's id) where it stands on the map now,
+* turned as it is: a unit is put there (`World.place`), the way there not its concern. A structure is not moved: the
+* editor takes it away and puts it down again
+*
+* @beta
+*/
+var placeCommand = defineDebugCommand("debug.place", {
+	object: id,
+	point,
+	facing: optional(number)
+}, (world, _player, command) => {
+	const entity = world.get(world.fromMap.get(command.object));
+	if (!entity?.alive || entity.isStructure) return;
+	world.place(entity, command.point);
+	if (command.facing !== void 0) entity.facing = command.facing;
+});
+/**
+* Takes what objects of the map became (`World.fromMap`, by the objects' ids) out of the world, whatever they
+* are, scenery included: no corpse is left. What the editor's Play here sends as something is taken off the map
+*
+* @beta
+*/
+var unplaceCommand = defineDebugCommand("debug.unplace", { objects: ids }, (world, _player, command) => {
+	const gone = /* @__PURE__ */ new Set();
+	for (const object of command.objects) {
+		const entity = world.get(world.fromMap.get(object));
+		world.fromMap.delete(object);
+		if (!entity?.alive) continue;
+		world.kill(entity, void 0, false, "removed");
+		gone.add(entity.id);
+	}
+	const lying = world.state(corpses);
+	if (lying.some((corpse) => gone.has(corpse.id))) world.setState(corpses, lying.filter((corpse) => !gone.has(corpse.id)));
+});
+/**
+* Reshapes a part of the ground as the patch has it (`World.reshapeGround`): what the editor's Play here sends of the
+* map's ground as its heights, cliffs, water and paint are edited while it plays. A patch that does not fit the ground
+* is refused
+*
+* @beta
+*/
+var groundCommand = defineDebugCommand("debug.ground", { patch: terrainPatchCheck }, (world, player, command) => {
+	const problem = terrainPatchProblem(world.terrain, command.patch);
+	if (problem) return world.message(player, {
+		key: "dataRefused",
+		params: { why: problem }
+	});
+	world.reshapeGround(command.patch);
+});
+/** The ground reshaped (`World.reshapeGround`): to everyone, as it is now */
+var toldGround = replicateEvent(groundReshaped, "ground", ({ patch }) => ({
+	type: "ground",
+	patch: structuredClone(patch)
+}));
+/**
+* The debug commands of the engine, which every game has; they go through only for who may use them
+*
+* @beta
+*/
+var debugCommands = [
+	cheatCommand,
+	revealCommand,
+	exploreCommand,
+	hourCommand,
+	speedCommand,
+	spawnCommand,
+	paintCommand,
+	giveCommand,
+	experienceCommand,
+	killCommand,
+	spawnPrefabCommand,
+	teleportCommand,
+	setOwnerCommand,
+	giveItemCommand,
+	researchCommand,
+	setLevelCommand,
+	winCommand,
+	loseCommand,
+	mapObjectCommand,
+	placeCommand,
+	unplaceCommand,
+	groundCommand
+];
+/** What a player who may use the debug commands is told of them (`Snapshot.debug`): the switches on, and whether the map started explored */
+var debugPart = snapshotField("debug", ({ world, player }) => world.debugPlayers.has(player) ? {
+	...world.cheats,
+	explored: world.fog.exploredFromStart
+} : void 0, true);
+//#endregion
+export { cheatCommand, debugCommands, debugPart, defineDebugCommand, experienceCommand, exploreCommand, giveCommand, giveItemCommand, groundCommand, hourCommand, killCommand, loseCommand, mapObjectCommand, paintCommand, placeCommand, redefineCommand, researchCommand, revealCommand, setLevelCommand, setOwnerCommand, spawnCommand, spawnPrefabCommand, speedCommand, teleportCommand, toldGround, unplaceCommand, winCommand };
+
+//# sourceMappingURL=debugCommands.js.map