@v12-engine/engine 0.1.0 → 0.4.0

package/dist/rulesCheck.js

@@ -0,0 +1,693 @@
+import { EFFECT_MOMENTS, anyEffect, lowerChain, upgradesOf } from "./defs.js";
+import { callingsOf } from "./callings.js";
+import { BUFF_BREAKS, TRIGGER_TYPES } from "./abilities/triggers.js";
+import { AIM_KINDS } from "./targeting.js";
+import { editDistance, nearestId } from "./nearest.js";
+import { CONTROL_KINDS } from "./abilities/control.js";
+import { summonEffects } from "./summons.js";
+import { dispelEffects } from "./abilities/dispel.js";
+import { coreEffects } from "./abilities/effects/core.js";
+import { DATA_KINDS } from "./gameData.js";
+import { coreComponents } from "./coreComponents.js";
+//#region src/rulesCheck.ts
+/** The sizes each shape of an effect reads, without which it covers nothing (`EffectCommon.shape`) */
+var SHAPE_SIZES = {
+	circle: ["radius"],
+	cone: ["length", "angle"],
+	line: ["length"],
+	rect: ["length"],
+	ring: ["radius"],
+	arc: ["radius", "angle"],
+	cross: ["length"]
+};
+/** Which way a knockback may throw (`KnockbackDirection`, the moves pack's) */
+var KNOCKBACK_DIRECTIONS = [
+	"away",
+	"aim",
+	"over",
+	"towards"
+];
+/** The fields the moves pack reads (AB12), and of which effects */
+var MOVES_FIELDS = {
+	through: ["dash"],
+	collide: ["dash", "knockback"],
+	stops: ["dash", "knockback"],
+	direction: ["knockback"],
+	rider: ["attach"]
+};
+/** The moves pack's id (`MOVES`), said here so that the check does not bring the pack in with it */
+var MOVES = "core.moves";
+/** The ground objects pack's id (`GROUND_OBJECTS`), likewise */
+var GROUND_OBJECTS = "core.groundObjects";
+/** The resources pack's id (`RESOURCES`), likewise */
+var RESOURCES = "core.resources";
+/** The holds pack's id (`HOLDS`), likewise */
+var HOLDS = "core.holds";
+/** The ability changes pack's id (`ABILITY_CHANGES`), likewise */
+var ABILITY_CHANGES = "core.abilityChanges";
+/** The vision pack's id (`VISION`), likewise */
+var VISION = "core.vision";
+/**
+* Checks a game's rules against themselves (`RulesProblem`): run by a game's `check()` and as a page fetches its view, and in a
+* game's tests (`expect(checkRules(rules).filter((p) => p.level === 'error')).toEqual([])`). Nothing is thrown
+*
+* @public
+*/
+function checkRules(rules) {
+	const problems = [];
+	const ids = (list) => new Set((list ?? []).map((def) => def.id));
+	const units = ids(rules.units);
+	const abilities = ids(rules.abilities);
+	const buffs = ids(rules.buffs);
+	const items = ids(rules.items);
+	const upgrades = ids(rules.upgrades);
+	const resources = ids(rules.resources);
+	/** The callings heroes may have: the heroes pack's, or the engine's (`callingsOf`) */
+	const callings = ids(callingsOf(rules));
+	/** The components something can be given by id: the engine's own, its packs' and the game's */
+	const components = ids([
+		...coreComponents(),
+		...(rules.packs ?? []).flatMap((pack) => pack.components ?? []),
+		...rules.components ?? []
+	]);
+	/** The types of effect something handles: the engine's own, its packs' (`GamePack.effects`) and the game's (`Rules.effects`) */
+	const handled = new Set([
+		...coreEffects,
+		...summonEffects,
+		...dispelEffects,
+		...(rules.packs ?? []).flatMap((pack) => pack.effects ?? []),
+		...rules.effects ?? []
+	].map((kind) => kind.type));
+	const effectTypes = (type) => handled.has(type);
+	/** Whether the game has the moves pack (AB12), which reads the fields of `MOVES_FIELDS` */
+	const moves = (rules.packs ?? []).some((pack) => pack.id === MOVES);
+	/** Whether the game has the ground objects pack (AB13) */
+	const groundObjects = (rules.packs ?? []).some((pack) => pack.id === GROUND_OBJECTS);
+	/** Whether the game has the resources pack (AB14), and the pools its unit types have */
+	const resourcesOn = (rules.packs ?? []).some((pack) => pack.id === RESOURCES);
+	const poolIds = new Set(rules.units.flatMap((unit) => Object.keys(unit.pools ?? {})));
+	/** A pool named that no unit type has: what costs or gives it does nothing */
+	const pool = (where, id) => {
+		if (!poolIds.has(id)) odd(where, id, `${where} names the pool "${id}", which no unit type has (UnitTypeDef.pools): it does nothing`);
+	};
+	/** Whether the game has the holds pack (AB15) */
+	const holdsOn = (rules.packs ?? []).some((pack) => pack.id === HOLDS);
+	/** A field the resources pack reads, in a game without it */
+	const needsResources = (where, id) => {
+		if (!resourcesOn) odd(where, id, `${where} is read in a game with the resources pack (resourcesPack) alone: without it nothing reads it`);
+	};
+	/** Whether the game has the vision pack (AB18) */
+	const vision = (rules.packs ?? []).some((pack) => pack.id === VISION);
+	const known = (where, id, set, what) => {
+		if (id === void 0 || set.has(id)) return;
+		const meant = nearestId(id, set);
+		problems.push({
+			level: "error",
+			where,
+			id,
+			message: `${where} names "${id}", which is no ${what} of the rules${meant ? `. Did you mean "${meant}"?` : ""}`
+		});
+	};
+	/** A number that does not do what it is there for: said as a warning, the engine making do with it */
+	const odd = (where, id, message) => problems.push({
+		level: "warning",
+		where,
+		id,
+		message
+	});
+	/** Whether a number, or any of its levels (`Scaled`), is under a bound: at `least`, or above it where `above` */
+	const under = (value, least, above = false) => value !== void 0 && (Array.isArray(value) ? value : [value]).some((each) => above ? each <= least : each < least);
+	const all = (where, list, set, what) => list?.forEach((id, index) => known(`${where}[${index}]`, id, set, what));
+	/** The tags the unit types have (`UnitTypeDef.tags`): one named that none has is likely a slip (AB6) */
+	const tagged = new Set(rules.units.flatMap((unit) => unit.tags ?? []));
+	const tags = (where, list) => list?.forEach((tag, index) => {
+		if (!tagged.has(tag)) odd(`${where}[${index}]`, tag, `${where}[${index}] is "${tag}", a tag no unit type has (UnitTypeDef.tags)${nearestId(tag, tagged) ? `. Did you mean "${nearestId(tag, tagged)}"?` : ""}`);
+	});
+	/** A cleave (`AttackDef.cleave`, `BuffDef.cleave`) that reaches nobody or takes away */
+	const cleave = (where, id, value) => {
+		if (!value) return;
+		if (under(value.part, 0, true)) odd(`${where}.part`, id, `${where}.part is not above 0 at a level: it deals nothing to those around the target there`);
+		if (!(value.radius > 0)) odd(`${where}.radius`, id, `${where}.radius is not above 0: it reaches nobody around the target`);
+		if (value.angle !== void 0 && !(value.angle > 0)) odd(`${where}.angle`, id, `${where}.angle is not above 0: its cone reaches nobody`);
+	};
+	/** What a requirement names: a unit type (a building to have) or an upgrade */
+	const requirable = /* @__PURE__ */ new Set([...units, ...upgrades]);
+	for (const unit of rules.units) {
+		const at = `units.${unit.id}`;
+		all(`${at}.trains`, unit.trains, units, "unit type");
+		all(`${at}.targetableBy`, unit.targetableBy, abilities, "ability");
+		if (unit.targetableBy?.length === 0) odd(`${at}.targetableBy`, unit.id, "an empty list: nothing may target it, so no ability takes it (leave targetableBy out, or name one)");
+		all(`${at}.builds`, unit.builds, units, "unit type");
+		all(`${at}.hires`, unit.hires, units, "unit type");
+		all(`${at}.researches`, unit.researches, upgrades, "upgrade");
+		all(`${at}.requires`, unit.requires, requirable, "unit type or upgrade");
+		all(`${at}.sells`, unit.sells, items, "item");
+		all(`${at}.abilities`, unit.abilities, abilities, "ability");
+		if (typeof unit.upgradesTo === "string") known(`${at}.upgradesTo`, unit.upgradesTo, units, "unit type");
+		else all(`${at}.upgradesTo`, unit.upgradesTo, units, "unit type");
+		if (Array.isArray(unit.drops)) unit.drops.forEach((drop, index) => known(`${at}.drops[${index}].item`, drop.item, items, "item"));
+		known(`${at}.trigger.ability`, unit.trigger?.ability, abilities, "ability");
+		known(`${at}.use.ability`, unit.use?.ability, abilities, "ability");
+		known(`${at}.burst.ability`, unit.burst?.ability, abilities, "ability");
+		if (unit.trueSight !== void 0 && !vision) odd(`${at}.trueSight`, unit.id, `${at}.trueSight is read in a game with the vision pack (visionPack) alone: without it it finds nothing`);
+		for (const field of [
+			"trigger",
+			"use",
+			"blocksMissiles",
+			"burst"
+		]) if (unit[field] !== void 0 && !groundObjects) odd(`${at}.${field}`, unit.id, `${at}.${field} is read in a game with the ground objects pack (groundObjectsPack) alone: without it nothing reads it`);
+		if (unit.trigger?.by !== void 0 && ![
+			"enemies",
+			"allies",
+			"all",
+			"maker"
+		].includes(unit.trigger.by)) odd(`${at}.trigger.by`, unit.id, `${at}.trigger.by is enemies, allies, all or maker: "${unit.trigger.by}" is none, enemies are`);
+		if (unit.use?.by !== void 0 && ![
+			"enemies",
+			"allies",
+			"all"
+		].includes(unit.use.by)) odd(`${at}.use.by`, unit.id, `${at}.use.by is enemies, allies or all: "${unit.use.by}" is none, allies are`);
+		if (unit.blocksMissiles !== void 0 && !["enemies", "all"].includes(unit.blocksMissiles)) odd(`${at}.blocksMissiles`, unit.id, `${at}.blocksMissiles is enemies or all: "${unit.blocksMissiles}" stops nothing`);
+		if (unit.pools) {
+			needsResources(`${at}.pools`, unit.id);
+			for (const [id, def] of Object.entries(unit.pools)) {
+				if (!(def.max > 0)) odd(`${at}.pools.${id}.max`, unit.id, `${at}.pools.${id}.max is not above 0: it never holds anything`);
+				def.thresholds?.forEach((threshold, index) => {
+					known(`${at}.pools.${id}.thresholds[${index}].buff`, threshold.buff, buffs, "buff");
+					if (threshold.at > def.max) odd(`${at}.pools.${id}.thresholds[${index}].at`, unit.id, `${at}.pools.${id}.thresholds[${index}].at is over its max (${def.max}): it is never reached`);
+				});
+			}
+		}
+		unit.attacks?.forEach((attack, index) => {
+			cleave(`${at}.attacks[${index}].cleave`, unit.id, attack.cleave);
+			if (attack.cleave && attack.projectileSpeed) odd(`${at}.attacks[${index}].cleave`, unit.id, `${at}.attacks[${index}] flies (projectileSpeed): only a blow from up close cleaves, so it never does`);
+		});
+		if (unit.attackCost) {
+			needsResources(`${at}.attackCost`, unit.id);
+			for (const id in unit.attackCost) if (!unit.pools?.[id]) odd(`${at}.attackCost.${id}`, id, `${at}.attackCost names the pool "${id}", which it has not (pools): it never attacks`);
+		}
+		if (unit.hero) {
+			all(`${at}.hero.learns`, unit.hero.learns, abilities, "ability");
+			all(`${at}.hero.spells`, unit.hero.spells, abilities, "ability");
+			known(`${at}.hero.innate`, unit.hero.innate, abilities, "ability");
+			if (unit.hero.innate && unit.hero.learns.includes(unit.hero.innate)) odd(`${at}.hero.innate`, unit.hero.innate, `${unit.hero.innate} is its innate and one it learns: points put into it are lost as the innate keeps its own level`);
+			known(`${at}.hero.meter`, unit.hero.meter, buffs, "buff");
+			for (const [calling, strength] of Object.entries(unit.hero.callings ?? {})) {
+				known(`${at}.hero.callings`, calling, callings, "calling");
+				if (![
+					1,
+					2,
+					3
+				].includes(strength)) odd(`${at}.hero.callings.${calling}`, calling, `a calling's strength is 1, 2 or 3: ${String(strength)} is shown as ${Math.min(Math.max(Math.round(Number(strength) || 1), 1), 3)}`);
+			}
+			for (const [into, form] of Object.entries(unit.hero.forms ?? {})) {
+				known(`${at}.hero.forms`, into, units, "unit type");
+				all(`${at}.hero.forms.${into}.learns`, form.learns, abilities, "ability");
+				if (form.cooldowns !== void 0 && ![
+					"keep",
+					"reset",
+					"shared"
+				].includes(form.cooldowns)) odd(`${at}.hero.forms.${into}.cooldowns`, String(form.cooldowns), `cooldowns is keep, reset or shared: ${String(form.cooldowns)} is none, the default is used`);
+				if (form.cooldowns === "shared" && !Object.values(form.levels ?? {}).some((by) => typeof by === "string") && (form.levels !== void 0 || form.keeps !== void 0)) odd(`${at}.hero.forms.${into}.cooldowns`, "shared", "shared needs an ability of the form whose level is one of the hero’s own (levels): nothing is shared");
+				all(`${at}.hero.forms.${into}.keeps`, form.keeps, abilities, "ability");
+				const own = /* @__PURE__ */ new Set([
+					...unit.hero.learns,
+					...unit.hero.spells ?? [],
+					...unit.abilities ?? []
+				]);
+				for (const id of form.keeps ?? []) if (abilities.has(id) && !own.has(id)) odd(`${at}.hero.forms.${into}.keeps`, id, `${id} is not ${unit.id}'s own: the form keeps nothing of it`);
+				for (const [id, by] of Object.entries(form.levels ?? {})) {
+					if (!(form.learns ?? []).includes(id)) odd(`${at}.hero.forms.${into}.levels`, id, `${id} is not one the form learns (its learns)`);
+					if (typeof by !== "string") continue;
+					known(`${at}.hero.forms.${into}.levels.${id}`, by, abilities, "ability");
+					if (abilities.has(by) && !own.has(by)) odd(`${at}.hero.forms.${into}.levels.${id}`, by, `${by} is not ${unit.id}'s own: ${id} starts at 0`);
+				}
+			}
+		}
+	}
+	const effects = (where, list) => {
+		if (list) lowerChain(list, (index, effect) => {
+			const at = `${where}[${index}].when`;
+			const moment = Object.hasOwn(EFFECT_MOMENTS, effect.when) ? EFFECT_MOMENTS[effect.when] : void 0;
+			problems.push({
+				level: "error",
+				where: at,
+				id: effect.type,
+				message: moment ? `${at} is "${effect.when}", but nothing before it in its list comes to that (${moment.types.join(" or ")}): it never happens` : `${at} is "${effect.when}", which is no moment (${Object.keys(EFFECT_MOMENTS).join(", ")}): it never happens`
+			});
+		});
+		list?.map(anyEffect).forEach((effect, index) => {
+			const at = `${where}[${index}]`;
+			if (!effectTypes(effect.type)) problems.push({
+				level: "error",
+				where: `${at}.type`,
+				id: effect.type,
+				message: `${at} is of the type "${effect.type}", which nothing handles (Rules.effects)`
+			});
+			known(`${at}.buff`, effect.buff, buffs, "buff");
+			known(`${at}.ifBuff`, effect.ifBuff, buffs, "buff");
+			tags(`${at}.tags`, effect.tags);
+			for (const who of [
+				"caster",
+				"target",
+				"where"
+			]) {
+				const condition = effect[who];
+				if (condition === void 0) continue;
+				if (who !== "where" && effect.type !== "if") odd(`${at}.${who}`, effect.type, `${at}.${who} is read of an if alone, not of ${effect.type}`);
+				if (typeof condition === "function") continue;
+				known(`${at}.${who}.buff`, condition.buff, buffs, "buff");
+				known(`${at}.${who}.noBuff`, condition.noBuff, buffs, "buff");
+				tags(`${at}.${who}.tags`, condition.tags);
+				tags(`${at}.${who}.notTags`, condition.notTags);
+				if (condition.is !== void 0 && condition.is !== "enemy" && condition.is !== "ally") odd(`${at}.${who}.is`, String(condition.is), `${at}.${who}.is is enemy or ally: "${String(condition.is)}" never holds`);
+			}
+			if (effect.as !== void 0 && effect.as !== "themselves") odd(`${at}.as`, String(effect.as), `${at}.as is "themselves" or left out: "${String(effect.as)}" is none, its unit rises`);
+			if (effect.type === "raiseDead" && effect.unit === void 0 && effect.as !== "themselves") problems.push({
+				level: "error",
+				where: `${at}.unit`,
+				id: effect.type,
+				message: `${at} raises no unit and not the dead as themselves (as): nothing rises`
+			});
+			if (effect.health !== void 0 && !(effect.health > 0 && effect.health <= 1)) odd(`${at}.health`, effect.type, `${at}.health is a share of its max health above 0 and at most 1: it is left with 1 health`);
+			if (effect.type === "if" && effect.caster === void 0 && effect.target === void 0 && effect.chance === void 0) odd(`${at}`, effect.type, `${at} asks nothing (caster, target, chance): its effects always happen`);
+			if (effect.chance !== void 0 && typeof effect.chance !== "function" && [effect.chance].flat().some((share) => !(share >= 0 && share <= 1))) odd(`${at}.chance`, effect.type, `${at}.chance is a share from 0 to 1 (0.25: one in four): under 0 it never happens, over 1 always`);
+			if ((effect.sort !== void 0 || effect.limit !== void 0) && effect.radius === void 0 && effect.shape === void 0) odd(`${at}.limit`, effect.type, `${at}.sort and .limit choose of what an area reaches: with no radius or shape it hits its one target anyway`);
+			if (effect.limit !== void 0 && [effect.limit].flat().some((count) => !(count >= 1))) odd(`${at}.limit`, effect.type, `${at}.limit is how many it hits, 1 or more: under 1 it hits nothing`);
+			known(`${at}.whileBuff`, effect.whileBuff, buffs, "buff");
+			if (effect.pool !== void 0) pool(`${at}.pool`, effect.pool);
+			known(`${at}.from`, effect.from, abilities, "ability");
+			for (const field of [
+				"from",
+				"uses",
+				"atLevel",
+				"pick"
+			]) if (effect[field] !== void 0 && ![
+				"grantAbility",
+				"swapAbility",
+				"stealAbility"
+			].includes(effect.type)) odd(`${at}.${field}`, effect.type, `${at}.${field} is read of grantAbility, swapAbility and stealAbility alone, not of ${effect.type}`);
+			if (effect.pick !== void 0 && ![
+				"ultimate",
+				"first",
+				"random"
+			].includes(effect.pick)) odd(`${at}.pick`, effect.type, `${at}.pick is ultimate, first or random: "${effect.pick}" is none, the ultimate is taken`);
+			known(`${at}.unit`, effect.unit, units, "unit type");
+			known(`${at}.into`, effect.into, units, "unit type");
+			if (effect.data) for (const id of Object.keys(effect.data)) known(`${at}.data.${id}`, id, components, "component");
+			known(`${at}.ability`, effect.ability, abilities, "ability");
+			known(`${at}.sell`, effect.sell, resources, "resource");
+			known(`${at}.buy`, effect.buy, resources, "resource");
+			for (const field of [
+				"arc",
+				"bounce",
+				"falloff",
+				"hitsOnReturn",
+				"seek",
+				"split",
+				"steer"
+			]) if (effect[field] !== void 0 && effect.type !== "missile") odd(`${at}.${field}`, effect.type, `${at}.${field} is read of a missile alone, not of ${effect.type}`);
+			if (effect.onWall !== void 0 && ![
+				"missile",
+				"dash",
+				"knockback"
+			].includes(effect.type)) odd(`${at}.onWall`, effect.type, `${at}.onWall is read of a missile, a dash and a knockback alone, not of ${effect.type}`);
+			for (const field of [
+				"through",
+				"collide",
+				"stops",
+				"direction",
+				"rider"
+			]) {
+				if (effect[field] === void 0) continue;
+				const of = MOVES_FIELDS[field];
+				if (!of.includes(effect.type)) odd(`${at}.${field}`, effect.type, `${at}.${field} is read of ${of.join(" and ")} alone, not of ${effect.type}`);
+				else if (!moves) odd(`${at}.${field}`, effect.type, `${at}.${field} is read in a game with the moves pack (movesPack) alone: without it nothing reads it`);
+			}
+			if (effect.type === "dash" && (effect.to === "target" || effect.onWall) && !moves) odd(`${at}.${effect.to === "target" ? "to" : "onWall"}`, effect.type, `${at} rushes to a unit or sees to a wall, which a dash does in a game with the moves pack (movesPack) alone`);
+			if (effect.type === "knockback" && effect.onWall && !moves) odd(`${at}.onWall`, effect.type, `${at}.onWall is read of a knockback in a game with the moves pack (movesPack) alone`);
+			if (effect.direction !== void 0 && !KNOCKBACK_DIRECTIONS.includes(effect.direction)) problems.push({
+				level: "error",
+				where: `${at}.direction`,
+				id: effect.direction,
+				message: `${at}.direction is "${effect.direction}", which is no way to throw (${KNOCKBACK_DIRECTIONS.join(", ")})`
+			});
+			if (effect.through !== void 0 && effect.to !== "target") odd(`${at}.through`, effect.type, `${at}.through is there, but it does not rush to a unit (to: 'target'): it goes through nobody`);
+			for (const field of ["line", "ring"]) {
+				if (effect[field] === void 0) continue;
+				if (effect.type !== "spawn") odd(`${at}.${field}`, effect.type, `${at}.${field} is read of a spawn alone, not of ${effect.type}`);
+				else if (!groundObjects) odd(`${at}.${field}`, effect.type, `${at}.${field} is read in a game with the ground objects pack (groundObjectsPack) alone: without it one is made`);
+				else if (!(effect[field].count >= 1)) odd(`${at}.${field}.count`, effect.type, `${at}.${field}.count is under 1: one is made`);
+			}
+			if (effect.stops && !effect.collide?.length) odd(`${at}.stops`, effect.type, `${at}.stops is there, but nothing happens to who it meets (collide): it never stops`);
+			for (const field of [
+				"follow",
+				"onEnter",
+				"onLeave",
+				"edge"
+			]) if (effect[field] !== void 0 && effect.type !== "zone") odd(`${at}.${field}`, effect.type, `${at}.${field} is read of a zone alone, not of ${effect.type}`);
+			if (effect.type === "zone" && (effect.onEnter || effect.onLeave || effect.edge) && !effect.radius && !effect.shape) odd(`${at}.radius`, effect.type, `${at} sees to who comes and goes, but has no radius or shape of its own: nobody is ever in it`);
+			if (effect.hitsOnReturn && !effect.returns) odd(`${at}.hitsOnReturn`, effect.type, `${at}.hitsOnReturn is there, but it does not come back (returns): it never hits on a way back`);
+			if (effect.seek !== void 0 && !(effect.seek > 0)) odd(`${at}.seek`, effect.type, `${at}.seek is not above 0: it finds nobody`);
+			if (typeof effect.pierce === "number" && !(effect.pierce >= 0)) odd(`${at}.pierce`, effect.type, `${at}.pierce is under 0: it is used up by the first it hits`);
+			if (effect.arc && !(effect.arc.height > 0)) odd(`${at}.arc.height`, effect.type, `${at}.arc.height is not above 0: it is thrown flat`);
+			if (effect.arc?.time !== void 0 && !(effect.arc.time > 0)) odd(`${at}.arc.time`, effect.type, `${at}.arc.time is not above 0: it flies at its speed`);
+			if (effect.bounce && under(effect.bounce.count, 1)) odd(`${at}.bounce.count`, effect.type, `${at}.bounce.count is under 1 at a level: it does not spring on there`);
+			if (effect.bounce && !(effect.bounce.range > 0)) odd(`${at}.bounce.range`, effect.type, `${at}.bounce.range is not above 0: it finds nothing to spring to`);
+			if (effect.shape !== void 0) {
+				const sizes = SHAPE_SIZES[effect.shape];
+				if (!sizes) {
+					const meant = nearestId(effect.shape, new Set(Object.keys(SHAPE_SIZES)));
+					problems.push({
+						level: "error",
+						where: `${at}.shape`,
+						id: effect.shape,
+						message: `${at}.shape is "${effect.shape}", which is no shape (${Object.keys(SHAPE_SIZES).join(", ")}): it covers nothing${meant ? `. Did you mean "${meant}"?` : ""}`
+					});
+				} else for (const size of sizes) if (effect[size] === void 0) odd(`${at}.${size}`, effect.type, `${at} is a ${effect.shape} with no ${size}: it covers nothing`);
+			}
+			if (effect.origin) {
+				const { origin } = effect;
+				known(`${at}.origin.proxy`, origin.proxy, units, "unit type");
+				if (origin.pick !== void 0 && ![
+					"nearest",
+					"all",
+					"newest",
+					"oldest"
+				].includes(origin.pick)) odd(`${at}.origin.pick`, effect.type, `${at}.origin.pick is nearest, all, newest or oldest: "${origin.pick}" is none, the nearest is picked`);
+				if (origin.at !== void 0 && !["aim", "proxy"].includes(origin.at)) odd(`${at}.origin.at`, effect.type, `${at}.origin.at is aim or proxy: "${origin.at}" is none, it lands where it was aimed`);
+				if (origin.caster !== void 0 && origin.caster !== true && origin.caster !== false && origin.caster !== "otherwise") odd(`${at}.origin.caster`, effect.type, `${at}.origin.caster is true, false or otherwise: "${String(origin.caster)}" is none`);
+			}
+			if (effect.type === "sendProxy" && !effect.origin) odd(`${at}.origin`, effect.type, `${at} sends the unit it goes off from, but has no origin: it goes off from the caster, and sends nothing`);
+			effects(`${at}.effects`, effect.effects);
+			effects(`${at}.onEnd`, effect.onEnd);
+			effects(`${at}.otherwise`, effect.otherwise);
+			for (const list of [
+				"onWall",
+				"split",
+				"onEnter",
+				"onLeave",
+				"edge",
+				"collide"
+			]) effects(`${at}.${list}`, effect[list]);
+		});
+	};
+	/** The ways an ability may be aimed: the engine's (`AimKind`) and the game's own (`Rules.targetings`) */
+	const aimings = /* @__PURE__ */ new Set([...AIM_KINDS, ...(rules.targetings ?? []).map((targeting) => targeting.id)]);
+	for (const ability of rules.abilities ?? []) {
+		const at = `abilities.${ability.id}`;
+		known(`${at}.target`, ability.target, aimings, "way of aiming");
+		known(`${at}.charge`, ability.charge, buffs, "buff");
+		tags(`${at}.targets.tags`, ability.targets?.tags);
+		const { recast } = ability;
+		if (recast) {
+			if (ability.target === "passive") odd(`${at}.recast`, ability.id, `${at} is passive: it is never cast, nor cast again`);
+			if (under(recast.window, 0, true)) odd(`${at}.recast.window`, ability.id, `${at}.recast.window is not above 0 at a level: it is never cast again there`);
+			if (recast.count !== void 0 && !(recast.count >= 1)) odd(`${at}.recast.count`, ability.id, `${at}.recast.count is under 1: it is cast again once`);
+			known(`${at}.recast.target`, recast.target, aimings, "way of aiming");
+			known(`${at}.recast.mark`, recast.mark, buffs, "buff");
+			if (recast.cooldown !== void 0 && recast.cooldown !== "after" && recast.cooldown !== "first") odd(`${at}.recast.cooldown`, String(recast.cooldown), `${at}.recast.cooldown is after or first: "${String(recast.cooldown)}" is none, after is taken`);
+			effects(`${at}.recast.effects`, recast.effects);
+		}
+		if (ability.charges && under(ability.charges.count, 1)) odd(`${at}.charges.count`, ability.id, `${at}.charges.count is under 1 at a level: it holds 1 there`);
+		if (ability.charges && under(ability.charges.refill, 0, true)) odd(`${at}.charges.refill`, ability.id, `${at}.charges.refill is not above 0 at a level: a use comes back at once there`);
+		effects(`${at}.effects`, ability.effects);
+		effects(`${at}.passive`, ability.passive);
+		for (const field of ["cost", "gain"]) {
+			if (!ability[field]) continue;
+			needsResources(`${at}.${field}`, ability.id);
+			for (const id in ability[field]) pool(`${at}.${field}.${id}`, id);
+		}
+		if (ability.costGrowth) {
+			needsResources(`${at}.costGrowth`, ability.id);
+			known(`${at}.costGrowth.buff`, ability.costGrowth.buff, buffs, "buff");
+		}
+		const withHolds = (where) => {
+			if (!holdsOn) odd(where, ability.id, `${where} is read in a game with the holds pack (holdsPack) alone: without it nothing reads it`);
+		};
+		if (ability.hold) {
+			withHolds(`${at}.hold`);
+			known(`${at}.hold.buff`, ability.hold.buff, buffs, "buff");
+			effects(`${at}.hold.tap.effects`, ability.hold.tap?.effects);
+			if (!(ability.hold.max > 0)) odd(`${at}.hold.max`, ability.id, `${at}.hold.max is not above 0: it is full at once`);
+			if (ability.target === "unit" || ability.target === "passive" || ability.target === "vector") odd(`${at}.hold`, ability.id, `${at}.hold is there, but it is aimed at ${ability.target === "passive" ? "nothing (passive)" : `a ${ability.target}`}: a hold is let go at a point, a way or on the spot`);
+			if (ability.channel) odd(`${at}.hold`, ability.id, `${at}.hold and a channel: the hold goes off as it is let go, and its channel after`);
+		}
+		all(`${at}.upgrades`, ability.upgrades, abilities, "ability");
+		if (ability.upgrades && !(rules.packs ?? []).some((pack) => pack.id === ABILITY_CHANGES)) odd(`${at}.upgrades`, ability.id, `${at}.upgrades is read in a game with the ability changes pack (abilityChangesPack) alone: nothing makes it into them without it`);
+		if (ability.channel?.aimed) withHolds(`${at}.channel.aimed`);
+		if (ability.channel?.walks) withHolds(`${at}.channel.walks`);
+		if (ability.channel?.leash !== void 0 && ability.target !== "unit") odd(`${at}.channel.leash`, ability.id, `${at}.channel.leash is there, but it is not cast on a unit: it is tied to nobody`);
+	}
+	for (const buff of rules.buffs ?? []) {
+		const at = `buffs.${buff.id}`;
+		if (buff.drain) {
+			needsResources(`${at}.drain`, buff.id);
+			for (const id in buff.drain) if (id !== "mana") pool(`${at}.drain.${id}`, id);
+		}
+		if (Array.isArray(buff.onApply)) effects(`${at}.onApply`, buff.onApply);
+		effects(`${at}.onTick.effects`, buff.onTick?.effects);
+		effects(`${at}.passive`, buff.passive);
+		effects(`${at}.onCarrierDeath`, buff.onCarrierDeath);
+		effects(`${at}.onMaxStacks`, buff.onMaxStacks);
+		buff.passive?.forEach((effect, index) => {
+			if (!TRIGGER_TYPES.includes(effect.type)) odd(`${at}.passive[${index}]`, effect.type, `${at}.passive[${index}] is a ${effect.type}: only triggers go off from a buff's passive (${TRIGGER_TYPES.join(", ")})`);
+		});
+		buff.breaksOn?.forEach((by, index) => {
+			if (!BUFF_BREAKS.includes(by)) odd(`${at}.breaksOn[${index}]`, String(by), `${at}.breaksOn[${index}] is "${String(by)}", which is no way a buff breaks (${BUFF_BREAKS.join(", ")}): it never breaks on it`);
+		});
+		if (typeof buff.control === "string" && !CONTROL_KINDS.includes(buff.control)) odd(`${at}.control`, String(buff.control), `${at}.control is "${String(buff.control)}", which is no control (${CONTROL_KINDS.join(", ")}): it takes no orders`);
+		if (buff.minHealth !== void 0 && typeof buff.minHealth !== "function" && under(buff.minHealth, 0)) odd(`${at}.minHealth`, buff.id, `${at}.minHealth is under 0 at a level: it keeps its carrier at nothing there`);
+		if (buff.onMaxStacks && buff.maxStacks === void 0) odd(`${at}.onMaxStacks`, buff.id, `${at}.onMaxStacks needs a maxStacks to come to: it never happens`);
+		for (const field of [
+			"revealed",
+			"camouflage",
+			"trueSight"
+		]) if (buff[field] !== void 0 && buff[field] !== false && !vision) odd(`${at}.${field}`, buff.id, `${at}.${field} is read in a game with the vision pack (visionPack) alone: without it nothing reads it`);
+		cleave(`${at}.cleave`, buff.id, buff.cleave);
+		if (buff.overheal) {
+			known(`${at}.overheal.buff`, buff.overheal.buff, buffs, "buff");
+			if (under(buff.overheal.part, 0, true)) odd(`${at}.overheal.part`, buff.id, `${at}.overheal.part is not above 0 at a level: no healing past full health becomes a shield there`);
+			if (buff.overheal.most !== void 0 && !(buff.overheal.most > 0)) odd(`${at}.overheal.most`, buff.id, `${at}.overheal.most is not above 0: the shield it makes holds nothing`);
+			if (buff.overheal.of !== void 0 && !["given", "taken"].includes(buff.overheal.of)) odd(`${at}.overheal.of`, buff.id, `${at}.overheal.of is given or taken: "${String(buff.overheal.of)}" is neither, given is meant`);
+		}
+		if (typeof buff.paysWithHealth === "number" && !(buff.paysWithHealth > 0)) odd(`${at}.paysWithHealth`, buff.id, `${at}.paysWithHealth is not above 0: its carrier pays nothing for its abilities, of health or mana`);
+		if (typeof buff.camouflage === "number" && !(buff.camouflage >= 0)) odd(`${at}.camouflage`, buff.id, `${at}.camouflage is under 0: its enemies never see it, even from up close`);
+	}
+	for (const race of rules.races ?? []) {
+		const start = race.startingBase;
+		if (!start || "spawn" in start) continue;
+		const at = `races.${race.id}.startingBase`;
+		known(`${at}.hall`, start.hall, units, "unit type");
+		known(`${at}.workers.type`, start.workers?.type, units, "unit type");
+		known(`${at}.onMine`, start.onMine, units, "unit type");
+		start.units?.forEach((each, index) => known(`${at}.units[${index}].type`, each.type, units, "unit type"));
+	}
+	for (const item of rules.items ?? []) {
+		const at = `items.${item.id}`;
+		known(`${at}.ability`, item.ability, abilities, "ability");
+		known(`${at}.passive`, item.passive, abilities, "ability");
+		all(`${at}.from`, item.from, items, "item");
+	}
+	itemProblems(rules, problems, odd);
+	for (const upgrade of rules.upgrades ?? []) {
+		const at = `upgrades.${upgrade.id}`;
+		upgrade.requires?.forEach((level, index) => all(`${at}.requires[${index}]`, level, requirable, "unit type or upgrade"));
+		upgrade.effects.forEach((effect, index) => {
+			if (Array.isArray(effect.units)) all(`${at}.effects[${index}].units`, effect.units, units, "unit type");
+		});
+	}
+	const needs = /* @__PURE__ */ new Map();
+	for (const unit of rules.units) if (unit.requires?.length) needs.set(unit.id, unit.requires);
+	for (const upgrade of rules.upgrades ?? []) if (upgrade.requires?.[0]?.length) needs.set(upgrade.id, upgrade.requires[0]);
+	const reported = /* @__PURE__ */ new Set();
+	for (const start of needs.keys()) {
+		const loop = cycleFrom(start, needs);
+		if (!loop) continue;
+		const key = [...loop].sort().join(",");
+		if (reported.has(key)) continue;
+		reported.add(key);
+		problems.push({
+			level: "error",
+			where: `requires`,
+			id: start,
+			message: `What is required waits on itself: ${[...loop, loop[0]].join(" → ")}. None of them can be had`
+		});
+	}
+	const made = /* @__PURE__ */ new Set();
+	for (const unit of rules.units) {
+		for (const id of [
+			...unit.trains ?? [],
+			...unit.builds ?? [],
+			...unit.hires ?? [],
+			...unit.researches ?? []
+		]) made.add(id);
+		for (const id of upgradesOf(unit)) made.add(id);
+	}
+	for (const unit of rules.units) {
+		if (!unit.cost || made.has(unit.id)) continue;
+		problems.push({
+			level: "warning",
+			where: `units.${unit.id}`,
+			id: unit.id,
+			message: `units.${unit.id} has a cost, and nothing trains, builds or hires it`
+		});
+	}
+	for (const upgrade of rules.upgrades ?? []) {
+		if (made.has(upgrade.id)) continue;
+		problems.push({
+			level: "warning",
+			where: `upgrades.${upgrade.id}`,
+			id: upgrade.id,
+			message: `upgrades.${upgrade.id} is researched nowhere (UnitTypeDef.researches)`
+		});
+	}
+	const had = /* @__PURE__ */ new Set();
+	for (const unit of rules.units) for (const id of [
+		...unit.abilities ?? [],
+		...unit.hero?.learns ?? [],
+		...unit.hero?.spells ?? [],
+		...unit.hero?.innate ? [unit.hero.innate] : [],
+		...Object.values(unit.hero?.forms ?? {}).flatMap((form) => form.learns ?? [])
+	]) had.add(id);
+	for (const item of rules.items ?? []) for (const id of [item.ability, item.passive]) if (id) had.add(id);
+	const named = (ability) => {
+		const walk = (list) => list?.map(anyEffect).forEach((effect) => (effect.ability && had.add(effect.ability), walk(effect.otherwise)));
+		walk(ability.effects);
+		walk(ability.passive);
+	};
+	for (const ability of rules.abilities ?? []) named(ability);
+	const offered = new Set(rules.defaults?.added.abilities ?? []);
+	for (const ability of rules.abilities ?? []) {
+		if (had.has(ability.id) || offered.has(ability.id)) continue;
+		problems.push({
+			level: "warning",
+			where: `abilities.${ability.id}`,
+			id: ability.id,
+			message: `abilities.${ability.id} is on no unit, hero or item`
+		});
+	}
+	return problems.map((problem) => {
+		const at = locate(rules, problem.where);
+		return at ? {
+			...problem,
+			at
+		} : problem;
+	});
+}
+/** The engine's limits of groups of items (`ItemSettings.groups`), said here so that the check loads none of the rules */
+var GROUP_LIMITS = { boots: 1 };
+/**
+* What does not fit in a game's items (items-and-spells plan, phase 5): a build tree that loops (an error: no price can
+* be worked out), a recipe of more of a group than a hero may carry (an error: its parts are never all carried), and as
+* warnings a price under its parts', an item nothing sells or drops (in a game that sells or drops any), numbers that
+* do nothing, callings no hero has
+*/
+function itemProblems(rules, problems, odd) {
+	const list = rules.items ?? [];
+	const byId = new Map(list.map((item) => [item.id, item]));
+	const currency = rules.currency ?? rules.resources?.[0]?.id;
+	const price = (id) => currency ? byId.get(id)?.cost[currency] ?? 0 : 0;
+	const groups = {
+		...GROUP_LIMITS,
+		...rules.settings?.items?.groups
+	};
+	const limitOf = (group, own) => own ?? groups[group] ?? 1;
+	const parts = new Map(list.filter((item) => item.from?.length).map((item) => [item.id, item.from.filter((part) => byId.has(part))]));
+	const looped = /* @__PURE__ */ new Set();
+	for (const start of parts.keys()) {
+		const loop = cycleFrom(start, parts);
+		if (!loop) continue;
+		const key = [...loop].sort().join(",");
+		if (looped.has(key)) continue;
+		looped.add(key);
+		problems.push({
+			level: "error",
+			where: `items.${start}.from`,
+			id: start,
+			message: `The build tree goes round: ${[...loop, loop[0]].join(" → ")}. None of them can be priced or bought`
+		});
+	}
+	const inLoop = new Set([...looped].flatMap((key) => key.split(",")));
+	const sold = new Set(rules.units.flatMap((unit) => unit.sells ?? []));
+	const dropped = new Set(rules.units.flatMap((unit) => Array.isArray(unit.drops) ? unit.drops.map((drop) => drop.item) : []));
+	const dealt = sold.size > 0 || dropped.size > 0;
+	const dropsInCode = rules.units.some((unit) => typeof unit.drops === "function");
+	const callings = suitedCallings(rules);
+	for (const item of list) {
+		const at = `items.${item.id}`;
+		const from = item.from?.filter((part) => byId.has(part)) ?? [];
+		if (from.length && currency && !inLoop.has(item.id)) {
+			const sum = from.reduce((total, part) => total + price(part), 0);
+			if (price(item.id) < sum) odd(`${at}.cost`, item.id, `${at}.cost (${price(item.id)} ${currency}) is under what its parts cost together (${sum}): building it pays the buyer`);
+		}
+		for (const group of new Set(from.map((part) => byId.get(part).group).filter((group) => group !== void 0))) {
+			const count = from.filter((part) => byId.get(part).group === group).length;
+			const limit = limitOf(group, from.map((part) => byId.get(part)).find((part) => part.group === group)?.groupLimit);
+			if (count > limit) problems.push({
+				level: "error",
+				where: `${at}.from`,
+				id: item.id,
+				message: `${at}.from has ${count} of the group "${group}", and a hero carries ${limit} at most: its parts are never all carried`
+			});
+		}
+		if (dealt && !item.powerUp && !sold.has(item.id) && !dropped.has(item.id) && !dropsInCode) odd(at, item.id, `${at} is sold by no shop and dropped by nothing (UnitTypeDef.sells, drops): nobody gets it but by code or a map`);
+		if (item.group !== void 0 && item.groupLimit !== void 0 && !(item.groupLimit >= 1)) odd(`${at}.groupLimit`, item.id, `${at}.groupLimit is under 1: nobody may carry it`);
+		if (item.groupLimit !== void 0 && item.group === void 0) odd(`${at}.groupLimit`, item.id, `${at}.groupLimit is there, but it is of no group: nothing limits it`);
+		if (item.stack !== void 0 && !item.charges) odd(`${at}.stack`, item.id, `${at}.stack is there, but it has no charges: what stacks is its charges, so nothing does`);
+		if (item.stack !== void 0 && !(item.stack >= 1)) odd(`${at}.stack`, item.id, `${at}.stack is under 1: one goes in a slot`);
+		if (item.refill !== void 0 && !item.charges) odd(`${at}.refill`, item.id, `${at}.refill is there, but it has no charges to come back`);
+		if (item.sellRate !== void 0 && !(item.sellRate >= 0)) odd(`${at}.sellRate`, item.id, `${at}.sellRate is under 0: selling it costs its seller`);
+		if (item.unique !== void 0 && !item.passive) odd(`${at}.unique`, item.id, `${at}.unique names its passive, and it has none (passive): it does nothing`);
+		if (callings) item.suits?.forEach((calling, index) => {
+			if (!callings.has(calling)) odd(`${at}.suits[${index}]`, calling, `${at}.suits[${index}] is "${calling}", which is no calling of the game${nearestId(calling, callings) ? `. Did you mean "${nearestId(calling, callings)}"?` : ""}`);
+		});
+	}
+}
+/**
+* The callings of a game's heroes, where it has them: the rules' (`callings`) or a pack's that keeps them
+* (`heroesPack({ callings })`). None for a game without, whose items' `suits` go unchecked
+*/
+function suitedCallings(rules) {
+	const own = rules.callings;
+	const ids = (Array.isArray(own) ? [own] : (rules.packs ?? []).map((each) => each.callings)).flatMap((list) => Array.isArray(list) ? list.flatMap((def) => typeof def === "string" ? [def] : typeof def?.id === "string" ? [def.id] : []) : []);
+	return ids.length ? new Set(ids) : void 0;
+}
+/**
+* The definition and field a place in the rules is (`abilities.holy-light.effects[0].buff`): the kind, the longest id
+* of it the place begins with (an id may have dots), and the rest as a path of the Data panel's (`effects.0.buff`)
+*/
+function locate(rules, where) {
+	const dot = where.indexOf(".");
+	const kind = where.slice(0, dot);
+	if (dot < 0 || !DATA_KINDS.includes(kind)) return void 0;
+	const rest = where.slice(dot + 1);
+	const id = (rules[kind] ?? []).map((def) => def.id).filter((each) => rest === each || rest.startsWith(`${each}.`)).sort((a, b) => b.length - a.length)[0];
+	if (id === void 0) return void 0;
+	return {
+		kind,
+		id,
+		path: rest.slice(id.length + 1).replace(/\[(\d+)\]/g, ".$1")
+	};
+}
+/** A loop of requirements through `start`, in order, or none */
+function cycleFrom(start, needs) {
+	const path = [];
+	const seen = /* @__PURE__ */ new Set();
+	const visit = (id) => {
+		if (id === start && path.length) return [...path];
+		if (seen.has(id)) return void 0;
+		seen.add(id);
+		path.push(id);
+		for (const next of needs.get(id) ?? []) {
+			const found = visit(next);
+			if (found) return found;
+		}
+		path.pop();
+	};
+	return visit(start);
+}
+//#endregion
+export { checkRules, editDistance };
+
+//# sourceMappingURL=rulesCheck.js.map