@v12-engine/engine 0.1.0 → 0.4.0

package/dist/gameData.js

@@ -0,0 +1,1690 @@
+import { CORE_STAT_KEYS } from "./defs.js";
+import { defineComponent } from "./components.js";
+import { defineEngineEvent } from "./events.js";
+import { replicateEvent } from "./replication.js";
+import { callingsOf, withCallings } from "./callings.js";
+import { COMMON_EFFECT_FIELDS } from "./abilities/effectFields.js";
+import { dataCellLayersProblem, layCellLayerData } from "./cellLayers.js";
+import { Invalid, string } from "./fields.js";
+import { summonEffects } from "./summons.js";
+import { dispelEffects } from "./abilities/dispel.js";
+import { coreEffects } from "./abilities/effects/core.js";
+import { dataDefaults, dataDefaultsProblem } from "./defaultSets.js";
+import { hasPack } from "./packs/pack.js";
+import { rootLogger } from "./log.js";
+//#region src/gameData.ts
+/**
+* The kinds of definition a game's data is kept for, by the field of the game module they are listed in
+*
+* @beta
+*/
+var DATA_KINDS = [
+	"units",
+	"abilities",
+	"buffs",
+	"items",
+	"upgrades",
+	"races"
+];
+/**
+* What a definition of each kind must have besides its id and its name, as the type says (`UnitTypeDef.radius`...),
+* with what one made of nothing starts as (`NEW_DEFINITION`: the Data panel's New, from empty). A unit type is a unit
+* unless its `kind` says otherwise
+*
+* @beta
+*/
+var REQUIRED_FIELDS = {
+	units: {
+		kind: "unit",
+		radius: .5,
+		stats: { health: 100 },
+		sight: 8
+	},
+	abilities: {
+		target: "none",
+		effects: []
+	},
+	buffs: {},
+	items: { cost: {} },
+	upgrades: {
+		cost: {},
+		researchTime: 30,
+		effects: []
+	},
+	races: {}
+};
+/**
+* What a definition in a `data.json` says to be one of its own, made of nothing, where the game has none by its id
+* (`{ "new": true, "name": "Peon", "stats": { "health": 220 } }`): what its kind must have (`REQUIRED_FIELDS`), its
+* name its id until it says, with what else is said over it. A unit type's `kind` is taken from it too
+*
+* @beta
+*/
+var NEW_DEFINITION = "new";
+/**
+* A definition made of nothing, by an id: what its kind must have (`REQUIRED_FIELDS`), named by its id
+*
+* @beta
+*/
+function blankDefinition(kind, id, unitKind) {
+	const required = structuredClone(REQUIRED_FIELDS[kind]);
+	if (kind === "units" && unitKind) required.kind = unitKind;
+	return {
+		id,
+		name: id,
+		...required
+	};
+}
+/** The kinds of thing a unit type made of nothing may be (`UnitTypeDef.kind`) */
+var UNIT_KINDS = [
+	"unit",
+	"building",
+	"resource"
+];
+/**
+* What a definition in a `data.json` is a copy of, when the game has none by its id: `{ "copyOf": "footman", "name":
+* "Champion" }` is a footman by another name. The copy is the definition it names, with what else is said over it,
+* and knows what it is a copy of (`basedOn`)
+*
+* @beta
+*/
+var COPY_OF = "copyOf";
+/** The fields a tag and a calling of a `data.json` may say, and what each holds */
+var TAG_FIELDS = {
+	name: "string",
+	description: "string",
+	icon: "string",
+	color: "string",
+	filter: "boolean"
+};
+var CALLING_FIELDS = {
+	name: "string",
+	description: "string",
+	icon: "string",
+	color: "string"
+};
+/**
+* Why what a `data.json` says of its tags or callings (`GameData.tags`, `callings`) is not right, where it first is
+* not: nothing when it is
+*
+* @beta
+*/
+function dataEntriesProblem(section, said) {
+	if (!isRecord(said)) return `${section} is no object by id`;
+	const known = section === "tags" ? TAG_FIELDS : CALLING_FIELDS;
+	for (const [id, entry] of Object.entries(said)) {
+		if (!isRecord(entry)) return `${section}.${id} is no object`;
+		for (const [field, value] of Object.entries(entry)) {
+			if (!(field in known)) return `${section}.${id}.${field} is nothing a ${section === "tags" ? "tag" : "calling"} says (${Object.keys(known).join(", ")})`;
+			if (typeof value !== known[field]) return `${section}.${id}.${field} is no ${known[field] === "string" ? "word" : "yes or no"}`;
+		}
+	}
+}
+/** Definitions with what a `data.json` says by id laid over them, field by field; one it says of an id they have not, added */
+function layEntries(list, said, made) {
+	const out = list.map((def) => said[def.id] ? {
+		...def,
+		...said[def.id]
+	} : def);
+	for (const [id, entry] of Object.entries(said)) if (!list.some((def) => def.id === id)) out.push({
+		...made(id),
+		...entry
+	});
+	return out;
+}
+/**
+* Why rules said as data are not, where they are first wrong: nothing for rules that are
+*
+* @beta
+*/
+function dataRulesProblem(rules) {
+	if (!isRecord(rules)) return "rules is no object";
+	const known = /* @__PURE__ */ new Set([
+		"supply",
+		"heroes",
+		"resources",
+		"upkeep"
+	]);
+	const other = Object.keys(rules).find((key) => !known.has(key));
+	if (other) return `rules.${other} is nothing the rules say as data`;
+	const number = (value) => typeof value === "number" && Number.isFinite(value);
+	for (const part of ["supply", "heroes"]) {
+		const said = rules[part];
+		if (said === void 0) continue;
+		if (!isRecord(said)) return `rules.${part} is no object`;
+		for (const [key, value] of Object.entries(said)) if (key !== "pools" && !number(value)) return `rules.${part}.${key} is no number`;
+	}
+	for (const part of ["resources", "upkeep"]) {
+		const said = rules[part];
+		if (said !== void 0 && (!Array.isArray(said) || !said.every(isRecord))) return `rules.${part} is no list`;
+	}
+}
+/** The game with the rules a `data.json` says laid over its own */
+function withDataRules(game, rules) {
+	const out = { ...game };
+	const own = game.settings ?? {};
+	const next = { ...own };
+	if (rules.supply) next.supply = {
+		...own.supply,
+		...rules.supply
+	};
+	if (rules.heroes) next.heroes = {
+		...own.heroes,
+		...rules.heroes
+	};
+	if (rules.supply || rules.heroes) out.settings = next;
+	if (rules.resources) out.resources = rules.resources;
+	if (rules.upkeep) out.upkeep = rules.upkeep;
+	return out;
+}
+/** Fields that are never changed from the editor: what a definition is known by, what kind of thing it is and of */
+var FIXED = /* @__PURE__ */ new Set([
+	"id",
+	"kind",
+	"basedOn",
+	"new"
+]);
+/**
+* The lists of ids of each kind of definition, and what they are ids of: what `all` makes editable as lists, and the
+* kind a list field names when the game does not say. Those `always` are there to fill in though a definition has none
+*/
+var LISTS = {
+	units: {
+		abilities: {
+			of: "abilities",
+			always: () => true
+		},
+		requires: {
+			of: "units",
+			always: () => true
+		},
+		provides: { of: "units" },
+		builds: {
+			of: "units",
+			always: (def) => def.kind === "unit" && !!def.harvester
+		},
+		trains: {
+			of: "units",
+			always: (def) => def.kind === "building"
+		},
+		researches: {
+			of: "upgrades",
+			always: (def) => def.kind === "building"
+		},
+		sells: { of: "items" },
+		hires: { of: "units" },
+		upgradesTo: {
+			of: "units",
+			one: true
+		},
+		"hero.learns": { of: "abilities" },
+		"hero.spells": { of: "abilities" },
+		targetableBy: {
+			of: "abilities",
+			always: () => true
+		},
+		"hero.forms.*.learns": {
+			of: "abilities",
+			always: () => true
+		},
+		"hero.forms.*.keeps": {
+			of: "abilities",
+			always: () => true
+		}
+	},
+	items: { from: { of: "items" } },
+	abilities: { upgrades: { of: "abilities" } }
+};
+/** The lists of things whose fields are changed by place (`attacks.1.acquisitionRange`), and only by place: a unit's attacks */
+var BY_PLACE = { units: ["attacks", "pools.*.thresholds"] };
+/** Whether a path is that of a list by place, one with a `*` for any one part of it standing for it (`pools.*.thresholds`) */
+var isByPlace = (byPlace, path) => byPlace.some((list) => byPath({ [list]: true }, path));
+/**
+* The lists of things changed whole in the editor (campaign plan RC2), each thing a row: added, taken out, put in
+* another order, its fields by place (`effects.0.amount`). The effects of abilities, of buffs, the changes of an
+* upgrade, the units a race's start adds. Offered where every thing in them is data (no function among them)
+*/
+var ROWS = {
+	abilities: {
+		effects: {
+			effects: true,
+			when: (def) => def.target !== "passive",
+			hint: "What it does, in order"
+		},
+		passive: {
+			effects: true,
+			when: (def) => def.target === "passive",
+			hint: "What it does all the time"
+		},
+		"recast.effects": {
+			effects: true,
+			when: (def) => isRecord(def.recast),
+			hint: "What a recast does: the ability’s own effects when it has none"
+		},
+		"hold.tap.effects": {
+			effects: true,
+			when: (def) => isRecord(def.hold) && isRecord(def.hold.tap),
+			hint: "What it does let go before its tap’s seconds, in place of its own effects"
+		}
+	},
+	buffs: {
+		onApply: {
+			effects: true,
+			when: () => true,
+			hint: "What happens as it is put on, in the name of who put it there"
+		},
+		"onTick.effects": {
+			effects: true,
+			when: (def) => isRecord(def.onTick),
+			hint: "What happens every so often while it lasts"
+		},
+		passive: {
+			effects: true,
+			when: () => true,
+			hint: "What the carrier’s attacks, hurts, casts and kills set off while it carries it (onHit, onDamaged…)"
+		},
+		onCarrierDeath: {
+			effects: true,
+			when: () => true,
+			hint: "What happens where its carrier dies carrying it, in the name of who put it on"
+		},
+		onMaxStacks: {
+			effects: true,
+			when: (def) => def.maxStacks !== void 0,
+			hint: "What happens to its carrier as it comes to its most stacks"
+		}
+	},
+	upgrades: { effects: {
+		row: (game) => [{
+			path: "units",
+			kind: "list",
+			of: "units",
+			hint: "The unit types that benefit: every one of the player’s when left out"
+		}, ...[...CORE_STAT_KEYS, ...(game?.stats ?? []).map((stat) => stat.id)].map((stat) => ({
+			path: `stats.${stat}`,
+			kind: "number",
+			hint: `What a level adds to ${stat}`
+		}))],
+		hint: "What each level changes"
+	} },
+	races: { "startingBase.units": {
+		row: () => [{
+			path: "type",
+			kind: "id",
+			of: "units",
+			hint: "The unit type"
+		}, {
+			path: "count",
+			kind: "integer",
+			min: 1,
+			hint: "How many"
+		}],
+		when: (def) => isRecord(def.startingBase) && typeof def.startingBase.spawn !== "function",
+		hint: "What else it starts with, by unit type"
+	} }
+};
+/** How deep lists of things go in a thing of a list (a missile's effects in an ability's): deeper ones stay the code's */
+var MAX_ROWS_DEPTH = 2;
+/**
+* The fields that are one id of a kind of definition, by path (a `*` for a place in a list), and what they are ids of:
+* what `all` makes an `id` field, picked in the editor from what the game has. A race's start as data (`StartingBaseData`)
+*/
+var IDS = {
+	races: {
+		"startingBase.hall": "units",
+		"startingBase.workers.type": "units",
+		"startingBase.onMine": "units"
+	},
+	units: {
+		"hero.forms.*.levels.*": "abilities",
+		"hero.innate": "abilities",
+		"trigger.ability": "abilities",
+		"use.ability": "abilities",
+		"burst.ability": "abilities",
+		"pools.*.thresholds.*.buff": "buffs"
+	},
+	abilities: {
+		"costGrowth.buff": "buffs",
+		"hold.buff": "buffs"
+	},
+	buffs: { "overheal.buff": "buffs" }
+};
+/** The ids of the engine's opt-in packs whose fields the Data panel offers (`resourcesPack`, …), as `GamePack.id` has them */
+var RESOURCES_PACK = "core.resources";
+var HOLDS_PACK = "core.holds";
+var CHANGES_PACK = "core.abilityChanges";
+var GROUND_PACK = "core.groundObjects";
+var VISION_PACK = "core.vision";
+var HEROES_PACK = "core.heroes";
+var BURNING_PACK = "burning";
+/** The pools the units of a game have (`UnitTypeDef.pools`), by id, in order: what a `<pool>` in a field's path stands for */
+function poolsOf(game) {
+	return [...new Set((game?.units ?? []).flatMap((def) => isRecord(def.pools) ? Object.keys(def.pools) : []))].sort();
+}
+/**
+* Fields offered though a definition has nothing there, for `all`, where `when` says: a copy of a race says what it
+* keeps of the original's code (`RaceDef.inherits`), kept unless it says otherwise
+*/
+var FILLED_IN = {
+	units: [
+		{
+			path: "tags",
+			kind: "list",
+			hint: "Words of the game’s for what it is (undead, mechanical, ward): what effects and abilities may go by",
+			when: () => true
+		},
+		{
+			path: "trueSight",
+			kind: "number",
+			min: 0,
+			hint: "Finds invisible and camouflaged enemies this near, for its team: a Sentry Ward",
+			when: () => true,
+			pack: VISION_PACK
+		},
+		{
+			path: "pools.<pool>.max",
+			kind: "number",
+			min: 0,
+			hint: "The most of this pool it holds: it has the pool once this is set",
+			when: () => true,
+			pack: RESOURCES_PACK
+		},
+		...[
+			["start", "What of it it starts with: its max when left out"],
+			["regen", "What comes back each second"],
+			["decay", "What goes each second once idle"],
+			["idle", "Seconds without gaining before it decays"],
+			["moving", "What comes for each cell walked"],
+			["reload", "Seconds to fill it again once it is empty"]
+		].map(([part, hint]) => ({
+			path: `pools.*.${part}`,
+			kind: "number",
+			min: 0,
+			hint,
+			when: () => true,
+			pack: RESOURCES_PACK
+		})),
+		{
+			path: "pools.*.name",
+			kind: "text",
+			hint: "What it is called on the screen",
+			when: () => true,
+			pack: RESOURCES_PACK
+		},
+		{
+			path: "pools.*.color",
+			kind: "text",
+			hint: "The colour of its bar (#e0a030)",
+			when: () => true,
+			pack: RESOURCES_PACK
+		},
+		{
+			path: "attacks.*.recovery",
+			kind: "number",
+			min: 0,
+			hint: "Seconds it is held after the blow, the backswing, shortened by attack speed as the swing is: none when left out",
+			when: (def) => Array.isArray(def.attacks)
+		},
+		{
+			path: "attacks.*.cleave.part",
+			kind: "number",
+			min: 0,
+			hint: "A blow from up close strikes the enemies round its target too: this part of its damage each",
+			when: (def) => Array.isArray(def.attacks)
+		},
+		{
+			path: "attacks.*.cleave.radius",
+			kind: "number",
+			min: 0,
+			hint: "How far round the target the cleave reaches",
+			when: (def) => Array.isArray(def.attacks)
+		},
+		{
+			path: "attacks.*.cleave.angle",
+			kind: "number",
+			min: 0,
+			max: 6.2832,
+			hint: "How wide a cone from the attacker through the target, in radians: all round when left out",
+			when: (def) => Array.isArray(def.attacks)
+		},
+		{
+			path: "attackCost.<pool>",
+			kind: "number",
+			min: 0,
+			hint: "What each attack costs of this pool: it does not attack with less",
+			when: (def) => Array.isArray(def.attacks),
+			pack: RESOURCES_PACK
+		},
+		{
+			path: "trigger.ability",
+			kind: "id",
+			of: "abilities",
+			hint: "A trap: this ability goes off in its maker’s name as one it is for comes near",
+			when: () => true,
+			pack: GROUND_PACK
+		},
+		{
+			path: "trigger.radius",
+			kind: "number",
+			min: 0,
+			hint: "How near sets it off",
+			when: (def) => isRecord(def.trigger),
+			pack: GROUND_PACK
+		},
+		{
+			path: "trigger.by",
+			options: [
+				"enemies",
+				"allies",
+				"all",
+				"maker"
+			],
+			hint: "Who sets it off: enemies when left out",
+			when: (def) => isRecord(def.trigger),
+			pack: GROUND_PACK
+		},
+		{
+			path: "trigger.arm",
+			kind: "number",
+			min: 0,
+			hint: "Seconds before it is armed",
+			when: (def) => isRecord(def.trigger),
+			pack: GROUND_PACK
+		},
+		{
+			path: "trigger.times",
+			kind: "integer",
+			min: 1,
+			hint: "How many times it goes off before it is gone: once when left out",
+			when: (def) => isRecord(def.trigger),
+			pack: GROUND_PACK
+		},
+		{
+			path: "use.ability",
+			kind: "id",
+			of: "abilities",
+			hint: "Right-clicked, it is walked up to and used: this ability goes off (a lantern, a portal)",
+			when: () => true,
+			pack: GROUND_PACK
+		},
+		{
+			path: "use.by",
+			options: [
+				"allies",
+				"enemies",
+				"all"
+			],
+			hint: "Who may use it: allies when left out",
+			when: (def) => isRecord(def.use),
+			pack: GROUND_PACK
+		},
+		{
+			path: "use.range",
+			kind: "number",
+			min: 0,
+			hint: "How near one must come to use it",
+			when: (def) => isRecord(def.use),
+			pack: GROUND_PACK
+		},
+		{
+			path: "use.times",
+			kind: "integer",
+			min: 1,
+			hint: "How many times it may be used",
+			when: (def) => isRecord(def.use),
+			pack: GROUND_PACK
+		},
+		{
+			path: "blocksMissiles",
+			options: ["enemies", "all"],
+			hint: "Stops the missiles of its enemies, or everyone’s: a wall of wind",
+			when: () => true,
+			pack: GROUND_PACK
+		},
+		{
+			path: "burst.ability",
+			kind: "id",
+			of: "abilities",
+			hint: "This ability goes off where it dies, in its maker’s name: a barrel",
+			when: () => true,
+			pack: GROUND_PACK
+		},
+		{
+			path: "burst.chain",
+			kind: "number",
+			min: 0,
+			hint: "Those of its type and owner this near die too, and go off in turn",
+			when: (def) => isRecord(def.burst),
+			pack: GROUND_PACK
+		},
+		{
+			path: "burns.seconds",
+			kind: "number",
+			min: 0,
+			hint: "Seconds it burns before it is burnt down: 20 when left out",
+			when: (def) => def.burns !== false,
+			pack: BURNING_PACK
+		},
+		{
+			path: "burns.leaves",
+			kind: "text",
+			hint: "What is left once it has burnt down: felled (it comes down), nothing (it burns away), or a unit type put in its place (a charred stump)",
+			when: (def) => def.burns !== false,
+			pack: BURNING_PACK
+		},
+		{
+			path: "burns.wood",
+			kind: "boolean",
+			hint: "What it leaves keeps the wood it had left",
+			when: (def) => def.burns !== false,
+			pack: BURNING_PACK
+		},
+		{
+			path: "burns.how",
+			kind: "text",
+			hint: "What kind of burning it is, for its look and its death: burnt when left out",
+			when: (def) => def.burns !== false,
+			pack: BURNING_PACK
+		},
+		{
+			path: "hero.callings.<calling>",
+			kind: "integer",
+			min: 1,
+			max: 3,
+			hint: "How strong it is in this calling, 1 to 3: what the shop suggests, the tooltips and the computer players go by. None: not one of its callings",
+			when: (def) => isRecord(def.hero),
+			pack: HEROES_PACK
+		},
+		{
+			path: "hero.innate",
+			kind: "id",
+			of: "abilities",
+			hint: "Its innate: an ability it has from level 1 for no point, its level growing with the hero’s",
+			when: (def) => isRecord(def.hero)
+		},
+		{
+			path: "hero.forms.*.cooldowns",
+			hint: "Its cooldowns going in and out of the form. Left alone, what is put away runs down by the time away; keep: as left; reset: ready; shared: one with the form’s ability that takes its place",
+			when: () => true
+		}
+	],
+	abilities: [
+		{
+			path: "recast.window",
+			kind: "number",
+			min: 0,
+			hint: "Seconds after it is cast that it may be cast again",
+			when: (def) => def.target !== "passive"
+		},
+		{
+			path: "recast.count",
+			kind: "integer",
+			min: 1,
+			hint: "How many times it may be cast again in the window (once when left out)",
+			when: (def) => isRecord(def.recast)
+		},
+		{
+			path: "recast.cooldown",
+			hint: "When the cooldown starts: after the last recast or the window’s end (when left out), or at the first cast",
+			when: (def) => isRecord(def.recast)
+		},
+		{
+			path: "recast.mark",
+			kind: "id",
+			of: "buffs",
+			hint: "A recast goes to the unit carrying this buff from the caster (Sonic Wave’s mark)",
+			when: (def) => isRecord(def.recast)
+		},
+		{
+			path: "recast.range",
+			kind: "number",
+			min: 0,
+			hint: "How far a recast reaches: the ability’s range when left out",
+			when: (def) => isRecord(def.recast)
+		},
+		{
+			path: "recast.manaCost",
+			kind: "number",
+			min: 0,
+			hint: "Mana a recast costs: none when left out",
+			when: (def) => isRecord(def.recast)
+		},
+		{
+			path: "targets.tags",
+			kind: "list",
+			hint: "Only what has one of these tags of its type (undead, mechanical): everything it may target when left out",
+			when: (def) => def.target === "unit"
+		},
+		{
+			path: "castTime",
+			kind: "number",
+			min: 0,
+			hint: "Seconds from the order to its going off, the caster winding up: at once when left out",
+			when: (def) => def.target !== "passive"
+		},
+		{
+			path: "ultimate",
+			kind: "boolean",
+			hint: "A hero’s ultimate: first learned at level 6 unless its required level says otherwise",
+			when: () => true
+		},
+		{
+			path: "charges.count",
+			kind: "integer",
+			min: 1,
+			hint: "Uses it holds, for one used so many times before it waits: its cooldown is then between two uses",
+			when: (def) => def.target !== "passive"
+		},
+		{
+			path: "charges.refill",
+			kind: "number",
+			min: 0,
+			hint: "Seconds until a use is back, while it holds fewer than it can",
+			when: (def) => def.target !== "passive"
+		},
+		{
+			path: "recast.target",
+			kind: "text",
+			hint: "How a recast is aimed (none, unit, point, direction, vector): as the ability is when left out",
+			when: (def) => isRecord(def.recast)
+		},
+		{
+			path: "channel.leash",
+			kind: "number",
+			min: 0,
+			hint: "The channel breaks as its target gets farther than this, dies or hides: a tether",
+			when: (def) => isRecord(def.channel)
+		},
+		{
+			path: "channel.aimed",
+			kind: "boolean",
+			hint: "Aimed as it goes: the caster’s pointer moves where it goes off",
+			when: (def) => isRecord(def.channel),
+			pack: HOLDS_PACK
+		},
+		{
+			path: "channel.walks",
+			kind: "boolean",
+			hint: "Kept up as the caster walks",
+			when: (def) => isRecord(def.channel),
+			pack: HOLDS_PACK
+		},
+		...[
+			["hold.max", "Seconds held for it to be full: held to charge, let go to cast"],
+			["hold.upTo", "Seconds held after which it goes off by itself: as it is full when left out"],
+			["hold.range.from", "How far it reaches let go at once"],
+			["hold.range.to", "How far it reaches let go full"],
+			["hold.scale", "What its amounts come to full, times what they are let go at once (1.5: half again)"]
+		].map(([path, hint]) => ({
+			path,
+			kind: "number",
+			min: 0,
+			hint,
+			when: (def) => [
+				"none",
+				"point",
+				"direction"
+			].includes(String(def.target ?? "none")) && !def.channel,
+			pack: HOLDS_PACK
+		})),
+		{
+			path: "hold.buff",
+			kind: "id",
+			of: "buffs",
+			hint: "A buff on the caster while it holds: a slow",
+			when: (def) => isRecord(def.hold),
+			pack: HOLDS_PACK
+		},
+		{
+			path: "hold.tap.under",
+			kind: "number",
+			min: 0,
+			hint: "Let go before so many seconds, it does its tap’s effects in place of its own (Pyke’s stab, not his hook)",
+			when: (def) => isRecord(def.hold),
+			pack: HOLDS_PACK
+		},
+		{
+			path: "cost.<pool>",
+			kind: "number",
+			min: 0,
+			hint: "What it costs of the caster’s pool: not ready with less",
+			when: (def) => def.target !== "passive",
+			pack: RESOURCES_PACK
+		},
+		{
+			path: "gain.<pool>",
+			kind: "number",
+			min: 0,
+			hint: "What it gives the caster’s pool as it goes off",
+			when: (def) => def.target !== "passive",
+			pack: RESOURCES_PACK
+		},
+		{
+			path: "costGrowth.buff",
+			kind: "id",
+			of: "buffs",
+			hint: "Its costs grow with the stacks of this buff of the caster’s",
+			when: (def) => def.target !== "passive",
+			pack: RESOURCES_PACK
+		},
+		{
+			path: "costGrowth.per",
+			kind: "number",
+			min: 0,
+			hint: "How much more for each stack: 1, twice with one stack, three times with two",
+			when: (def) => def.target !== "passive",
+			pack: RESOURCES_PACK
+		},
+		{
+			path: "upgrades",
+			kind: "list",
+			of: "abilities",
+			hint: "What it may be made into for good, chosen once",
+			when: () => true,
+			pack: CHANGES_PACK
+		}
+	],
+	buffs: [
+		{
+			path: "breaksOn",
+			kind: "list",
+			hint: "What takes it off before its time: damage (its carrier hurt), attack (its attack lands), cast",
+			when: () => true
+		},
+		{
+			path: "control",
+			hint: "It takes its carrier’s orders while it lasts: fear (away from who put it on), charm (to them), taunt (attacks them)",
+			when: (def) => typeof def.control !== "function"
+		},
+		{
+			path: "suppress",
+			kind: "boolean",
+			hint: "Held like a stun, but tenacity does not shorten it and a cleanse does not take it off",
+			when: () => true
+		},
+		{
+			path: "grounded",
+			kind: "boolean",
+			hint: "Its carrier cannot dash or blink of its own",
+			when: () => true
+		},
+		{
+			path: "unstoppable",
+			kind: "boolean",
+			hint: "Nothing that holds a unit up (stun, root, silence, fear, a throw…) does anything to its carrier",
+			when: () => true
+		},
+		{
+			path: "revealed",
+			kind: "boolean",
+			hint: "Its carrier is seen by the team of whoever put it on, wherever it stands (with the vision pack)",
+			when: () => true,
+			pack: VISION_PACK
+		},
+		{
+			path: "camouflage",
+			kind: "number",
+			min: 0,
+			hint: "Its carrier is seen by its enemies only from this near, unless something finds it (with the vision pack)",
+			when: (def) => typeof def.camouflage !== "function",
+			pack: VISION_PACK
+		},
+		{
+			path: "trueSight",
+			kind: "number",
+			min: 0,
+			hint: "Its carrier finds invisible and camouflaged enemies this near (with the vision pack)",
+			when: () => true,
+			pack: VISION_PACK
+		},
+		{
+			path: "invulnerable",
+			kind: "boolean",
+			hint: "Its carrier takes no damage, and no enemy’s ability is cast on it",
+			when: (def) => typeof def.invulnerable !== "function"
+		},
+		{
+			path: "untargetable",
+			kind: "boolean",
+			hint: "Nothing of anyone else’s reaches its carrier: no ability cast on it, no attack, no area, no missile",
+			when: (def) => typeof def.untargetable !== "function"
+		},
+		{
+			path: "minHealth",
+			kind: "number",
+			min: 0,
+			hint: "The least health damage leaves its carrier with (1: it cannot die of it)",
+			when: (def) => typeof def.minHealth !== "function"
+		},
+		{
+			path: "drain.mana",
+			kind: "number",
+			min: 0,
+			hint: "Mana it takes of its carrier each second: off when there is not enough",
+			when: () => true,
+			pack: RESOURCES_PACK
+		},
+		{
+			path: "drain.<pool>",
+			kind: "number",
+			min: 0,
+			hint: "What it takes of its carrier’s pool each second: off when there is not enough",
+			when: () => true,
+			pack: RESOURCES_PACK
+		},
+		{
+			path: "tags",
+			kind: "list",
+			hint: "Words of the game’s for what it is (fire, slow, anti-heal): what a search and code find it by",
+			when: () => true
+		},
+		{
+			path: "phasing",
+			kind: "boolean",
+			hint: "Its carrier walks through other units and they through it; walls and buildings still stop it",
+			when: (def) => typeof def.phasing !== "function"
+		},
+		{
+			path: "cleave.part",
+			kind: "number",
+			min: 0,
+			hint: "Its carrier’s blows from up close strike the enemies round the target too, this part of the damage each",
+			when: () => true
+		},
+		{
+			path: "cleave.radius",
+			kind: "number",
+			min: 0,
+			hint: "How far round the target the cleave reaches",
+			when: (def) => isRecord(def.cleave)
+		},
+		{
+			path: "cleave.angle",
+			kind: "number",
+			min: 0,
+			max: 6.2832,
+			hint: "How wide a cone from the attacker through the target, in radians: all round when left out",
+			when: (def) => isRecord(def.cleave)
+		},
+		{
+			path: "overheal.buff",
+			kind: "id",
+			of: "buffs",
+			hint: "Healing past full health its carrier gives (or gets) becomes a shield: this buff, on whoever was healed",
+			when: () => true
+		},
+		{
+			path: "overheal.part",
+			kind: "number",
+			min: 0,
+			hint: "The part of what spilled over the shield holds: all of it when left out",
+			when: (def) => isRecord(def.overheal)
+		},
+		{
+			path: "overheal.most",
+			kind: "number",
+			min: 0,
+			hint: "The most the shield holds, a part of the healed one’s max health: a third when left out",
+			when: (def) => isRecord(def.overheal)
+		},
+		{
+			path: "overheal.of",
+			options: ["given", "taken"],
+			hint: "Of the healing its carrier gives (given, when left out), or gets (taken)",
+			when: (def) => isRecord(def.overheal)
+		},
+		{
+			path: "paysWithHealth",
+			kind: "either",
+			orNumber: "number",
+			min: 0,
+			hint: "Its carrier pays for its abilities with health, not mana: this much health a point of mana (1 when on)",
+			when: () => true
+		}
+	],
+	items: [
+		{
+			path: "level",
+			kind: "integer",
+			min: 1,
+			hint: "How good it is: what an item table draws by (a level)",
+			when: () => true
+		},
+		{
+			path: "class",
+			kind: "text",
+			hint: "Its kind of item, a word of the game’s: what an item table draws by (a class)",
+			when: () => true
+		},
+		{
+			path: "tier",
+			kind: "text",
+			hint: "Where it goes in a shop: consumable, starter, basic, intermediate, legendary, relic (found, not sold), or a tier of the game’s",
+			when: () => true
+		},
+		{
+			path: "tags",
+			kind: "list",
+			hint: "Words of the game’s for what it is (attack, lifesteal, early): what a search (#lifesteal) and a shop’s filters go by",
+			when: () => true
+		},
+		{
+			path: "suits",
+			kind: "list",
+			hint: "The callings of heroes it is meant for (vanguard, ranger): what a shop suggests, never a lock",
+			when: () => true
+		},
+		{
+			path: "unique",
+			kind: "text",
+			hint: "A name for its passive: two carried, of it or of items sharing the name, work once",
+			when: () => true
+		},
+		{
+			path: "group",
+			kind: "text",
+			hint: "A group a hero carries only so many of (boots: one pair)",
+			when: () => true
+		},
+		{
+			path: "groupLimit",
+			kind: "integer",
+			min: 1,
+			hint: "How many of its group one hero may carry: the game’s limit of the group, or 1, when left out",
+			when: (def) => def.group !== void 0
+		},
+		{
+			path: "stack",
+			kind: "integer",
+			min: 1,
+			hint: "How many go in one slot, their charges added (a stack of potions)",
+			when: (def) => def.charges !== void 0
+		},
+		{
+			path: "refill.shop",
+			kind: "boolean",
+			hint: "Its charges all come back at a shop",
+			when: (def) => def.charges !== void 0
+		},
+		{
+			path: "refill.every",
+			kind: "number",
+			min: 0,
+			hint: "Seconds for one of its charges to come back, wherever it is",
+			when: (def) => def.charges !== void 0
+		},
+		{
+			path: "sellRate",
+			kind: "number",
+			min: 0,
+			max: 1,
+			step: .05,
+			hint: "The part of its price a shop gives back: the game’s when left out",
+			when: () => true
+		}
+	],
+	races: [{
+		path: "inherits.hooks",
+		kind: "boolean",
+		hint: "Keeps the hooks of the race this is a copy of: how it gathers, where it builds. Off, it plays by the game's rules alone",
+		when: (def) => !!def.basedOn
+	}, {
+		path: "inherits.onStart",
+		kind: "boolean",
+		hint: "Keeps the onStart of the race this is a copy of: what its players begin with that is not a unit (a ground of its own)",
+		when: (def) => !!def.basedOn
+	}]
+};
+/** The words a path is one of (a `choice`), by kind and path, `*` for any one part of it */
+var CHOICES = {
+	units: {
+		"hero.forms.*.cooldowns": [
+			"keep",
+			"reset",
+			"shared"
+		],
+		"trigger.by": [
+			"enemies",
+			"allies",
+			"all",
+			"maker"
+		],
+		"use.by": [
+			"allies",
+			"enemies",
+			"all"
+		],
+		blocksMissiles: ["enemies", "all"]
+	},
+	buffs: {
+		control: [
+			"fear",
+			"charm",
+			"taunt"
+		],
+		"overheal.of": ["given", "taken"]
+	},
+	abilities: { "recast.cooldown": ["after", "first"] }
+};
+/** The kind of definition a path is an id of, as `IDS` says, or undefined */
+function idKindOf(kind, path) {
+	return byPath(IDS[kind], path);
+}
+/**
+* What a table by path says of a path: by the path itself, or by one with a `*` for any one part of it (a place in a
+* list, a form of a hero's: `hero.forms.*.keeps`)
+*/
+function byPath(table, path) {
+	if (!table) return void 0;
+	if (path in table) return table[path];
+	const parts = path.split(".");
+	for (const [key, value] of Object.entries(table)) {
+		if (!key.includes("*")) continue;
+		const keys = key.split(".");
+		if (keys.length === parts.length && keys.every((each, i) => each === "*" || each === parts[i])) return value;
+	}
+}
+/** The paths a path with a `*` stands for in a definition: one for each key of what is there (`hero.forms.bear.keeps`) */
+function expandedPaths(def, path) {
+	const star = path.indexOf(".*");
+	if (star < 0) return [path];
+	const head = path.slice(0, star);
+	const there = valueAt(def, head);
+	return (Array.isArray(there) ? there.map((_, index) => String(index)) : isRecord(there) ? Object.keys(there) : []).flatMap((key) => expandedPaths(def, `${head}.${key}${path.slice(star + 2)}`));
+}
+/** The list by place a path is in, and the place: `attacks.1.acquisitionRange` is in `attacks` at 1 */
+function placeOf(kind, path) {
+	const parts = path.split(".");
+	for (const general of BY_PLACE[kind] ?? []) {
+		const keys = general.split(".");
+		if (parts.length <= keys.length || !keys.every((each, i) => each === "*" || each === parts[i])) continue;
+		const place = Number(parts[keys.length]);
+		if (Number.isInteger(place)) return {
+			list: parts.slice(0, keys.length).join("."),
+			place
+		};
+	}
+}
+var isWords = (value) => Array.isArray(value) && value.every((each) => typeof each === "string");
+var MAX_DEPTH = 4;
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isValue = (value) => typeof value === "boolean" || typeof value === "string" || typeof value === "number" && Number.isFinite(value);
+/**
+* What is at a path of a definition, or undefined
+*
+* @beta
+*/
+function valueAt(def, path) {
+	let at = def;
+	for (const part of path.split(".")) {
+		if (typeof at !== "object" || at === null) return void 0;
+		at = at[part];
+	}
+	return at;
+}
+/**
+* Values with one field set, nested as the path says: `nested('stats.health', 420)` is `{ stats: { health: 420 } }`
+*
+* @beta
+*/
+function nested(path, value) {
+	const parts = path.split(".");
+	let out = { [parts.pop()]: value };
+	while (parts.length) out = { [parts.pop()]: out };
+	return out;
+}
+/**
+* Every number, word and yes or no of a definition, by path, and its lists of ids as lists: what `all` makes editable.
+* A list of numbers (a bounty's two ends) is by place, and so are the things of a list `byPlace` names (a unit's
+* attacks); another list of things (drops) or of lists stays the code's
+*/
+function leaves(def, lists = {}, prefix = "", depth = 0, byPlace = []) {
+	if (depth > MAX_DEPTH) return [];
+	const out = [];
+	const entries = Array.isArray(def) ? def.map((value, i) => [String(i), value]) : Object.entries(def);
+	for (const [key, value] of entries) {
+		if (depth === 0 && FIXED.has(key)) continue;
+		const path = prefix ? `${prefix}.${key}` : key;
+		if (isValue(value)) out.push(path);
+		else if (byPath(lists, path) && isWords(value)) out.push(path);
+		else if (Array.isArray(value) ? value.every((each) => typeof each === "number") || isByPlace(byPlace, path) && value.every(isRecord) : isRecord(value)) out.push(...leaves(value, lists, path, depth + 1, byPlace));
+	}
+	return out;
+}
+var kindOf = (value) => typeof value === "boolean" ? "boolean" : typeof value === "string" ? "text" : "number";
+function fieldOf(kind, def, field) {
+	const said = typeof field === "string" ? { path: field } : field;
+	const options = said.options ?? byPath(CHOICES[kind], said.path);
+	const given = options ? {
+		...said,
+		options
+	} : said;
+	const parts = given.path.split(".");
+	const list = byPath(LISTS[kind], given.path);
+	const value = valueAt(def, given.path);
+	const listed = given.kind === "list" || given.kind === void 0 && (isWords(value) || value === void 0 && !!list || !!list?.one && typeof value === "string");
+	const idOf = (given.kind === "id" || given.kind === void 0) && typeof value !== "number" ? idKindOf(kind, given.path) : void 0;
+	const place = placeOf(kind, given.path);
+	const form = kind === "units" && parts.length > 3 && parts[0] === "hero" && parts[1] === "forms";
+	return {
+		...given,
+		name: given.name ?? (place ? given.path.slice(`${place.list}.${place.place}.`.length) : form ? parts.slice(3).join(" ") : parts[parts.length - 1]),
+		kind: given.kind ?? (given.options ? "choice" : listed ? "list" : idOf ? "id" : kindOf(value)),
+		group: given.group ?? (place ? `${place.list.split(".").join(" ")} ${place.place + 1}` : form ? `form ${parts[2]}` : parts.length > 1 ? parts[0] : listed ? "lists" : ""),
+		...listed && (given.of ?? list?.of) && { of: given.of ?? list.of },
+		...listed && (given.one ?? list?.one) && { one: true },
+		...!listed && (given.of ?? idOf) && { of: given.of ?? idOf }
+	};
+}
+/** Whether a value is data all through, no function anywhere in it: as a list must be to be changed whole and kept in a file */
+var isData = (value, depth = 0) => depth <= 8 && (value === void 0 || isValue(value) || Array.isArray(value) && value.every((each) => isData(each, depth + 1)) || isRecord(value) && Object.values(value).every((each) => isData(each, depth + 1)));
+/** The kinds of effect a game has, by type: the engine's, its packs' and its own (`Rules.effects`), one of its own over the engine's of its type */
+function effectTypesByType(game) {
+	const kinds = /* @__PURE__ */ new Map();
+	for (const kind of [
+		...coreEffects,
+		...summonEffects,
+		...dispelEffects,
+		...(game?.packs ?? []).flatMap((pack) => pack.effects ?? []),
+		...game?.effects ?? []
+	]) kinds.set(kind.type, kind);
+	return kinds;
+}
+/**
+* The fields an effect of a type has, by their path in it: those its type reads (`defineEffect`'s `fields`), then those
+* every effect may have (`EffectCommon`). Only those every effect may have, for a type the game has not
+*
+* @beta
+*/
+function effectFields(game, type) {
+	return [...effectTypesByType(game).get(type)?.fields ?? [], ...Object.values(COMMON_EFFECT_FIELDS).flat()];
+}
+/**
+* The types of effect a game has (`defineEffect`): the engine's and its own, in order of their names
+*
+* @beta
+*/
+function effectTypesOf(game) {
+	return [...effectTypesByType(game).keys()].sort();
+}
+/**
+* A list of things changed whole (`ROWS`), and the fields of each of its things by place under a heading of its own
+* (`effects 1`): its type for an effect, then what it has, then what its type or the list says it may have. The lists
+* inside a thing (a missile's effects) the same, a few deep
+*/
+function rowsFields(game, spec, path, heading, rows, depth = 0) {
+	const types = spec.effects ? effectTypesOf(game) : void 0;
+	const out = [{
+		path,
+		name: path.split(".").pop(),
+		kind: "rows",
+		group: heading,
+		...types && { types },
+		...spec.hint && { hint: spec.hint }
+	}];
+	rows.forEach((row, place) => {
+		if (!isRecord(row)) return;
+		const at = `${path}.${place}`;
+		const group = `${heading} ${place + 1}`;
+		const declared = spec.effects ? effectFields(game, String(row.type)) : spec.row?.(game) ?? [];
+		const lists = Object.fromEntries(declared.filter((field) => field.kind === "list").map((field) => [field.path, field]));
+		const own = (field, value) => ({
+			...field,
+			path: `${at}.${field.path}`,
+			name: field.name ?? field.path,
+			kind: field.kind ?? (field.options ? "choice" : isWords(value) ? "list" : kindOf(value)),
+			group: field.group ?? group
+		});
+		if (spec.effects) out.push({
+			path: `${at}.type`,
+			name: "type",
+			kind: "text",
+			group,
+			hint: "What kind of effect it is"
+		});
+		const present = leaves(row, lists).filter((each) => !spec.effects || each !== "type");
+		for (const each of present) out.push(own(declared.find((field) => field.path === each) ?? { path: each }, valueAt(row, each)));
+		for (const field of declared) {
+			const value = valueAt(row, field.path);
+			if (field.kind !== "rows") {
+				const byLevel = (field.kind === "number" || field.kind === "integer") && Array.isArray(value);
+				if (value === void 0 || byLevel) out.push(own(field, void 0));
+			} else if (depth < MAX_ROWS_DEPTH && (value === void 0 || Array.isArray(value) && isData(value))) out.push(...rowsFields(game, {
+				effects: true,
+				hint: field.hint
+			}, `${at}.${field.path}`, `${group} ${field.path}`, value ?? [], depth + 1));
+		}
+	});
+	return out;
+}
+/** The lists of things changed whole of a definition (`ROWS`), with their things' fields: those it has, all data, and those offered empty */
+function allRows(game, kind, def) {
+	return Object.entries(ROWS[kind] ?? {}).flatMap(([path, spec]) => {
+		const rows = valueAt(def, path);
+		return (rows === void 0 ? !!spec.when?.(def) : Array.isArray(rows) && isData(rows)) ? rowsFields(game, spec, path, path.split(".").join(" "), rows ?? []) : [];
+	});
+}
+/**
+* An upgrade's requirements by level (`UpgradeDef.requires`, a list for each): a list of ids for each of its levels,
+* those it has and up to its last
+*/
+function levelLists(def) {
+	const levels = Math.max(def.maxLevel ?? 1, def.requires?.length ?? 0);
+	return Array.from({ length: Math.min(levels, MAX_LIST) }, (_, level) => ({
+		path: `requires.${level}`,
+		name: `level ${level + 1}`,
+		kind: "list",
+		of: "units",
+		group: "requires",
+		hint: `The buildings needed for level ${level + 1}: all of them`
+	}));
+}
+/**
+* The fields of a definition the editor may change, as the game says (`Rules.editable`), each with what it
+* holds and the heading it goes under. None for a game that says nothing of that kind
+*
+* @beta
+*/
+function editableFields(game, kind, def) {
+	const editable = game?.editable;
+	if (!editable) return [];
+	let said = editable === "all" ? "all" : editable[kind];
+	if (typeof said === "function") said = said(def);
+	if (!said) return [];
+	if (said === "all") {
+		const lists = LISTS[kind] ?? {};
+		const paths = leaves(def, lists, "", 0, BY_PLACE[kind]);
+		for (const [general, list] of Object.entries(lists)) for (const path of expandedPaths(def, general)) if (!paths.includes(path) && valueAt(def, path) === void 0 && list.always?.(def)) paths.push(path);
+		const fields = paths.map((path) => fieldOf(kind, def, path));
+		for (const { when, pack, ...field } of FILLED_IN[kind] ?? []) {
+			if (pack && !hasPack(game, pack)) continue;
+			const general = field.path.includes("<pool>") ? poolsOf(game).map((pool) => field.path.replace("<pool>", pool)) : field.path.includes("<calling>") ? callingsOf({ packs: game?.packs }).map((calling) => field.path.replace("<calling>", calling.id)) : [field.path];
+			for (const path of general.flatMap((each) => expandedPaths(def, each))) if (!paths.includes(path) && !fields.some((each) => each.path === path) && when(def)) fields.push(fieldOf(kind, def, {
+				...field,
+				path
+			}));
+		}
+		fields.push(...allRows(game, kind, def));
+		if (kind === "upgrades") fields.push(...levelLists(def));
+		return fields;
+	}
+	return said.flatMap((field) => {
+		const path = typeof field === "string" ? field : field.path;
+		const spec = ROWS[kind]?.[path];
+		if (!spec) return [fieldOf(kind, def, field)];
+		const rows = valueAt(def, path);
+		if (rows !== void 0 && !(Array.isArray(rows) && isData(rows))) return [];
+		return rowsFields(game, spec, path, path.split(".").join(" "), rows ?? []);
+	});
+}
+/** How many words a list field holds at most, and how long each is */
+var MAX_LIST = 64;
+var MAX_WORD = 100;
+/** Whether something is values as a data file has them: numbers, words, yes or no, lists of them and of things, a few deep */
+function isValues(value, depth = 0) {
+	return isRecord(value) && depth <= 6 && Object.entries(value).every(([key, each]) => /^[\w$]+$/.test(key) && isEntry(each, depth + 1));
+}
+var isEntry = (value, depth) => isValue(value) && (typeof value !== "string" || value.length <= 200) || Array.isArray(value) && value.length <= MAX_LIST && value.every((each) => isEntry(each, depth + 1)) || isValues(value, depth);
+/** Whether something is a list of things as a `rows` field takes it whole */
+var isRows = (value) => Array.isArray(value) && value.length <= MAX_LIST && value.every((row) => isValues(row));
+/**
+* A value as a field takes it, or the reason it does not
+*
+* @beta
+*/
+function fitValue(field, value) {
+	switch (field.kind) {
+		case "rows": return isRows(value) && (!field.types || value.every((row) => typeof row.type === "string")) ? { value: value.map((row) => ({ ...row })) } : { error: `${field.path} is a list of things${field.types ? ", each of a type" : ""}` };
+		case "list": {
+			const words = field.one && typeof value === "string" ? [value] : value;
+			return isWords(words) && words.length <= MAX_LIST && words.every((each) => each.length <= MAX_WORD) ? { value: field.one && words.length === 1 ? words[0] : [...words] } : { error: `${field.path} is a list of words` };
+		}
+		case "boolean": return typeof value === "boolean" ? { value } : { error: `${field.path} is yes or no` };
+		case "text": return typeof value === "string" ? { value } : { error: `${field.path} is words` };
+		case "id": return typeof value === "string" && value.length <= MAX_WORD ? { value } : { error: `${field.path} is an id${field.of ? ` of the ${field.of}` : ""}` };
+		case "choice": return typeof value === "string" && (!field.options || field.options.includes(value)) ? { value } : { error: `${field.path} is one of ${(field.options ?? []).join(", ")}` };
+		case "either":
+			if (typeof value === "boolean" || typeof value === "string" && field.options?.includes(value)) return { value };
+			if (field.orNumber && typeof value === "number" && Number.isFinite(value)) return { value: fitNumber(field, field.orNumber, value) };
+			return { error: `${field.path} is ${[
+				"yes or no",
+				...field.options ?? [],
+				...field.orNumber ? ["a number"] : []
+			].join(", ")}` };
+		default: return typeof value === "number" && Number.isFinite(value) ? { value: fitNumber(field, field.kind, value) } : { error: `${field.path} is a number` };
+	}
+}
+/** A number within a field's ends, whole where it is an integer */
+function fitNumber(field, kind, value) {
+	let set = kind === "integer" ? Math.round(value) : value;
+	if (field.min !== void 0) set = Math.max(set, field.min);
+	if (field.max !== void 0) set = Math.min(set, field.max);
+	return set;
+}
+/** Whether a list in the data is one of things by place (a unit's attacks) or of numbers (a bounty's two ends): walked by place, as a record of indices is */
+var byPlace = (value) => Array.isArray(value) && value.length > 0 && (value.every(isRecord) || value.every((each) => typeof each === "number"));
+/**
+* Every path of values, with what is there: a list of things or numbers by place (`attacks.0.damagePoint`), a list of
+* words whole, and a list of things whole where `whole` says (a `rows` field's)
+*/
+function pathsOf(values, whole = () => false, prefix = "") {
+	return Object.entries(values).flatMap(([key, value]) => {
+		const path = prefix ? `${prefix}.${key}` : key;
+		return isRecord(value) || byPlace(value) && !whole(path) ? pathsOf(value, whole, path) : [{
+			path,
+			value
+		}];
+	});
+}
+/** Whether a record is one of places in a list: every key a whole number */
+var places = (value) => Object.keys(value).length > 0 && Object.keys(value).every((key) => /^\d+$/.test(key));
+/**
+* A definition with values over it: a copy, the parts the values go into copied too, the rest (its functions, its
+* lists of things) shared with the one it was made from. Values by place (`{ attacks: { 0: { damagePoint: 0.5 } } }`)
+* go into the list there, or make one where there is none. Nothing of the definition given is changed
+*
+* @beta
+*/
+function layValues(def, values) {
+	const over = (into, from) => {
+		const copy = Array.isArray(into) ? [...into] : { ...into };
+		for (const [key, value] of Object.entries(from)) {
+			if (!isRecord(value)) {
+				copy[key] = value;
+				continue;
+			}
+			const there = copy[key];
+			const inner = isRecord(there) || Array.isArray(there) ? there : places(value) ? [] : {};
+			copy[key] = over(inner, value);
+		}
+		return copy;
+	};
+	return over(def, values);
+}
+/**
+* Values merged: what `b` says over what `a` says, at any depth. Places said over a list go into it (`{ 0: { amount:
+* 50 } }` over a list of effects); a list said is the list
+*
+* @beta
+*/
+function mergeValues(a, b) {
+	const out = { ...a };
+	for (const [key, value] of Object.entries(b)) {
+		const before = out[key];
+		if (isRecord(value) && isRecord(before)) out[key] = mergeValues(before, value);
+		else if (isRecord(value) && Array.isArray(before) && places(value)) {
+			const list = [...before];
+			for (const [place, each] of Object.entries(value)) list[Number(place)] = isRecord(each) && isRecord(list[Number(place)]) ? mergeValues(list[Number(place)], each) : each;
+			out[key] = list;
+		} else out[key] = value;
+	}
+	return out;
+}
+/**
+* Only the values of the fields that can be changed, each as its field takes it. What is not is left out and said:
+* a field the game no longer lets be changed, a value of another kind
+*
+* @beta
+*/
+function editableValues(fields, values, said = () => {}) {
+	let out = {};
+	const rows = new Set(fields.filter((field) => field.kind === "rows").map((field) => field.path));
+	for (const { path, value } of pathsOf(values, (path) => rows.has(path))) {
+		const field = fields.find((each) => each.path === path);
+		if (!field) {
+			said(`${path} cannot be changed from the data`);
+			continue;
+		}
+		const fit = fitValue(field, value);
+		if ("error" in fit) said(fit.error);
+		else out = mergeValues(out, nested(path, fit.value));
+	}
+	return out;
+}
+/**
+* The game with what its `data.json` says over what its code says: `export default layData(game, dataFile)`. Only
+* the fields the game lets be changed (`Rules.editable`) are taken, and of the kind each holds; anything else in
+* the file is left out, and said in the log. The game given is not changed
+*
+* @beta
+*/
+function layData(game, file) {
+	if (!isRecord(file)) return game;
+	const warn = (why) => rootLogger.warn("game", `${game.id}'s data.json: ${why}`);
+	if (file.defaults !== void 0) {
+		const wrong = dataDefaultsProblem(file.defaults, game);
+		if (wrong) warn(wrong);
+		else game = dataDefaults(game, file.defaults);
+	}
+	let out = { ...game };
+	if (file.tags !== void 0) {
+		const wrong = dataEntriesProblem("tags", file.tags);
+		if (wrong) warn(wrong);
+		else out.tags = layEntries(out.tags ?? [], file.tags, (id) => ({ id }));
+	}
+	if (file.callings !== void 0) {
+		const wrong = dataEntriesProblem("callings", file.callings);
+		if (wrong) warn(wrong);
+		else out = withCallings(out, layEntries(callingsOf(out), file.callings, (id) => ({
+			id,
+			name: id
+		})));
+	}
+	if (file.cellLayers !== void 0) {
+		const wrong = dataCellLayersProblem(file.cellLayers);
+		if (wrong) warn(wrong);
+		else {
+			const said = file.cellLayers;
+			if (out.cellLayers) out.cellLayers = layCellLayerData(out.cellLayers, said);
+			for (const layer of Object.keys(said)) if (!out.cellLayers?.some((def) => def.id === layer)) warn(`cellLayers: the game has no layer of cells "${layer}"`);
+		}
+	}
+	for (const kind of DATA_KINDS) {
+		const values = file[kind];
+		if (values === void 0) continue;
+		const defs = game[kind];
+		if (!isRecord(values) || !defs) {
+			warn(`there are no ${kind} to set`);
+			continue;
+		}
+		const seen = new Set(Object.keys(values));
+		/** What is said of a definition as its fields take it, what it is a copy of (or that it is new) left out */
+		const over = (def, own) => {
+			const { [COPY_OF]: _, ["new"]: isNew, ...rest } = own;
+			if (isNew === true) delete rest.kind;
+			return layValues(def, editableValues(editableFields(game, kind, def), rest, (why) => warn(`${kind}.${def.id}: ${why}`)));
+		};
+		const made = defs.map((def) => {
+			const own = values[def.id];
+			if (!isRecord(own)) return def;
+			seen.delete(def.id);
+			return over(def, own);
+		});
+		for (const id of seen) {
+			const own = values[id];
+			if (!isRecord(own) || own["new"] !== true) continue;
+			made.push(over(blankDefinition(kind, id, unitKindOf(own.kind)), own));
+			seen.delete(id);
+		}
+		for (let progress = true; progress;) {
+			progress = false;
+			for (const id of seen) {
+				const own = values[id];
+				const from = isRecord(own) ? own[COPY_OF] : void 0;
+				const base = typeof from === "string" ? made.find((def) => def.id === from) : void 0;
+				if (!base) continue;
+				made.push(over({
+					...base,
+					id,
+					basedOn: from
+				}, own));
+				seen.delete(id);
+				progress = true;
+			}
+		}
+		out[kind] = made;
+		for (const id of seen) {
+			const from = isRecord(values[id]) ? values[id][COPY_OF] : void 0;
+			warn(typeof from === "string" ? `${kind}.${id} is a copy of "${from}", which the game has not` : `the game has no ${kind} "${id}"`);
+		}
+	}
+	const ai = file.ai;
+	if (ai !== void 0) {
+		const races = isRecord(ai) ? ai.races : void 0;
+		if (!isRecord(ai) || races !== void 0 && !isRecord(races)) warn("ai is no { races: { <race>: <profile> } }");
+		else if (isRecord(races)) {
+			const own = { ...game.ai?.races };
+			for (const [race, profile] of Object.entries(races)) {
+				if (!isRecord(profile)) {
+					warn(`ai.races.${race} is no profile`);
+					continue;
+				}
+				if (!(out.races ?? []).some((def) => def.id === race)) warn(`ai.races: the game has no race "${race}"`);
+				own[race] = profile;
+			}
+			out.ai = {
+				...game.ai,
+				races: own
+			};
+		}
+	}
+	if (file.rules !== void 0) {
+		const wrong = dataRulesProblem(file.rules);
+		if (wrong) warn(wrong);
+		else Object.assign(out, withDataRules(out, file.rules));
+	}
+	const removed = file.removed;
+	if (isRecord(removed)) for (const [kind, ids] of Object.entries(removed)) {
+		const list = out[kind];
+		if (!DATA_KINDS.includes(kind) || !list || !isWords(ids)) {
+			warn(`removed.${kind} is no list of ${kind} of the game`);
+			continue;
+		}
+		for (const id of ids) if (!list.some((def) => def.id === id)) warn(`removed.${kind}: the game has no ${kind} "${id}"`);
+		out[kind] = list.filter((def) => !ids.includes(def.id));
+	}
+	return out;
+}
+/** The kind of thing a unit type made of nothing is, as its data says: a unit when it says none the game knows */
+var unitKindOf = (said) => typeof said === "string" && UNIT_KINDS.includes(said) ? said : void 0;
+/**
+* What a world's definitions were changed to while it runs (`world.redefine`), by kind and id: kept with the world
+* and in its save, so that a load has them again
+*
+* @beta
+*/
+var redefinitions = defineComponent({
+	id: "core.redefinitions",
+	default: () => ({})
+});
+/**
+* A definition changed while the game runs: what it is now
+*
+* @beta
+*/
+var definitionChanged = defineEngineEvent({ id: "core.definitionChanged" });
+/**
+* Puts a definition with values over it into the registry, in the place of the one there: what is made of it from
+* then on is made of the new one. False for a definition the game does not have
+*
+* @beta
+*/
+function redefineIn(registry, kind, id, values) {
+	const copyOf = values[COPY_OF];
+	if (typeof copyOf === "string" && !definitionIn(registry, kind, id)) {
+		if (!copyDefinition(registry, kind, copyOf, id)) return false;
+		const { [COPY_OF]: _, ...rest } = values;
+		return Object.keys(rest).length ? redefineIn(registry, kind, id, rest) : true;
+	}
+	if (values["new"] === true && !definitionIn(registry, kind, id)) {
+		if (!id) return false;
+		registry.kinds[kind].define(blankDefinition(kind, id, unitKindOf(values.kind)));
+		const { ["new"]: _, kind: __, ...rest } = values;
+		return Object.keys(rest).length ? redefineIn(registry, kind, id, rest) : true;
+	}
+	if ("copyOf" in values || "new" in values) {
+		const { [COPY_OF]: _, ["new"]: __, ...rest } = values;
+		values = rest;
+	}
+	const defs = registry.kinds[kind];
+	const def = defs.find(id);
+	if (!def) return false;
+	defs.define(layValues(def, values));
+	return true;
+}
+/**
+* A new definition, a copy of one the registry has, by an id it has nothing by: what it is drawn as is the one it is
+* a copy of (`basedOn`) until the game gives it a look of its own. False for one it does not have, or an id it has
+*
+* @beta
+*/
+function copyDefinition(registry, kind, from, id) {
+	const base = definitionIn(registry, kind, from);
+	if (!base || definitionIn(registry, kind, id) || !id) return false;
+	const copy = {
+		...base,
+		id,
+		basedOn: from
+	};
+	registry.kinds[kind].define(copy);
+	return true;
+}
+/**
+* Takes a definition out of the registry (the Data panel's Delete): what is made of it from then on is not. False for
+* one it has not. Not for a world that runs: its units of the type are there
+*
+* @beta
+*/
+function removeDefinition(registry, kind, id) {
+	return registry.kinds[kind].remove(id);
+}
+/**
+* The definition of a kind and id in the registry, as it is now, or undefined
+*
+* @beta
+*/
+function definitionIn(registry, kind, id) {
+	return registry.kinds[kind].find(id);
+}
+/**
+* Every definition of a kind the registry has
+*
+* @beta
+*/
+function definitionsIn(registry, kind) {
+	return registry.kinds[kind].all();
+}
+/** Puts what a save kept of the definitions changed while it ran back into the registry: before its entities are made */
+function restoreRedefinitions(registry, kept) {
+	if (!isRecord(kept)) return;
+	for (const kind of DATA_KINDS) {
+		const byId = kept[kind];
+		if (!isRecord(byId)) continue;
+		for (const [id, values] of Object.entries(byId)) if (isRecord(values)) redefineIn(registry, kind, id, values);
+	}
+}
+/** A path into a definition: names and places, joined by dots */
+/** A path into a definition, as the Data panel names a field: `stats.health` */
+var pathCheck = (value, path) => {
+	const text = string(value, path);
+	if (!/^[A-Za-z_$][\w$]*(\.[\w$]+)*$/.test(text)) throw new Invalid(`${path} is a path like stats.health`);
+	return text;
+};
+/** A value of a field the Data panel may set: a number, words, yes or no, a list of words, or a list of things whole */
+var valueCheck = (value, path) => {
+	if (isValue(value) && (typeof value !== "string" || value.length <= 200)) return value;
+	if (isWords(value) && value.length <= MAX_LIST && value.every((each) => each.length <= MAX_WORD)) return value;
+	if (isRows(value)) return value;
+	throw new Invalid(`${path} is a number, words, yes or no, a list of words, or a list of things`);
+};
+/** A definition changed while the game runs (`world.redefine`): to everyone, whose screens read the definitions */
+var toldRedefined = replicateEvent(definitionChanged, "redefined", ({ kind, id, values }) => values ? {
+	type: "redefined",
+	kind,
+	definition: id,
+	values: structuredClone(values)
+} : void 0);
+//#endregion
+export { COPY_OF, DATA_KINDS, NEW_DEFINITION, REQUIRED_FIELDS, blankDefinition, copyDefinition, dataEntriesProblem, dataRulesProblem, definitionChanged, definitionIn, definitionsIn, editableFields, editableValues, effectFields, effectTypesOf, fitValue, layData, layValues, mergeValues, nested, pathCheck, redefineIn, redefinitions, removeDefinition, restoreRedefinitions, toldRedefined, valueAt, valueCheck };
+
+//# sourceMappingURL=gameData.js.map